నా కోడింగ్ ఏజెంట్ సెషన్లను గుర్తుంచుకుంది, పనిని కాదు
ఒక కోడింగ్ ఏజెంట్ థ్రెడ్ను సజీవంగా ఉంచగలదు, కానీ మళ్ళీ మళ్ళీ మర్చిపోతున్నట్లు అనిపించవచ్చు.
CliGateని నిర్మిస్తున్నప్పుడు నేను ఈ సమస్యను ఎదుర్కొన్నాను. నేను సెషన్ కంటిన్యూటీని (session continuity) సరిచేశాను, కానీ పదేపదే చేసే పనులు (repeated tasks) ఇంకా చాలా నెమ్మదిగా ఉన్నాయి.
ఏజెంట్ సంభాషణను గుర్తుంచుకుంది, కానీ పనిని గుర్తుంచుకోలేదు.
సెషన్ కంటిన్యూటీ ఒక సమస్యను పరిష్కరిస్తుంది. ఇది ఈ క్రింది ఫాలో-అప్ కమాండ్స్కు సహాయపడుతుంది:
- continue
- do the same for this file
- retry that
అది ఉపయోగకరమే. కానీ కొన్ని రోజుల తర్వాత మీరు ఒక వర్క్ఫ్లోను మళ్ళీ చేసినప్పుడు అది సహాయపడదు.
గత ప్రయత్నం ఎందుకు విజయవంతమైందో ఏజెంట్ గుర్తుంచుకోవాలి. దానికి ఇవి తెలియాలి:
- ఏ బటన్ పనిచేస్తుంది
- ఏ దశ నిష్ఫలమవుతుంది (dead end)
- ఏ ఫీల్డ్కు ప్రత్యేకంగా హ్యాండిల్ చేయాలి
- ఏ నియమాన్ని మీరు ఎల్లప్పుడూ వర్తింపజేయాలనుకుంటున్నారు
మొదటి ప్రయత్నం అత్యంత ఖరీదైనది. మీ ప్రాంప్ట్లో లేని వివరాలను ఏజెంట్ అన్వేషించి కనుగొనేది అప్పుడే.
నా పరిష్కారం కంటే ముందు, ఈ వివరాలు కేవలం రా (raw) లాగ్స్లో మాత్రమే ఉండేవి. ఏజెంట్కు హిస్టరీ ఉంది, కానీ మళ్ళీ ఉపయోగించుకోగలిగే మెమరీ (reusable memory) లేదు. అది ప్రతిసారీ అన్నింటినీ మళ్ళీ కనుగొనాల్సి వచ్చేది.
అది తెలివితేటలు కాదు. అది ఒకే డీబగ్గింగ్ ఖర్చును రెండుసార్లు చెల్లించడం వంటిది.
ఎక్కువ హిస్టరీని సేవ్ చేసి, మోడల్ దానిని ఉపయోగిస్తుందని ఆశించడం తప్పు పద్ధతి. అది అనవసరమైన శబ్దాన్ని (noise) సృష్టిస్తుంది.
దానికి బదులుగా నేను ఒక చిన్న, మళ్ళీ ఉపయోగించుకోగలిగే మెమరీ లేయర్ను నిర్మించాను. నేను వీటిపై దృష్టి పెట్టాను:
- procedures (పద్ధతులు)
- facts (వాస్తవాలు)
- directives (ఆదేశాలు)
- references (రిఫరెన్స్లు)
జరిగిన ప్రతిదీ సేవ్ చేయడానికి ప్రయత్నించడం నేను ఆపివేశాను. గుర్తుంచుకోవలసిన వాటిని మాత్రమే సేవ్ చేయడం ప్రారంభించాను.
ఇప్పుడు, అసిస్టెంట్ ఈ క్రింది వాటిని గుర్తుంచుకోవడానికి ఫైల్-ఆధారిత మెమరీ లేయర్ను ఉపయోగిస్తుంది:
- a procedure: ఉత్తమ దశలు మరియు తెలిసిన నిష్ఫల దశలు
- a fact: ఒక URL లేదా ఒక నిర్దిష్ట సెట్టింగ్
- a directive: పనులను మీరు ఎలా చేయాలనుకుంటున్నారు
- a reference: డాక్యుమెంటేషన్ ఎక్కడ ఉంది
మనుషులు ఇలాగే పని చేస్తారు.
ఇంటర్ఫేస్లు మారుతుంటాయి మరియు బటన్లు కదులుతుంటాయి కాబట్టి, నాకు గతంలో జరిగినది యథాతథంగా కావాలని లేదు. నేను ఏజెంట్ ఈ క్రింది విధంగా చేయాలని కోరుకుంటున్నాను:
- తెలిసిన ఉత్తమ పద్ధతిని గుర్తుంచుకోవడం
- మొదట దానిని ప్రయత్నించడం
- ప్రతి దశను ధృవీకరించడం
- అది విఫలమైతే మళ్ళీ అన్వేషణకు వెళ్లడం
- విజయం సాధించిన తర్వాత మెమరీని అప్డేట్ చేయడం
ఇది బలహీనమైన ఆటోమేషన్ను ఉపయోగకరమైన ఆపరేషనల్ మెమరీగా మారుస్తుంది.
నేను నిలిచి ఉండే నియమాలను (standing rules) సంభాషణ హిస్టరీ నుండి కూడా వేరు చేశాను. "ఎల్లప్పుడూ చైనీస్లో సమాధానం ఇవ్వండి" లేదా "ప్రొడక్షన్ డేటాను తాకవద్దు" వంటి నియమాలు సెషన్ కాంటెక్స్ట్ (session context) కాదు. అవి ఆపరేటింగ్ రూల్స్ (operating rules).
వీటిని వేరు చేసిన తర్వాత, అసిస్టెంట్ అంచనా వేయదగినదిగా (predictable) మారింది. ఒక పని మధ్యలో మీ ప్రాధాన్యతలను (preferences) అది మళ్ళీ మళ్ళీ కనుగొనాల్సిన అవసరం లేదు.
పదేపదే చేసే పనులు ఇప్పుడు తక్కువ సమయంలో పూర్తవుతున్నాయి. అసిస్టెంట్ ప్రతిసారీ ఖాళీ మోడల్తో ప్రారంభించదు కాబట్టి వేగంగా పనిచేస్తుంది.
నిరంతర థ్రెడ్ను నేర్చుకునే వ్యవస్థతో (system that learns) తప్పుగా పోల్చకండి.
ఒక సెషన్ సంభాషణను సజీవంగా ఉంచుతుంది. మెమరీ ఉపయోగకరమైన పాఠాలను సజీవంగా ఉంచుతుంది.
మీరు కోడింగ్ ఏజెంట్లను నిర్మిస్తుంటే, మిమ్మల్ని మీరు ఇలా ప్రశ్నించుకోండి: మీ సిస్టమ్ థ్రెడ్ను గుర్తుంచుకుంటోందా, లేదా విజయవంతమైన పద్ధతిని గుర్తుంచుకుంటోందా?
మూలం: https://dev.to/codekingai/my-coding-agent-remembered-sessions-not-work-that-was-the-bug-2fig