Google యొక్క తాజా agent framework retraining కంటే persistence పై దృష్టి పెడుతుంది
Google Research, WikiSkill అనే ఒక systemను పరిచయం చేసింది. ఇది AI ఏజెంట్లలో కనిపించే ఒక పరిచిత బలహీనతను పరిష్కరించడానికి ప్రయత్నిస్తుంది: వారు తరచుగా ఒక taskను పూర్తి చేసి, ఆ అనుభవాన్ని వదిలేసి, ముందు ఏమి తప్పు జరిగింది అనే ప్రాయోగిక జ్ఞాపకం చాలా తక్కువగా తదుపరి runను ప్రారంభిస్తారు. WikiSkill, వైఫల్యాలు మరియు విజయాలను నమోదు చేసే persistent, wiki-like knowledge baseతో ఏజెంట్ను జతచేసి, ఆ రికార్డును భవిష్యత్ performanceను మెరుగుపరచడానికి ఉపయోగిస్తుంది.
ఆ మౌలిక ఆలోచన సూటిగా ఉంటుంది. ప్రతి runను వినియోగించి పారేసేదిగా చూడటానికి బదులుగా, ఈ framework execution సమయంలో ఏమి జరిగింది అనేది పట్టుకుని, ఆ ఫలితాలను structured knowledgeగా సంక్షిప్తం చేసి, అత్యంత ఉపయోగకరమైన పాఠాలను మళ్లీ ఉపయోగించగల behavioral guidanceగా మారుస్తుంది. ఏర్పడే instructions, source “Agent Skills” అని వివరిస్తున్న modulesగా ప్యాక్ చేయబడతాయి; ఇవి model యొక్క అసలు trainingను మార్చకుండా, ఏజెంట్ ఎలా ప్రవర్తిస్తుందో ఆకృతీకరించగలవు.
ఆ తేడా ముఖ్యమైనది. WikiSkillను model స్థాయిలో నిజమైన continuous learningగా చూపించలేదు. continuous learning ఇప్పటికీ పరిష్కారం కాని సమస్య అని source స్పష్టంగా గమనిస్తుంది. WikiSkill అందించేది బాహ్య memory మరియు self-improvement loop: ఏజెంట్ తనకే మెరుగైన instructions రాస్తుంది, వాటిని నిల్వ చేస్తుంది, తరువాత వాటిని మళ్లీ పరిశీలిస్తుంది. ఇది ఒక workaround, కానీ report ప్రకారం అది ప్రభావవంతమైనది.
మూడు-స్థరాల architecture logs, knowledge, actionను వేరు చేస్తుంది
WikiSkill ఏజెంట్ workspaceను మూడు layersగా నిర్వహిస్తుంది. అత్యంత దిగువన Raw Layer ఉంటుంది, ఇందులో tool calls మరియు results సహా పూర్తి execution traces నిల్వ ఉంటాయి. ఈ layer immutable; ఏజెంట్ నిజంగా ఏమి చేశాడో దానికి ఇది ఆధార రికార్డుగా పనిచేస్తుంది. దాని పైన Wiki Layer ఉంటుంది, అక్కడ ఆ raw tracesను విజయవంతమైన strategies మరియు పునరావృతం అయ్యే failure patterns వంటి structured observationsగా మారుస్తారు. పైభాగంలో Skill Layer ఉంటుంది, ఇందులో tasks నిర్వహించే సమయంలో ఏజెంట్ ఉపయోగించే active procedural instructions ఉంటాయి.
ఈ విభజన framework యొక్క బలమైన design choicesలో ఒకటి. Raw traces ఆధారాలను కాపాడుతాయి. wiki ఆ ఆధారాలను సమష్టి knowledgeగా మారుస్తుంది. skills ఆ knowledgeను operational behaviorగా మారుస్తాయి. ఈ విధంగా systemను విభజించడం ద్వారా, WikiSkill అన్నింటినీ ఒకే opaque memory storeగా కుదించకుండా ఉంటోంది.
ఇది revisionను కూడా జాగ్రత్తగా నిర్వహిస్తుంది. source ప్రకారం, Wiki Layer మాత్రమే పెరుగుతుంది; iterations మధ్యలో అది reset కాదు. Skill Layer మరింత provisionalగా ఉంటుంది. కొత్త skill update performanceను దెబ్బతీస్తే, దాన్ని rollback చేయవచ్చు. అంటే framework durable knowledge మరియు active policyను వేర్వేరుగా చూసుకుంటుంది: knowledge చేరుకుంటూ ఉంటుంది, కానీ behavior test చేయదగినదిగా, తిరిగి మార్చదగినదిగా ఉంటుంది.
మెరుగుదల loop ఎలా పనిచేస్తుంది
update cycle నాలుగు భాగాలతో ఉంటుంది. మొదట, inference agent ప్రస్తుత skill setను ఉపయోగించి tasksను అమలు చేసి execution tracesను ఉత్పత్తి చేస్తుంది. తరువాత Wiki Maintainer అనే component ఆ tracesను విశ్లేషించి, failure modes మరియు సమర్థవంతమైన tacticsను గుర్తించి, ఆ కనుగొన్న విషయాలను wikiలో రాస్తుంది. Skill Proposer, నవీకరించిన wiki మరియు execution data రెండింటినీ ఉపయోగించి, ఏజెంట్ skillsకు లక్ష్యిత మార్పులను సూచిస్తుంది. చివరగా, ఒక gating mechanism ఆ ప్రతిపాదిత updateను వేరే validation setపై అంచనా వేసి, అది సహాయపడితే మాత్రమే ఆ మార్పును ఉంచుతుంది.
ఆ చివరి దశ కీలకం. ఏజెంట్లు తమ own proceduresను తిరిగి రాయడానికి అనుమతించే systems, ప్రతి revisionను అంగీకరిస్తే వేగంగా దారితప్పవచ్చు. WikiSkill యొక్క validation gate ఆ driftను ఆపడానికి రూపొందించబడింది. ప్రతిపాదిత skill పరీక్షలో విఫలమైతే, system skill updateను విస్మరిస్తుంది, కానీ wikiలో నమోదు చేసిన underlying knowledgeను మాత్రం నిలుపుకుంటుంది.
అందువల్ల విఫలమైన proposals కూడా ఉపయోగకరమైన inputsగా మారతాయి. source ప్రకారం, wiki ఏమి ప్రయత్నించారో, ఎందుకు విఫలమైందో డాక్యుమెంట్ చేస్తుంది, దీని వల్ల తరువాతి iterationsకు మరింత context లభిస్తుంది. వాస్తవంలో, system విజయవంతమైన tacticsను మాత్రమే గుర్తుంచుకోదు. అలాగే ప్రయోజనం లేని దిశలను కూడా గుర్తుంచి, వాటిని అంధంగా మళ్లీ చేయకుండా తప్పించగలదు.
వైఫల్య జ్ఞాపకం ఏజెంట్ reliabilityకు ఎందుకు ముఖ్యమవచ్చు
WikiSkill యొక్క విస్తృత ప్రాముఖ్యత, ఏజెంట్లు notesను సేకరించగలరన్న విషయం మాత్రమే కాదు. వైఫల్యం first-class informationగా మారుతుంది అన్నదే ముఖ్యం. అనేక agent pipelinesలో, వైఫల్యం ఒక తక్షణ చెడు ఫలితంగా మాత్రమే కనిపిస్తుంది: ఒక task మిస్ అవుతుంది, ఒక tool తప్పుగా వాడబడుతుంది, లేదా ఒక instruction chain కూలిపోతుంది. developers logsను manually inspect చేసి promptsను సవరించకపోతే, ఆ తప్పులు నిలకడైన operational knowledgeగా మారవు.
WikiSkill ఆ మార్పును స్వయంచాలకంగా చేయడానికి ప్రయత్నిస్తుంది. వైఫల్య patterns మరియు విజయవంతమైన strategiesను దీర్ఘకాలిక layerలో డాక్యుమెంట్ చేయడం ద్వారా, ఈ framework model training యొక్క కొత్త దశ లేకుండానే ఏజెంట్ ప్రవర్తనను కాలక్రమేణా మెరుగుపరచడానికి ఒక మార్గాన్ని ఇస్తుంది. ప్రత్యేకించి సమానమైన tasksను పదే పదే ఎదుర్కొనే పరిసరాల్లో, tool use, sequencing, మరియు exception handling raw language abilityతో సమానంగా ముఖ్యమైనప్పుడు, ఇది గణనీయంగా ప్రాసంగికం కావచ్చు.
ఈ framework, model weightsలో కాకుండా model చుట్టూ ఉన్న scaffoldingలో మరింత intelligenceను నెట్టి వేయాలనే AI system designలో పెరుగుతున్న trendను కూడా ప్రతిబింబిస్తుంది. Memory, validation, rollback, మరియు structured self-documentation అన్నీ operational engineering రూపాలు. ఇవి అత్యంత కష్టమైన learning problemను పరిష్కరించకపోయినా, కొలవదగిన లాభాలను అందించవచ్చు.
ఒక “LLM Wiki” ఆలోచన నుండి implementationకు
ఈ పని, sourceలో Andrej Karpathyతో అనుసంధానించబడిన ఒక conceptపై ఆధారపడి ఉంది: AI system కాలక్రమేణా నిర్మించి, చూడగలిగే, మళ్లీ ఉపయోగించగల experience యొక్క సమ్మేళన నిల్వ అయిన “LLM Wiki” అనే ఆలోచన. WikiSkill ఆ ఆలోచనను ప్రత్యేకంగా agent developmentకు వర్తింపజేస్తుంది. సాధారణ memory dumpగా కాకుండా, tracesను తిరిగి ఉపయోగించదగిన, పరీక్షించదగిన proceduresగా మార్చే processను ఇది సృష్టిస్తుంది.
procedureపై ఈ దృష్టి ముఖ్యమైనది. ఏజెంట్కు facts మాత్రమే సరిపోవు; అది ఎలా పనిచేయాలో మెరుగైన అవగాహన అవసరం. ఏ toolను మొదట ఉపయోగించాలి? ఏ failure patterns వేరే మార్గాన్ని ప్రేరేపించాలి? ఇలాంటి పరిస్థితిలో ముందుగా ఏ strategy పనిచేసింది? WikiSkill యొక్క సమాధానం, ఆ పాఠాలను skillsగా formalize చేసి, వాటి కింద evidence baseను నిలుపుకోవడం.
ఇంకా tradeoffs ఉన్నాయి. ఈ method నిజమైన learning కంటే ఎక్కువ లోపాలకు లోనయ్యే అవకాశం ఉందని source గమనిస్తుంది. బాహ్య knowledge stores తప్పు interpretationsను కోడ్ చేయగలవు, మరియు self-authored instructions జాగ్రత్తగా validate చేయకపోతే brittle heuristicsగా మారవచ్చు. కానీ gating mechanism మరియు rollback model, ఆ ప్రమాదాన్ని design problemలో భాగంగా పరిశోధకులు పరిగణిస్తున్నారని చూపిస్తున్నాయి.
ప్రస్తుతం సందేశం స్పష్టంగా ఉంది: నిజమైన continuous learning పరిష్కారం అయ్యేలోపు, persistent memory ఏజెంట్లను మెరుగుపరచడానికి అత్యంత practical మార్గాల్లో ఒకటి కావచ్చు. WikiSkill సూచిస్తున్నది ఏమిటంటే, పునరావృత పనిలో మెరుగ్గా ఉండేందుకు ఏజెంట్లు retrain కావలసిన అవసరం లేదు. ఏమి జరిగింది, ఏమి విఫలమైంది, తదుపరి సారి ఏమి ప్రయత్నించాలి అనే దానిని గుర్తుంచుకోవడానికి వారికి ఒక structured way కావచ్చు.
This article is based on reporting by The Decoder. Read the original article.
Originally published on the-decoder.com
