చాలా ఇంజనీరింగ్ బృందాలు ఇప్పటికీ AI ఏజెంట్లను గణిత హోంవర్క్ను గ్రేడ్ చేసే విధంగానే అంచనా వేస్తున్నాయి. అవి కేవలం తుది అవుట్పుట్ను మాత్రమే చూస్తాయి. సమాధానం సరైనదైతే, అవి విడుదలకు అనుమతి ఇచ్చి ముందుకు సాగిపోతాయి. ఇది ఒక ప్రమాదకరమైన షార్ట్కట్. ఒక సరైన సమాధానం లోపభూయిష్టంగా ఉన్న వ్యవస్థను దాచిపెట్టవచ్చు.
అసలు కథ ఏజెంట్ అక్కడికి చేరుకోవడానికి అనుసరించిన మార్గంలో ఉంటుంది. ఆ మార్గాన్ని 'ఏజెంట్ ట్రాజెక్టరీ' (agent trajectory) అని పిలుస్తారు. ఇందులో ప్రతి tool call, ప్రతి routing decision, ఏజెంట్ మళ్ళీ ఆలోచించడానికి తీసుకునే ప్రతి విరామం ఉంటాయి. దీనిని ఏజెంట్ వదిలివెళ్లిన గుర్తుల (trail of breadcrumbs) లాగా భావించవచ్చు. మీరు కేవలం గమ్యాన్ని మాత్రమే పరిశీలిస్తే, దారిలో కనిపించే హెచ్చరిక సంకేతాలన్నింటినీ మీరు కోల్పోతారు.
గందరగోళ మార్గాలతో ఉన్న సమస్యలు
ఒక ఏజెంట్ మద్యం సేవించిన డ్రైవర్ లాగా ప్రవర్తిస్తూ కూడా సరైన సమాధానాన్ని ఇవ్వవచ్చు. అది తప్పుడు టూల్స్ ద్వారా వెళ్లడం, మళ్ళీ రూటర్కు తిరిగి రావడం మరియు అనవసరమైన reasoning ద్వారా తిరగడం వంటివి చేస్తూ, చివరికి ఏదో ఒక సరైన సమాధానాన్ని చేరుకుంటుంది. వినియోగదారుడికి మాత్రం ఒక స్పష్టమైన ఫలితం కనిపిస్తుంది. కానీ తెర వెనుక, సిస్టమ్ వనరులను వృథా చేస్తూ ప్రమాదాలను పెంచుకుంటూ ఉంటుంది.
ఆ గందరగోళం ఆచరణలో ఎలా ఉంటుందంటే?
మొదటిది, అనవసరమైన tool call. ఏజెంట్ మీ కస్టమర్ డేటాబేస్ను క్వెరీ చేస్తుంది, ఫలితాన్ని పొందుతుంది, ఐదు సెకన్ల తర్వాత దానిని మర్చిపోతుంది, మరియు అదే పారామీటర్లతో మళ్ళీ అదే రికార్డును క్వెరీ చేస్తుంది. ఇది డేటా సమస్య కాదు. ఇది ట్రాజెక్టరీ సమస్య. ఏజెంట్ stateను నిలుపుకోవడంలో విఫలమైంది, అందుకే అది పనిని మళ్ళీ మళ్ళీ చేస్తుంది.
తర్వాత 'wrong-tool-first' పద్ధతి వస్తుంది. ఒక కోడింగ్ ఏజెంట్, లోకల్ రిపోజిటరీలోనే ఉన్న function definition కోసం వెబ్లో వెతకడానికి ప్రయత్నించవచ్చు. లేదా ఒక సపోర్ట్ ఏజెంట్, వినియోగదారుడి ప్రశ్న స్పష్టంగా account settings toolను కోరుతున్నప్పుడు, billing APIని ఉపయోగించవచ్చు. ప్రతి తప్పుడు ఎంపిక tokensను వృథా చేస్తుంది, latencyని పెంచుతుంది మరియు అసలు పని ప్రారంభం కాకముందే context limits ముగిసిపోయే ప్రమాదాన్ని పెంచుతుంది.
Router loops మరొక హెచ్చరిక. Decision node ఒక నిర్ణయానికి రాలేకపోతుంది. అది టాస్క్ను branch Aకి పంపిస్తుంది, తర్వాత తన నిర్ణయాన్ని మార్చుకుని, దానిని వెనక్కి తీసుకువస్తుంది, branch Bకి పంపిస్తుంది, ఆపై ఎటువంటి కారణం లేకుండా general-purpose fallback node ద్వారా రూట్ చేస్తుంది. ప్రతి లూప్ ఒక network hopను మరియు చివరి debug logలో మరిన్ని గందరగోళాలను పెంచుతుంది.
చివరగా, పునరావృత విశ్లేషణ (repeated analysis). ఏజెంట్ ఒక విషయాన్ని స్థిరమైనదిగా పరిగణించకుండా, ప్రతి దశలోనూ అదే ముగింపును మళ్ళీ మళ్ళీ పొందుతూ ఉంటుంది. ఇది ప్రతి కటింగ్ కంటే ముందు చెక్క ముక్కను పదిసార్లు కొలిచే వడ్రంగి లాంటిది. మొదటి కొలత సరిగ్గా ఉన్నా, మిగిలిన తొమ్మిది కొలతలు వృథా ప్రయత్నాలు మాత్రమే.
ఈ అదనపు దశల వల్ల నిజమైన పరిణామాలు ఉంటాయి. Latency పెరుగుతుంది. ఒక synchronous chat interfaceలో, అదనపు మూడు సెకన్లు కూడా చాలా కాలంలా అనిపిస్తాయి. భారీ స్థాయిలో చూస్తే, ఆ సెకన్లు కంప్యూట్ ఖర్చులో వేల డాలర్ల నష్టానికి దారితీస్తాయి. వైఫల్య ప్రమాదం కూడా పెరుగుతుంది. ప్రతి అనవసరమైన hop, ఒక external API time out అవ్వడానికి, context window overflow అవ్వడానికి లేదా race condition తలెత్తడానికి మరొక అవకాశం. ఏదైనా విఫలమైనప్పుడు, స్పాగెట్టి లాగా చిక్కుపడిన ట్రేస్ను డీబగ్ చేయడం చాలా కష్టం. ఏజెంట్ ఏల ఏడవ దశను ఎందుకు తీసుకుందో తెలుసుకోవడానికి మీరు గంటల తరబడి సమయం వెచ్చిస్తారు, కానీ చివరికి ఆ ఏడవ దశ అసలు అవసరమే లేదని అర్థమవుతుంది.
కన్వర్జెన్స్ (Convergence) అంటే నిజంగా ఏమిటి?
ట్రాజెక్టరీ అనేది మార్గం అయితే, కన్వర్జెన్స్ అనేది దాని సామర్థ్యానికి కొలమానం. వినియోగదారుడి అభ్యర్థన మరియు సరైన పరిష్కారం మధ్య ఏజెంట్ ఎంత దగ్గరగా అతి తక్కువ మార్గాన్ని అనుసరిస్తుందో కన్వర్జెన్స్ చెబుతుంది.
ఇది accuracy తో సమానం కాదు. Accuracy అనేది ఒక ప్రాథమిక కొలత మాత్రమే. అది తుది స్థితి సరైనదా కాదా అని మాత్రమే అడుగుతుంది. కన్వర్జెన్స్ ఆ ప్రయాణం ఎంత హేతుబద్ధంగా ఉందో అడుగుతుంది. అధిక accuracy మరియు తక్కువ కన్వర్జెన్స్ ఉన్న ఏజెంట్, విజయపు ముసుగులో ఉన్న ఒక భారంగా మారుతుంది. అధిక కన్వర్జెన్స్ మరియు మధ్యస్థ accuracy ఉన్న ఏజెంట్ను సరిదిద్దడం సాధారణంగా సులభం, ఎందుకంటే దాని reasoning స్పష్టంగా ఉంటుంది మరియు దాని తప్పులు పరిమితంగా ఉంటాయి.
ఏజెంట్ నిజంగా తీసుకునే దశలను, ఆ task class కోసం మీరు నిర్వచించిన అతి తక్కువ మార్గంతో పోల్చడం ద్వారా మీరు ఒక అంచనా convergence scoreను లెక్కించవచ్చు. ఒక సాధారణ refund queryకి సరిగ్గా మూడు tool calls అవసరమైతే మరియు ఏజెంట్ తొమ్మిది ఉపయోగించినట్లయితే, మీ convergence ratio తగ్గుతుంది. వివిధ రకాల వృథాలను weighting చేయడం ద్వారా మీరు దీనిని మరింత మెరుగుపరచవచ్చు. టూల్ యొక్క latency మరియు ధరను బట్టి, ఒక తప్పుడు tool call, ఒక అనవసరమైన call కంటే ఎక్కువ ఖర్చు చేయవచ్చు. ఎటువంటి విలువను చేర్చని router loop అన్నిటికంటే ఎక్కువ పెనాల్టీని కలిగి ఉండవచ్చు, ఎందుకంటే ఇది architectural