రివ్యూ పేపర్ ప్రకారం AI ఏజెంట్లకు నిజమైన ఇంజిన్ కోడ్

భాష మాత్రమే కాదు, కోడ్ కూడా AI ఏజెంట్లకు మౌలిక ఆధారంగా ఎదుగుతోంది

Meta, Stanford, మరియు University of Illinois Urbana-Champaign కు చెందిన పరిశోధకుల కొత్త రివ్యూ పేపర్, ఆధునిక AI ఏజెంట్లు నిజంగా ఎలా పనిచేస్తాయో నేరుగా వివరిస్తుంది: కోడ్ ఇకపై కేవలం అవుట్‌పుట్ ఫార్మాట్ మాత్రమే కాదు, ఏజెంట్లు ఆలోచించడానికి, చర్య తీసుకోవడానికి, మరియు సమన్వయం చేయడానికి ఉపయోగించే కేంద్ర మాధ్యమం. The Decoder ఇచ్చిన వివరణ ప్రకారం, ఈ పేపర్ దృష్టిని language model ఒక్కదానిపై కాకుండా, stateless మోడల్‌ను ఒక operating agent గా మార్చే దాని చుట్టూ ఉన్న సాఫ్ట్‌వేర్ సిస్టమ్‌పైకి మళ్లిస్తుంది.

ఆ చుట్టూ ఉన్న పొరను రచయితలు “హార్నెస్” అని పిలుస్తారు. ఇందులో tools, interfaces, sandboxed execution environments, memory, permission boundaries, testing infrastructure, execution loops, మరియు feedback channels ఉంటాయి. వారి పాయింట్ సూటిగా ఉంది: ఆ scaffolding లేకుండా, మోడల్ responses తయారుచేసే వ్యవస్థగా మాత్రమే మిగులుతుంది. దానితో, మోడల్ క్రమంగా plan చేయగలదు, execute చేయగలదు, ఫలితాలను inspect చేయగలదు, మరియు ఎక్కువ task horizons మీద పని కొనసాగించగలదు.

హార్నెస్ ఎందుకు ముఖ్యమైంది

ఈ రివ్యూ, long-running agent systems ను మూడు భాగాల కలయికగా చూపిస్తుంది. మొదట, planning మరియు reasoning వంటి మోడల్ యొక్క native capabilities. రెండవది, మోడల్ చుట్టూ అందించే infrastructure. మూడవది, ఏజెంట్ పని చేస్తున్నప్పుడు వ్రాస్తున్న లేదా ఉపయోగిస్తున్న code, ఇందులో scripts, helper tools, tests, workflows, మరియు reusable skills ఉంటాయి. ఈ ఫ్రేమింగ్‌లో, మరింత సామర్థ్యం గల ఏజెంట్లకు bottleneck మరింతగా మోడల్ alone కన్నా software environment యొక్క reliability మరియు transparency కావచ్చు.

కోడ్‌కు ఏజెంట్ ప్రవర్తనకు ప్రత్యేకంగా ఉపయోగపడే అనేక లక్షణాలు ఉన్నాయని రచయితలు వాదిస్తున్నారు. అది executable, అంటే outputs ను తనిఖీ చేయగల operations గా మార్చవచ్చు. అది traceable, ఎందుకంటే మధ్యంతర దశలను structured artifacts గా రికార్డ్ చేయవచ్చు. అది persistent, ఎందుకంటే ఏజెంట్లు అనేక దశలలో తిరిగి కొనసాగించగల రూపంలో పురోగతిని నిల్వ చేయగలరు.

ఈ దృక్కోణం, ప్రస్తుత commercial systems లో model మరియు software runtime మధ్య గీత ఎందుకు మసకబారుతోందో వివరిస్తుంది. The Decoder పేర్కొన్నట్లు, Claude Code మరియు OpenAI యొక్క Codex వంటి systems ఇప్పటికే ఈ సూత్రంపైనే పనిచేస్తున్నాయి, model responses ను తుది ముగింపుగా పరిగణించకుండా tool use మరియు controlled execution పై ఆధారపడుతున్నాయి.

Execution కొత్త ప్రమాదాలను తెస్తుంది

ఈ పేపర్ హార్నెస్‌ను సులభమైన పరిష్కారంగా చూపించదు. ప్రస్తుత software tests తప్పు భద్రతా భావనను సృష్టించవచ్చని కూడా రచయితలు హెచ్చరిస్తున్నారు. అసంపూర్ణమైన లేదా పరిమితమైన test suites, ఏజెంట్లు code ను సృష్టిస్తూనే లేదా మారుస్తూనే ఉన్నప్పుడు, failure modes ను దాచుతూ systems నమ్మదగినవిగా కనిపించడానికి అవకాశం ఇవ్వవచ్చు.

ఈ ఆందోళన ముఖ్యమైనది, ఎందుకంటే tests మరియు execution traces ను తరచుగా విజయానికి సంబంధించిన objective సంకేతాలుగా పరిగణిస్తారు. ఈ రివ్యూ, మరింత automation మాత్రమే కాదు, మరింత transparent evaluation mechanisms కూడా అవసరమని వాదిస్తోంది. ప్రాక్టికల్‌గా, దాని అర్థం ఏజెంట్‌కు ఏమి చేయడానికి అనుమతి ఇచ్చారు, అది నిజంగా ఏమి చేసింది, ఏ evidence సేకరించబడింది, మరియు ఎలాంటి failures ను పక్కన పెట్టి ఉండవచ్చో పరిశీలించడం.

దీని విస్తృతార్థం ఏమిటంటే, AI safety మరియు capability ఇప్పుడు engineering discipline తో మరింత దగ్గరగా అనుసంధానమవుతున్నాయి. Sandboxes, permissions, logging, test design, మరియు tool boundaries ఇక peripheral implementation details కావు. అవి system intelligence లో భాగం మరియు దాని risk surface లో భాగం.

AI పరిశ్రమకు ఒక కొత్త రూపకల్పన

ఈ పునర్వ్యాఖ్యానం, agentic systems demos నుండి operational products దిశగా కదులుతున్న సమయంలో వస్తోంది. పేపర్ యొక్క thesis సరైందైతే, autonomy లో తదుపరి పెద్ద లాభాలు models ను మాత్రమే scale చేయడం కన్నా, వాటి చుట్టూ ఉన్న software structures ను మెరుగుపరచడం ద్వారా రావచ్చు. మెరుగైన tool interfaces, బలమైన memory systems, స్పష్టమైన permissions, మరింత rigorous test environments, మరియు మరింత faithful audit trails, model size లో మరో పెరుగుదలంతే ముఖ్యంగా ఉండవచ్చు.

ఇది evaluation standards కూడా అభివృద్ధి చెందాల్సి ఉందని సూచిస్తోంది. ఒక agent ను benchmark score లేదా single-turn response ఆధారంగా మాత్రమే కొలవడం, వ్యవస్థ నిజమైన పనులను సురక్షితంగా మరియు విశ్వసనీయంగా పూర్తి చేయగలదా లేదా అనేది నిర్ణయించే infrastructure పాత్రను మిస్ చేస్తుంది. executable workflows మరియు harness design పై పేపర్ ఉంచిన గమనం, AI performance పై మరింత systems-level దృక్కోణం వైపు చూపుతుంది.

ఏజెంట్లను నిర్మిస్తున్న developers మరియు కంపెనీలకు, సందేశం ఆచరణాత్మకం. code అనేది ఏజెంట్లు ఎలా ఆలోచిస్తారు మరియు పని చేస్తారో అందులో భాగమైతే, model చుట్టూ ఉన్న runtime quality ఒక first-order product decision అవుతుంది. దానిలో ఏ tools expose చేయబడ్డాయి, outputs ఎలా verify చేయబడతాయి, memory ఎలా store చేయబడుతుంది, మరియు ఏజెంట్‌కు ఎంత operational freedom ఇవ్వబడుతుంది అన్నది వస్తాయి.

ఈ రివ్యూ, models ఇక ముఖ్యమല്ല అని చెప్పడం లేదు. బదులుగా, capability model మరియు environment మధ్య పరస్పర చర్య నుండి ఉద్భవిస్తుందని వాదిస్తోంది. ఆ అర్థంలో, హార్నెస్ ఒక accessory కాదు. అది prediction ను sustained action గా మార్చే mechanism.

ఈ వ్యాసం The Decoder నివేదికపై ఆధారపడింది. మూల వ్యాసాన్ని చదవండి.