मला वाटायचे की AI एजंट तयार करणे म्हणजे चॅटबॉटला प्रॉम्प्ट देणेच आहे. तुम्ही प्रश्न नीट विचारता, मॉडेल उत्तर देते आणि तुमचे काम झाले असे समजता. मग मी काही ॲप्लिकेशन्स लाँच केले. वास्तव खूप वेगळे होते. LLM म्हणजे एजंट नाही. LLM फक्त पुढचा टोकन (token) प्रेडिक्ट करते. तो 'लूप' (loop) म्हणजे एजंट तयार करतो.

चहा बनवण्याबद्दल विचार करा. तुम्ही make_tea() नावाचा एक कमांड देऊन बाजूला जात नाही. तुम्ही केटल भरता, नळाचा दाब कमी असल्याचे लक्षात येते, थांबता, केटल सुरू करता, स्विच खराब असल्याचे पाहता, दुसऱ्या बर्नरकडे जाता, वाफ तपासता, चहा ओतता, चव घेता आणि कदाचित मध घालता कारण पाने जास्त वेळ भिजली होती. ध्येय कधीच बदलत नाही, पण पायऱ्या बदलतात. तुम्ही निरीक्षण करता, बदल करता आणि पुन्हा प्रयत्न करता. AI एजंट्स अगदी याच पद्धतीने काम करतात.

एजन्सी (Agency) निर्माण करणारा सायकल

हा लूप केवळ एक अमूर्त सिद्धांत नाही. तुमच्या वतीने काम करणाऱ्या कोणत्याही प्रणालीचा तो कार्यात्मक कणा (operational heartbeat) आहे. प्रत्यक्ष व्यवहारात तो असा दिसतो:

  • Think: मॉडेल ध्येयाचा विचार करते आणि त्याला कशाची गरज आहे हे ठरवते. वापरकर्ता विचारतो, "मी उद्या पोर्टलंडला छत्री घेऊन जाऊ का?" मॉडेलला समजते की त्याला हवामानाचा अंदाज आणि ठिकाणाची गरज आहे.
  • Act: मॉडेल एखादे टूल (tool) वापरते. ते "Portland" शोधण्यासाठी geocoding API कॉल करू शकते आणि नंतर त्या कोऑर्डिनेट्ससह हवामान (weather) एंडपॉइंटवर विनंती पाठवू शकते.
  • Observe: मॉडेल टूलचे आउटपुट वाचते. API ने JSON फॉरकास्ट पाठवला, 403 एरर दिली की HTML मेंटेनन्स पेज?
  • Update: जे दिसते त्यावरून मॉडेल आपली योजना सुधारते. जर geocoder ने Portland, Oregon ऐवजी Portland, Maine पाठवले असेल, तर मॉडेलला ते स्पष्ट करावे लागेल. जर API डाऊन असेल, तर ते बॅकअप सोर्स वापरू शकते किंवा वापरकर्त्याला विचारू शकते.
  • Think Again: नवीन संदर्भासह (context) सायकल पुन्हा सुरू होते.

हे पाच वेगळे फंक्शन्स नाहीत जे तुम्ही एकदा लिहून विसरून जाल. हे एक सतत चालणारे इंजिन आहे जे ध्येय गाठले नाहीतर किंवा एखादी मर्यादा (hard stop) आली नाहीतर थांबत नाही. मॉडेल एखाद्या स्क्रिप्टप्रमाणे कोड एक्झिक्युट करत नाही. ते जगाच्या स्थितीचा विचार करते, कृती निवडते, त्याचे परिणाम वाचते आणि पुढे काय करायचे हे ठरवते. हीच एका साध्या 'autocomplete' आणि काम पूर्ण करणाऱ्या 'एजंट'मधील मुख्य तफावत आहे.

सर्व फ्रेमवर्क्स सारखे का दिसतात

जर तुम्ही LangGraph, CrewAI किंवा AutoGen सोबत काम केले असेल, तर तुम्हाला कदाचित असे जाणवले असेल की ते सर्व सारखेच वाटू लागतात. LangGraph प्रवाहाचे मॉडेलिंग नोड्स (nodes) आणि एडजेस (edges) च्या कायमस्वरूपी ग्राफच्या स्वरूपात करते. CrewAI एजंट्सना भूमिका (roles) आणि क्रूमध्ये (crews) आयोजित करते. AutoGen मल्टी-एजंट संवादांचे नियोजन करते. पॅकेजिंग वेगळे आहे, पण सांगाडा (skeleton) तोच आहे.

ते सारखे दिसतात कारण ते सर्व याच लूपिंग तत्त्वावर आधारित आहेत. LangGraph स्पष्टपणे टूल कॉल्स आणि मॉडेल इन्फरन्स (inferences) मधील स्टेट ट्रान्झिशन (state transitions) म्हणून या सायकलची रचना करते. CrewAI या लूपला भूमिका-आधारित एजंट्समध्ये गुंडाळते, परंतु प्रत्येक क्रू मेंबर अजूनही प्लॅनिंग, ॲक्टिंग आणि ऑब्झर्व्हिंगच्या चक्रातून जातो. AutoGen ॲक्टर्समधील संदेशांचे मध्यस्थी करते, तरीही प्रत्येक टर्न हा जनरेट, एक्झिक्युट, रिफ्लेक्ट आणि रूट यातील एक प्रकार असतो.

हे फ्रेमवर्क्स लूपवर लक्ष केंद्रित करतात कारण तिथेच 'एजन्सी' असते. मूळ मॉडेल GPT-4, Claude किंवा एखादे फाईन-ट्यून केलेले ओपन-वेट मॉडेल असू शकते. लूपशिवाय, तुमच्याकडे फक्त एक महागडा 'वाक्य पूर्ण करणारा' (sentence completer) प्रोग्राम आहे. लूपसह, तुमच्याकडे अशी प्रणाली आहे जी अनेक प्रयत्नांनंतरही उद्दिष्टाकडे वाटचाल करू शकते.

जेव्हा खरे काम सुरू होते

लोकल डेमो पाहताना जादू वाटते. पण प्रोडक्शनमध्ये त्या जादूचा सामना वास्तव आणि गोंधळाशी होतो. एकदा तुम्ही प्रोटोटाइपिंगच्या पलीकडे गेलात की, तुम्ही AI च्या समस्या सोडवणे थांबवता आणि सिस्टम इंजिनिअरिंगच्या समस्या सोडवू लागता.

टूल फेल्युअर अपरिहार्य आहेत. APIs टाइम आउट होतात. ते चुकीचे (malformed) JSON परत करतात. ते HTML मध्ये गुंडाळलेले 500 एरर्स देतात. जर तुमचा लूप प्रत्येक टूल आउटपुटवर आंधळेपणाने विश्वास ठेवत असेल, तर तुमचा एजंट यशाचा भास (hallucinate success) करेल किंवा गोंधळात पडेल. तुम्हाला प्रत्येक रिटर्न पेलोडवर retry logic, circuit breakers आणि schema validation ची गरज आहे.

मेमरी कालबाह्य होते. तुमच्या एजंटला आठवते की वापरकर्त्याचा पसंतीचा डेटाबेस PostgreSQL आहे, पण इन्फ्रास्ट्रक्चर टीमने काल रात्री नवीन क्लस्टरवर स्थलांतर केले आहे. संदर्भ (context) रिफ्रेश किंवा एक्स्पायर करण्यासाठी यंत्रणा नसल्यास, एजंट आत्मविश्वासाने मृत एंडपॉइंट्सवर कमांड्स देईल. मेमरीला टाइमस्टॅम्प्स, कॉन्फिडन्स स्कोअर आणि स्वतःला अवैध (invalidate) करण्याची क्षमता असणे आवश्यक आहे.

इन्फिनाइट लूप्स हे शांत मारेकरी आहेत. एखादा एजंट वेबवर शोधतो, काहीही उपयुक्त मिळत नाही, क्वेरीमध्ये थोडा बदल करतो, पुन्हा शोधतो, काहीही मिळत नाही आणि हेच पुन्हा पुन्हा करतो. कमाल इटरेशन सीलिंग (maximum iteration ceiling) किंवा सिमेंटिक डुप्लिकेट डिटेक्शनशिवाय, वापरकर्ता वाट पाहत असताना तो टोकन्स आणि पैसे खर्च करत राहील. तुम्हाला गार्डरेल्स (guardrails) बनवावे लागतील: रिट्रायजवर कडक मर्यादा, डायव्हर्जन्स चेक आणि मानवी हस्तक्षेपाचे मार्ग (human escalation paths).

असंगत माहिती तर्कशक्तीला बुडवते. Retrieval-Augmented Generation पाइपलाइन्स अनेकदा संदर्भासाठी (context window) अस्पष्टपणे संबंधित असलेल्या पन्नास परिच्छेदांचे दस्तऐवज त्यात टाकतात. यामुळे एजंट गोंधळात पडतो आणि चुकीचे टूल निवडतो किंवा पॅरामीटरबाबत भ्रमित (hallucinate) होतो. मॉडेलने शोधलेला मजकूर पाहण्यापूर्वीच तुम्हाला फिल्टरिंग, रँकिंग आणि संक्षिप्त सारांश (summarisation) करण्याची गरज असते.

एका एजंटला केवळ बुद्धिमत्तेपेक्षा अधिक गोष्टींची गरज असते. त्याला एका प्रणालीची गरज असते: व्यवस्थापित मेमरी (managed memory), स्पष्ट स्टेट ट्रॅकिंग (state tracking), कडक गार्डरेल्स (guardrails) आणि निरीक्षणक्षम टेलिमेट्री (observable telemetry). मॉडेल जितके चांगले असेल, तितकी त्याच्या सभोवतालची प्रणाली अधिक सक्षम असणे आवश्यक आहे. एका नाजूक लूपमध्ये असलेले शक्तिशाली मॉडेल केवळ अधिक सुस्पष्ट अपयश निर्माण करते.

काम पूर्ण करणे

एजंटमधील खरी बुद्धिमत्ता म्हणजे पहिल्याच प्रयत्नात अचूक उत्तर देणे नव्हे. तर जेव्हा काहीही योजनेनुसार घडत नाही, तेव्हा हेतू (intention) आणि निकाल (outcome) यांच्यातील अंतर भरून काढणे म्हणजे खरी बुद्धिमत्ता होय. पहिला प्रयत्न करणे सोपे असते. कोणताही व्यक्ती 'हॅपी पाथ' (happy path) स्क्रिप्ट करू शकतो. कठीण भाग म्हणजे चौथी पुनरावृत्ती (iteration), जेव्हा मुख्य API बंद असते, context window कमी होत असते, वापरकर्ता अधीर होत असतो आणि एजंटला तरीही काहीतरी उपयुक्त माहिती द्यावी लागते.

हीच चिकाटी एका 'डेमो'ला 'प्रॉडक्ट'पासून वेगळे करते. प्रत्येक टप्प्यावरून शिकण्याची क्षमता म्हणजे केवळ रिअल-टाइममध्ये मॉडेल वेट्स (model weights) अपडेट करणे नव्हे, तर योजनेत (plan) बदल करणे होय. रणनीती बदलत असली तरी एजंट आपले ध्येय स्थिर ठेवतो. हेच 'looping principle' प्रत्यक्ष कृतीत आहे.

मग भविष्य मोठ्या मॉडेल्सचे आहे की अधिक चांगल्या एक्झिक्यूशन लूप्सचे (execution loops)? स्केल नक्कीच मदत करते. अधिक सक्षम मॉडेल प्रत्येक सायकलमध्ये अधिक चांगल्या प्रकारे तर्क करते. परंतु, एका घट्ट, निरीक्षणक्षम आणि लवचिक (resilient) लूपमध्ये चालणारे लहान मॉडेल, एकाच प्रयत्नात सर्व काही सोडवण्यास सांगितलेल्या महाकाय मॉडेलपेक्षा नेहमीच सरस ठरेल. अंदाज (prediction) कृतीत बदलण्याचे काम लूप करते. तिथे गुंतवणूक करा.

स्रोत: The Looping Principle: A Simple Mental Model for Understanding AI Agents

अशा अधिक चर्चांसाठी, GyaanSetu learning community on Telegram मध्ये सामील व्हा.