पहले मुझे लगता था कि AI एजेंट बनाना मूल रूप से एक चैटबॉट को प्रॉम्प्ट करने जैसा ही है। आप सवाल को अच्छी तरह से फ्रेम करते हैं, मॉडल जवाब देता है, और आपका काम हो जाता है। फिर मैंने कुछ एप्लिकेशन लॉन्च किए। हकीकत का सामना बहुत कड़वा था। एक LLM एजेंट नहीं है। एक LLM केवल अगले टोकन की भविष्यवाणी करता है। वह 'लूप' (loop) ही है जो एजेंट बनाता है।

चाय बनाने के बारे में सोचें। आप make_tea() नाम का एक सिंगल कमांड नहीं देते और चले जाते हैं। आप केतली भरते हैं, महसूस करते हैं कि नल का दबाव कम है, इंतज़ार करते हैं, उसे चालू करते हैं, देखते हैं कि स्विच खराब है, दूसरे बर्नर पर जाते हैं, भाप की जाँच करते हैं, डालते हैं, चखते हैं, और शायद शहद डालते हैं क्योंकि पत्तियां बहुत देर तक भिगोई गई थीं। लक्ष्य कभी नहीं बदलता, लेकिन कदम बदल जाते हैं। आप देखते हैं, सुधार करते हैं, और फिर से कोशिश करते हैं। AI एजेंट बिल्कुल इसी तरह काम करते हैं।

वह चक्र जो एजेंसी (Agency) बनाता है

लूप कोई अमूर्त सिद्धांत (abstract theory) नहीं है। यह आपके बदले काम करने वाले किसी भी सिस्टम की परिचालन धड़कन (operational heartbeat) है। व्यवहार में यह वास्तव में ऐसा दिखता है:

  • Think: मॉडल लक्ष्य के बारे में तर्क करता है और तय करता है कि उसे क्या चाहिए। एक यूजर पूछता है, "क्या मुझे कल पोर्टलैंड में छाता ले जाना चाहिए?" मॉडल पहचानता है कि उसे मौसम के पूर्वानुमान और एक स्थान की आवश्यकता है।
  • Act: मॉडल एक टूल का उपयोग करता है। यह "Portland" को हल करने के लिए एक geocoding API को कॉल कर सकता है, फिर निर्देशांकों (coordinates) के साथ एक मौसम एंडपॉइंट (weather endpoint) पर जा सकता है।
  • Observe: मॉडल टूल के आउटपुट को पढ़ता है। क्या API ने JSON पूर्वानुमान लौटाया, 403 एरर, या HTML मेंटेनेंस पेज?
  • Update: जो वह देखता है उसके आधार पर, मॉडल अपनी योजना में संशोधन करता है। यदि geocoder ने Portland, Oregon के बजाय Portland, Maine लौटाया, तो मॉडल को स्पष्टता (disambiguate) की आवश्यकता होगी। यदि API डाउन है, तो यह बैकअप स्रोत पर स्विच कर सकता है या यूजर से पूछ सकता है।
  • Think Again: नया संदर्भ (context) मिलते ही चक्र फिर से शुरू हो जाता है।

यह पाँच अलग-अलग फंक्शन नहीं हैं जिन्हें आप एक बार लिखकर भूल जाते हैं। यह एक निरंतर इंजन है जो तब तक चलता है जब तक लक्ष्य प्राप्त न हो जाए या कोई हार्ड स्टॉप (hard stop) ट्रिगर न हो जाए। मॉडल किसी स्क्रिप्ट की तरह कोड निष्पादित (execute) नहीं कर रहा है। यह दुनिया की स्थिति के बारे में तर्क कर रहा है, एक क्रिया चुन रहा है, उसके परिणाम को पढ़ रहा है, और तय कर रहा है कि आगे क्या होगा। यही एक शानदार ऑटो-कम्प्लीट और काम पूरा करने वाले एजेंट के बीच का अंतर है।

सभी फ्रेमवर्क एक जैसे क्यों दिखते हैं

यदि आपने LangGraph, CrewAI, या AutoGen के साथ समय बिताया है, तो आपने शायद गौर किया होगा कि वे एक जैसे लगने लगते हैं। LangGraph प्रवाह (flow) को नोड्स और एड्जेस (nodes and edges) के एक निरंतर ग्राफ के रूप में मॉडल करता है। CrewAI एजेंटों को भूमिकाओं (roles) और क्रू (crews) में व्यवस्थित करता है। AutoGen मल्टी-एजेंट बातचीत का संचालन (orchestrate) करता है। पैकेजिंग अलग है, लेकिन ढांचा (skeleton) वही है।

वे समान दिखते हैं क्योंकि वे सभी इसी लूपिंग सिद्धांत के इर्द-गिर्द बनाए गए हैं। LangGraph स्पष्ट रूप से टूल कॉल और मॉडल इन्फरेंस (inference) के बीच स्टेट ट्रांजिशन (state transitions) के रूप में चक्र को संरचना देता है। CrewAI लूप को भूमिका-आधारित एजेंटों के भीतर लपेटता है, लेकिन प्रत्येक क्रू मेंबर अभी भी प्लानिंग, एक्टिंग और ऑब्जर्विंग के चक्र से गुजरता है। AutoGen अभिनेताओं (actors) के बीच संदेशों का समन्वय करता है, फिर भी हर टर्न अभी भी जनरेट, एक्जीक्यूट, रिफ्लेक्ट और रूट का एक रूपांतर है।

ये फ्रेमवर्क लूप पर ध्यान केंद्रित करते हैं क्योंकि एजेंसी वहीं बसती है। अंतर्निहित मॉडल GPT-4, Claude, या एक फाइन-ट्यून किया गया ओपन-वेट मॉडल हो सकता है। लूप के बिना, आपके पास एक बहुत महंगा वाक्य पूरा करने वाला (sentence completer) टूल है। लूप के साथ, आपके पास एक ऐसा सिस्टम है जो कई प्रयासों के माध्यम से एक उद्देश्य की ओर बढ़ सकता है।

जब असली काम शुरू होता है

लोकल डेमो जादुई लगते हैं। प्रोडक्शन वह जगह है जहाँ जादू का सामना अव्यवस्था (mess) से होता है। एक बार जब आप प्रोटोटाइपिंग से आगे बढ़ जाते हैं, तो आप AI समस्याओं को हल करना बंद कर देते हैं और सिस्टम इंजीनियरिंग की समस्याओं को हल करना शुरू कर देते हैं।

Tool failures are inevitable. APIs टाइम आउट हो जाते हैं। वे गलत तरीके से बना हुआ (malformed) JSON लौटाते हैं। वे HTML में लिपटे 500 एरर देते हैं। यदि आपका लूप आँख बंद करके हर टूल आउटपुट पर भरोसा करता है, तो आपका एजेंट सफलता का भ्रम (hallucinate success) पैदा करेगा या भ्रम में फंस जाएगा। आपको हर रिटर्न पेलोड पर रिट्राय लॉजिक (retry logic), सर्किट ब्रेकर्स और स्कीमा वैलिडेशन की आवश्यकता है।

Memory goes stale. आपका एजेंट याद रखता है कि यूजर का पसंदीदा डेटाबेस PostgreSQL है, लेकिन इंफ्रास्ट्रक्चर टीम ने कल रात एक नए क्लस्टर पर माइग्रेट कर दिया। संदर्भ (context) को रिफ्रेश या एक्सपायर करने के तंत्र के बिना, एजेंट आत्मविश्वास के साथ मृत एंडपॉइंट्स के खिलाफ कमांड जारी करेगा। मेमोरी को टाइमस्टैम्प, कॉन्फिडेंस स्कोर और खुद को अमान्य (invalidate) करने की क्षमता की आवश्यकता होती है।

Infinite loops are silent killers. एक एजेंट वेब पर खोजता है, कुछ भी उपयोगी नहीं पाता, क्वेरी को थोड़ा सुधारता है, फिर से खोजता है, कुछ नहीं पाता, और यही दोहराता रहता है। अधिकतम इटरेशन सीमा (maximum iteration ceiling) या सिमेंटिक डुप्लिकेट डिटेक्शन के बिना, यह यूजर के इंतज़ार करते समय टोकन और पैसा बर्बाद करेगा। आपको गार्डरेल्स (guardrails) बनाने होंगे: रिट्राय पर हार्ड कैप, डाइवर्जेंस चेक और ह्यूमन एस्केलेशन पाथ।

अप्रासंगिक डेटा तर्क को दबा देता है। Retrieval-Augmented Generation पाइपलाइन्स अक्सर कॉन्टेक्स्ट विंडो में अस्पष्ट रूप से संबंधित दस्तावेज़ों के पचास पैराग्राफ डाल देती हैं। एजेंट शोर के कारण उलझ जाता है और गलत टूल चुन लेता है या किसी पैरामीटर को लेकर भ्रमित (hallucinate) हो जाता है। मॉडल द्वारा रिट्रीव किए गए टेक्स्ट को देखने से पहले आपको फ़िल्टरिंग, रैंकिंग और संक्षिप्त सारांश की आवश्यकता होती है।

एक एजेंट को बुद्धिमत्ता से कहीं अधिक की आवश्यकता होती है। उसे एक सिस्टम चाहिए: मैनेज्ड मेमोरी, स्पष्ट स्टेट ट्रैकिंग, सख्त गार्डरेल्स और ऑब्जर्वेबल टेलीमेट्री। मॉडल जितना बेहतर होगा, उसके आसपास का सिस्टम भी उतना ही बेहतर होना चाहिए। एक नाजुक लूप के भीतर एक शक्तिशाली मॉडल केवल अधिक स्पष्ट विफलताएं ही पैदा करता है।

काम को पूरा करना

एजेंटों में सच्ची बुद्धिमत्ता पहली बार में सही उत्तर देने के बारे में नहीं है। यह तब इरादे और परिणाम के बीच के अंतर को पाटने के बारे में है जब कुछ भी योजना के अनुसार नहीं होता है। पहला प्रयास आसान होता है। कोई भी 'हैप्पी पाथ' को स्क्रिप्ट कर सकता है। कठिन हिस्सा चौथा इटरेशन होता है, जब प्राइमरी API डाउन हो, कॉन्टेक्स्ट विंडो सिकुड़ रही हो, यूजर अधीर हो रहा हो, और एजेंट को फिर भी कुछ उपयोगी देना हो।

यही दृढ़ता एक डेमो को प्रोडक्ट से अलग करती है। यह हर कदम से सीखने की क्षमता है, रीयल-टाइम में मॉडल वेट्स को अपडेट करके नहीं, बल्कि योजना (plan) को अपडेट करके। एजेंट लक्ष्य को स्थिर रखता है जबकि कार्यनीति बदलती रहती है। यही 'लूपिंग प्रिंसिपल' का क्रियान्वयन है।

तो क्या भविष्य बड़े मॉडल्स का है या बेहतर एग्जीक्यूशन लूप्स का? स्केल निश्चित रूप से मदद करता है। एक अधिक सक्षम मॉडल प्रत्येक चक्र के भीतर बेहतर तर्क करता है। लेकिन एक टाइट, ऑब्जर्वेबल और रेजिलिएंट लूप के भीतर चलने वाला एक छोटा मॉडल लगभग हमेशा उस विशाल मॉडल से बेहतर प्रदर्शन करेगा जिसे एक ही बार में सब कुछ हल करने के लिए कहा गया हो। लूप ही वह चीज़ है जो पूर्वानुमान को कार्रवाई में बदल देता है। वहीं निवेश करें।

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

इस तरह की और चर्चाओं के लिए, Telegram पर GyaanSetu लर्निंग कम्युनिटी से जुड़ें.