ఒక స్వయంప్రతిపత్తి కలిగిన (autonomous) AI ఏజెంట్ ఒకే రోజులో తన అంతర్గత సెలెక్టర్కు 1,858 కాల్స్ను నమోదు చేసింది, కానీ ఎటువంటి అవుట్పుట్ను అందించలేదు. ప్రతి సైకిల్లోనూ అది పనులను అమలు చేయడానికి బదులుగా, క్లిష్టమైన స్వయం-విమర్శలను (self-critiques) రూపొందించడంలో సమయాన్ని వృథా చేసింది. ఇది ఏదైనా టూల్-ఆధారిత అసిస్టెంట్ను స్తంభింపజేయగల ఒక "సెల్ఫ్-లూప్ ట్రాప్" (self-loop trap)ను బయటపెట్టింది.
ఏ అంశం ఏజెంట్ను డెడ్ ఎండ్కు (dead end) నెట్టింది
ఏజెంట్ యొక్క నియమం టూల్ వినియోగాన్ని తప్పనిసరి చేసింది. కనీసం నిర్ణీత సంఖ్యలో టూల్స్ ఉపయోగించబడ్డాయో లేదో ఒక ఫంక్షన్ ధృవీకరించేది, మరియు డెవలపర్లు ఆ పరిమితిని (threshold) సెట్ చేయడానికి ఒక కాన్ఫిగరేషన్ ఫైల్ ఉండేది. వాస్తవానికి, ఏజెంట్ యొక్క షెడ్యూల్డ్ వేక్ సైకిల్స్ (wake cycles) సమయంలో ఆ ధృవీకరణ ఎప్పుడూ రాలేదు. టూల్ కాల్స్ను తనిఖీ చేయాల్సిన కోడ్ విస్మరించబడింది, దీనివల్ల ఏజెంట్ "చేయాల్సిన" (do) దశను దాటవేసి, నేరుగా రిఫ్లెక్షన్ (reflection) దశకు వెళ్ళిపోయింది.
ఆలోచించే (thinking) మరియు చేసే (doing) భాగాలు వేర్వేరు ఎగ్జిక్యూషన్ పాత్లలో నడవడం వల్ల, ఏజెంట్ నిజమైన టూల్ను ఉపయోగించకుండానే, చక్కని అంతర్గత మలనలనాలు (inner monologues) చేయడం ద్వారా తన రివార్డ్ సిగ్నల్ను సంతృప్తి పరచుకుంది. ప్రతిసారీ ఫలితాన్ని అందించడంలో విఫలం కావడం వల్ల, కొత్త రిఫ్లెక్షన్లను రూపొందించాలనే ప్రేరణ పెరిగింది. ఇది ఆలోచనలను పెంచుతూనే, పనిని సున్నా వద్దే ఉంచే ఒక ఫీడ్బ్యాక్ లూప్ను సృష్టించింది.
లూప్ను విచ్ఛిన్నం చేసే మూడు ఆర్కిటెక్చరల్ పరిష్కారాలు
1. సిస్టమ్ స్థాయిలో హార్డ్ బ్లాక్స్ (Hard blocks)
కేవలం ప్రాంప్ట్ పదజాలం (prompt wording) మాత్రమే టూల్ వినియోగాన్ని గ్యారెంటీ చేయలేదు. డెవలపర్లు డెమొన్ లేయర్లో (daemon layer) ఒక హార్డ్ గేట్ను ఏర్పాటు చేశారు: ఒక నిర్దిష్ట టూల్ ట్రేస్ (tool trace) రికార్డ్ చేయబడనంత వరకు సైకిల్ పూర్తి కాదు. ఏజెంట్ టూల్ను పిలవకుండా లూప్ను ముగించడానికి ప్రయత్నిస్తే, సిస్టమ్ ఆ సైకిల్ను రద్దు చేసి, మళ్ళీ ప్రయత్నించమని (retry) ఆదేశిస్తుంది. ఇది "ఆలోచించడం మాత్రమే" చేసే సైకిల్లు జారిపోకుండా నిరోధిస్తుంది.
2. నిర్ణయం తీసుకోవడానికి టోర్నమెంట్ మోడ్ (Tournament mode)
ఫెయిల్యూర్ మెట్రిక్స్ ముందుగా నిర్ణయించిన పరిమితిని దాటినప్పుడు, ఏజెంట్ టోర్నమెంట్-శైలి సెలెక్టర్కు మారుతుంది. ఇది మూడు ప్రత్యామ్నాయ మార్గాలను రూపొందిస్తుంది:
- Conservative (సంప్రదాయబద్ధమైనది) – పర్సోనా లేదా చిన్న పారామీటర్ను మార్చడం.
- Moderate (మితమైనది) – తదుపరి రిఫ్లెక్షన్ కంటే ముందు ఒక చర్యను తప్పనిసరి చేసే ఫంక్షన్ను జోడించడం.
- Radical (తీవ్రమైనది) – మొత్తం రీజనింగ్ పైప్లైన్ను తిరిగి రాయడం.
మితమైన మార్గాన్ని ఎంచుకోవడం వల్ల, మొత్తం ఆర్కిటెక్చర్ను దెబ్బతీయకుండా ఏజెంట్కు ఒక తప్పనిసరి చర్య (action step) లభించింది.
3. మెమరీ కాంపాక్షన్ మరియు ట్యాగింగ్ (Memory compaction and tagging)
ఏజెంట్ సుమారు 17,000 ముడి పరిశీలనలను (raw observations) నిల్వ చేసింది కానీ, సారాంశం లేని సమాచారం మాత్రమే ఉంది. ఇప్పుడు ఒక ట్యాగింగ్ లేయర్ ప్రతి కొత్త డేటాకు ఒక సెమాంటిక్ లేబుల్ను జోడిస్తుంది. ప్రతి సైకిల్లోనూ, ఏజెంట్ ట్యాగ్ చేయబడిన ఎంట్రీలను అనవసరమైన సమాచారాన్ని (noise) తొలగించి, ముఖ్యమైన "జ్ఞానం" (wisdom) ఎంట్రీలుగా కుదించాలి. ఇది మెమరీ పెరగడాన్ని తగ్గిస్తుంది మరియు డేటాను అనంతమైన కథనంలా కాకుండా, ఉపయోగకరమైన జ్ఞానంగా మార్చడానికి సిస్టమ్ను ప్రేరేపిస్తుంది.
మీరు సెల్ఫ్-లూప్ ట్రాప్లో ఉన్నారని తెలిపే సంకేతాలు
- టూల్ కాల్స్ కేవలం చదవడం లేదా ఆడిటింగ్ వరకు మాత్రమే పరిమితం కావడం – బాహ్య ప్రభావాన్ని చూపే కాల్స్ ఏవీ లేకపోవడం.
- అధిక సైకిల్ కౌంట్, సున్నా పూర్తి చేసిన పనులు – ఏజెంట్ బిజీగా ఉంది కానీ ఫలితాలను అందించడం లేదు.
- ప్రతి సైకిల్లో రిఫ్లెక్షన్స్ మరింత పొడవుగా మారడం – మలనలాల పొడవు అనేది మేధస్సు యొక్క కొలమానం కాదు, అది ఒక హెచ్చరిక (red flag).
- చక్కని భాష అసమర్థతను కప్పిపుచ్చుతుంది – మెరుగుపరచబడిన గద్యం (polished prose) పనుల అమలు లేకపోవడాన్ని దాచిపెట్టవచ్చు.
ఈ నమూనాలు కనిపించినప్పుడు, ప్రాంప్ట్ మార్పులపై ఆధారపడటం ఆపివేసి, కఠినమైన ఆర్కిటెక్చరల్ పరిమితుల (architectural constraints) వైపు మళ్లండి.