AI एजेंट्स का इंजीनियरिंग एनाटॉमी: वैचारिक मॉडल से रेजिलिएंट प्रोडक्शन आर्किटेक्चर तक

AI एजेंट्स के बारे में अधिकांश तकनीकी चर्चाएं व्यापक सामान्यीकरणों पर समाप्त हो जाती हैं: "एक एजेंट टूल्स से जुड़ा हुआ एक मॉडल है।"

यद्यपि यह परिभाषा वैचारिक रूप से सही है, लेकिन यह उन सॉफ्टवेयर इंजीनियरिंग वास्तविकताओं को पूरी तरह नजरअंदाज कर देती है जो इन प्रणालियों को नियतात्मक (deterministic), दोष-सहिष्णु (fault-tolerant) और आर्थिक रूप से व्यावहारिक बनाने के लिए आवश्यक हैं। व्यवहार में, एक एजेंट का निर्माण प्रॉम्प्ट इंजीनियरिंग से बहुत कम और डिस्ट्रिब्यूटेड सिस्टम्स इंजीनियरिंग, स्टेट मशीन्स और API ऑर्केस्ट्रेशन से बहुत अधिक संबंधित है।

आइए परिचयात्मक अवधारणाओं से आगे बढ़ें और उन सटीक मैकेनिक्स, डेटा स्ट्रक्चर्स और रनटाइम लाइफसाइकिल को डिकंस्ट्रक्ट करें जो प्रोडक्शन में ऑटोनॉमस एजेंट्स को नियंत्रित करते हैं।

1. एजेंट रनटाइम लाइफसाइकिल का विश्लेषण

हार्डवेयर के स्तर पर, एक लार्ज लैंग्वेज मॉडल (LLM) एक स्टेटलेस (stateless) नेक्स्ट-टोकन प्रिडिक्टर होता है। इसमें कोई सतत चेतना नहीं होती, कोई बैकग्राउंड वर्कर थ्रेड नहीं होता, और "पुनः प्रयास करने" की कोई आंतरिक अवधारणा नहीं होती।

एजेंसी वास्तव में एक बाहरी रनटाइम इंजन द्वारा निर्मित भ्रम है। यह रनटाइम लगातार एक बंद लूप में मॉडल को इनवोक करता है, संरचित जनरेशन आउटपुट को इंटरसेप्ट करता है, बाहरी कॉल निष्पादित करता है, और पर्यावरण पेलोड को संदर्भ विंडो (context window) में वापस फीड करता है।

┌────────────────────────────────────────────────────────────────────────┐ │ एजेंट रनटाइम इंजन │ │ │ │ उपयोगकर्ता लक्ष्य / घटना (User Goal / Event) │ │ │ │ │ ▼ │ │ ┌──────────────┐ अनुमान अनुरोध ┌─────────────────────┐ │ │ │ State / Env │ ────────────────────────► │ फाउंडेशन मॉडल │ │ │ │ Context Pack │ ◄──────────────────────── │ (रीजनिंग/प्लानर) │ │ │ └──────────────┘ संरचित टूल कॉल └─────────────────────┘ │ │ ▲ │ │ │ │ ▼ │ │ │ ┌────────────────────┐ │ │ │ │ टूल कॉल राउटर │ │ │ │ └─────────┬──────────┘ │ │ │ │ │ │ अवलोकन पेलोड ▼ │ │ │ ┌────────────────────┐ │ │ └─────────── │ निष्पादक / सैंडबॉक्स│ │ │ └────────────────────┘ │ └────────────────────────────────────────────────────────────────────────┘

माइक्रो-स्टेप अनुक्रम (The Micro-Step Sequence)

एक एजेंट का प्रत्येक असतत निष्पादन लूप चार नियतात्मक चरणों से मिलकर बनता है:

कंटेक्स्ट संकलन (Context Compilation): रनटाइम सिस्टम निर्देशों, संवादी स्मृति, गतिशील टूल परिभाषाओं (JSON स्कीमा के रूप में), और हालिया निष्पादन इतिहास को एक सीमित टोकन बजट में इकट्ठा करता है।
अनुमान और शाखा मूल्यांकन: मॉडल इनमें से किसी एक का आउटपुट देता है:
- एक अंतिम टेक्स्ट प्रतिक्रिया (कार्य पूरा होने या उपयोगकर्ता से स्पष्टीकरण का संकेत)।
- एक पूर्वनिर्धारित JSON स्कीमा (फ़ंक्शन नाम + टाइप किए गए तर्क) से मेल खाने वाला संरचित टूल कॉल अनुरोध।
डिस्पैच और सैंडबॉक्स्ड निष्पादन: होस्ट सिस्टम टूल कॉल को पकड़ता है, सख्त स्कीमा के विरुद्ध तर्कों को मान्य करता है, और लक्षित फ़ंक्शन को निष्पादित करता है (उदा. डेटाबेस क्वेरी, API आमंत्रण, फाइल सिस्टम ऑपरेशन)।
ऑब्जर्वेशन इंजेक्शन (Observation Injection): टूल द्वारा लौटाए गए stdout, stderr या JSON पेलोड को एक मानकीकृत टूल रिस्पॉन्स फॉर्मेट में लपेटा जाता है और मैसेज ऐरे में वापस जोड़ा जाता है। लूप चरण 1 पर रीसेट हो जाता है।

2. उन्नत संज्ञानात्मक और निष्पादन टोपोलॉजी

पारंपरिक ReAct (Reason + Act) लूप सरल, एकल-बारी खोजों के लिए पर्याप्त है। हालाँकि, बहु-घंटे, गैर-तुच्छ इंजीनियरिंग कार्यों के लिए, एकल-लूप आर्किटेक्चर तेजी से ख़राब हो जाते हैं। औद्योगिक एजेंट आर्किटेक्चर अधिक परिष्कृत निष्पादन टोपोलॉजी पर निर्भर करते हैं।

A. ReAct B. Plan-and-Solve (DAG) ┌──────────────────┐ ┌────────────────────────┐ │ Thought ──► Act │ │ उच्च-स्तरीय प्लानर │ │ ▲ │ │ └───────────┬────────────┘ │ └─────┘ │ │ उत्पन्न करता है └──────────────────┘ ▼ [T1] ──► [T2] ──► [T3] (स्थैतिक या गतिशील DAG) C. Evaluator-Optimizer (परावर्तन / Reflection) ┌───────────────────────────────────────────────────────────┐ │ ┌───────────────┐ कलाकृति ┌────────────────┐ │ │ │ जनरेटर │ ────────────────► │ मूल्यांकनकर्ता│ │ │ └───────────────┘ └────────┬───────┘ │ │ ▲ │ │ │ └──────── फीडबैक / आलोचना ────────────┘ │ └───────────────────────────────────────────────────────────┘

A. गतिशील DAG (Directed Acyclic Graph) निष्पादन

बिना किसी दूरदर्शिता के एक बार में एक कदम उठाने के बजाय, एक प्लानर मॉडल (Planner Model) असतत उप-कार्यों का एक निर्भरता ग्राफ उत्पन्न करता है।

नोड्स विशिष्ट उप-लक्ष्यों का प्रतिनिधित्व करते हैं (उदा. FetchLogs, ParseStacktrace, LocateSourceFile)।
निर्देशित किनारे डेटा निर्भरता का प्रतिनिधित्व करते हैं (उदा. LocateSourceFile को ParseStacktrace के आउटपुट की आवश्यकता होती है)।
शून्य परस्पर निर्भरता वाले कार्य वर्कर थ्रेड्स में समवर्ती (concurrently) रूप से चलते हैं, जिससे लेटेंसी में भारी कमी आती है।

B. Evaluator-Optimizer / परावर्तन लूप (Reflection Loop)

जब सटीकता की सीमाएं सख्त होती हैं (जैसे कोड संकलन या डेटाबेस माइग्रेशन), जनरेशन और वैलिडेशन के बीच जिम्मेदारियों का पृथक्करण अनिवार्य हो जाता है।

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

3. फंक्शन कॉलिंग प्रोटोकॉल: मॉडल कोड से कैसे बात करते हैं

आधुनिक मॉडल्स को ढीले मार्कडाउन स्ट्रिंग्स के बजाय नेटिव फंक्शन-कॉलिंग फॉर्मेट्स आउटपुट करने के लिए RLHF और फाइन-ट्यूनिंग के माध्यम से प्रशिक्षित किया जाता है।

जब हम एजेंट इंजन के साथ किसी टूल को पंजीकृत करते हैं, तो हम एक OpenAPI/JSON स्कीमा प्रदान करते हैं। उदाहरण के लिए, एक फाइल सिस्टम राइटर पंजीकृत करना:

{
  "name": "write_source_file",
  "description": "अनुमत वर्कस्पेस निर्देशिका के भीतर डिस्क पर फ़ाइल लिखता या अधिलेखित करता है।",
  "parameters": {
    "type": "object",
    "properties": {
      "file_path": {
        "type": "string",
        "description": "लक्षित फ़ाइल का सापेक्ष पथ।"
      },
      "content": {
        "type": "string",
        "description": "लिखी जाने वाली सटीक UTF-8 एन्कोडेड टेक्स्ट सामग्री।"
      }
    },
    "required": ["file_path", "content"]
  }
}

तर्क पार्सिंग और टाइप-सेफ्टी सीमा

जब मॉडल एक टूल कॉल उत्सर्जित करता है, तो एजेंट रनटाइम को कच्चे स्ट्रिंग तर्कों को सीधे निष्पादन कार्यों में पास नहीं करना चाहिए। प्रोडक्शन में, एक मध्यवर्ती सीरियलाइजेशन लेयर (जैसे पायथन में Pydantic या टाइपस्क्रिप्ट में Zod) सख्त रनटाइम वैलिडेशन करती है:

मॉडल आउटपुट (Raw String) │ ▼ JSON पार्सर (त्रुटिपूर्ण ब्रेसिज़/एस्केप का पता लगाता है) │ ▼ टाइप और सीमा वैलिडेटर (Zod / Pydantic) ├── जाँचता है: क्या `file_path` जेल निर्देशिका के बाहर है? ├── जाँचता है: क्या `content` आकार सीमा के भीतर है? │ ├── [मान्य] ──► OS फ़ाइल डिस्क्रिप्टर को आमंत्रित करता है └── [अमान्य] ──► स्कीमा एरर पकड़ता है ──► संदर्भ में एरर ट्रेस लौटाता है

यह प्रॉम्प्ट इंजेक्शन एस्केप, डायरेक्टरी ट्रैवर्सल कारनामों (उदा. ../../etc/passwd), या अनहैंडल्ड रनटाइम अपवादों जैसी सामान्य सुरक्षा समस्याओं को रोकता है।

4. बहु-स्तरीय मेमोरी आर्किटेक्चर (Multi-Tiered Memory)

कंटेक्स्ट विंडो का नाटकीय रूप से विस्तार हुआ है, लेकिन इसे अपने एकमात्र मेमोरी तंत्र के रूप में मानना त्रुटिपूर्ण है। संदर्भ में मौजूद टोकन क्षणिक, महंगे और ध्यान क्षरण ("बीच में खो जाना" / Lost in the Middle सिंड्रोम) के अधीन होते हैं।

प्रोडक्शन एजेंट फ्रेमवर्क एक खंडित मेमोरी पदानुक्रम तैनात करते हैं:

मेमोरी स्तर	अंतर्निहित तंत्र	प्राथमिक विशेषताएं और दायरा
1. वर्किंग मेमोरी	इन-कंटेक्स्ट बफ़र और स्क्रैचपैड	उच्चतम निष्ठा, क्षणिक, कड़ाई से टोकन-बाउंड। तत्काल प्रॉम्प्ट और सक्रिय टूल पेलोड रखता है।
2. सिमेंटिक मेमोरी	वेक्टर एम्बेडिंग (HNSW इंडेक्स)	विशाल डेटा संग्रह, तकनीकी दस्तावेज, कोडबेस और डोमेन मैनुअल पर अतुल्यकालिक खोज।
3. संरचित स्थिति (State)	रिलेशनल DB / की-वैल्यू स्टोर (SQLite/PostgreSQL)	नियतात्मक तथ्य, सत्र फ़्लैग, कार्य स्थिति चर, लेनदेन चेकपॉइंट और उपयोगकर्ता प्राथमिकताएं।
4. प्रासंगिक मेमोरी (Episodic)	अनुभव इतिहास और ट्रेस लॉग्स	पिछले निष्पादनों, सफल रणनीतियों और दर्ज विफलता मोड के दीर्घकालिक लॉग्स।

कंटेक्स्ट कॉम्पैक्शन द्वारा वर्किंग मेमोरी का प्रबंधन

जैसे-जैसे एक एजेंट बहु-चरणीय निष्पादन के माध्यम से आगे बढ़ता है, बातचीत का इतिहास बढ़ता जाता है। जब टोकन संख्या एक महत्वपूर्ण सीमा (उदा. सीमा का 75%) तक पहुँच जाती है, तो रनटाइम को डिटरमिनिस्टिक स्टेट कॉम्पैक्शन करना चाहिए:

स्लाइडिंग विंडो: वर्तमान लक्ष्य को बनाए रखने के लिए प्रारंभिक सिस्टम निर्देश और सबसे हालिया N इंटरैक्शन को अक्षुण्ण रखें।
रिकर्सिव सारांशीकरण: मध्यवर्ती टूल चरणों (चरण 2 से K) को एक तेज़ मॉडल में इस प्रॉम्प्ट के साथ पास करें: "इन मध्यवर्ती परिचालनों को निर्णयों, सत्यापित स्थिति और लंबित मुद्दों को सूचीबद्ध करने वाले एक संरचित निष्पादन लॉग में संपीड़ित करें।"
पेलोड प्रूनिंग: विस्तृत ऐतिहासिक पेलोड (उदा. चरण 3 से 10,000-पंक्ति का CSV आउटपुट) को एक हल्के पॉइंटर से बदलें: [डेटा लोड किया गया: 10,000 पंक्तियाँ session_cache_id_948 में संग्रहीत].

5. मॉडल कंटेक्स्ट प्रोटोकॉल (MCP): एंटरप्राइज इंटीग्रेशन स्टैंडर्ड

मॉडल कंटेक्स्ट प्रोटोकॉल (MCP) की शुरूआत से पहले, एक एजेंट को एंटरप्राइज डेटाबेस, आंतरिक प्रलेखन और बाहरी प्लेटफार्मों से जोड़ने के लिए प्रत्येक टूल और रनटाइम के लिए अलग कनेक्टर कोड लिखना पड़ता था।

MCP मानक ट्रांसपोर्ट्स पर एक खुला, क्लाइंट-होस्ट-सर्वर विनिर्देश प्रदान करता है:

┌───────────────────────────────────────────────────────────┐ │ MCP होस्ट (क्लाइंट) │ │ (एजेंट रनटाइम / डेवलपमेंट UI) │ └─────────────┬───────────────────────────────┬─────────────┘ │ JSON-RPC 2.0 (stdio/SSE) │ ▼ ▼ ┌───────────────────────┐ ┌───────────────────────┐ │ MCP सर्वर: Git │ │ MCP सर्वर: Postgres │ ├───────────────────────┤ ├───────────────────────┤ │ उपलब्ध कराता है: │ │ उपलब्ध कराता है: │ │ • टूल्स: commit, diff │ │ • टूल्स: run_query │ │ • संसाधन: repos │ │ • संसाधन: schemas │ └───────────────────────┘ └───────────────────────┘

MCP के मूल तत्व:

टूल्स (Tools): साइड इफेक्ट वाले कॉल करने योग्य रूटीन (उदा. रिकॉर्ड अपडेट करना, बिल्ड ट्रिगर करना, टेस्ट सुइट चलाना)।
संसाधन (Resources): केवल-पढ़ने योग्य डेटा पेलोड (उदा. फ़ाइल सामग्री, सिस्टम लॉग, डेटाबेस स्कीमा) जिन्हें मॉडल निष्पादन साइड इफेक्ट के बिना संदर्भ के रूप में संदर्भित कर सकता है।
प्रॉम्प्ट्स (Prompts): सर्वर द्वारा होस्ट किए गए प्री-पैकेज्ड टेम्प्लेट और सिस्टम व्यक्तित्व जो यह मार्गदर्शन करते हैं कि मॉडल को उस विशिष्ट संसाधन के साथ कैसे इंटरैक्ट करना चाहिए।

विशिष्ट टूल API से रीजनिंग इंजन को अलग करके, संगठन अपने निजी बुनियादी ढांचे को एक बार MCP सर्वर के रूप में उजागर कर सकते हैं, जिससे किसी भी संगत एजेंट को कस्टम कनेक्टर लॉजिक के बिना इसके साथ सुरक्षित रूप से बातचीत करने की अनुमति मिलती है।

6. मल्टी-एजेंट ऑर्केस्ट्रेशन पैटर्न

जब वर्कफ़्लो जटिलता में बड़े होते हैं, तो एकल-एजेंट सिस्टम प्रदर्शन की सीमा का सामना करते हैं। यदि एक ही मॉडल आर्किटेक्ट बनने, साफ कोड लिखने, सुरक्षा बाधाओं का ऑडिट करने और दस्तावेज लिखने का प्रयास एक साथ करता है, तो ध्यान भटकता है और गुणवत्ता गिर जाती है।

आधुनिक रूपरेखाएँ इसे मल्टी-एजेंट ऑर्केस्ट्रेशन (स्टेट ग्राफ्स) के माध्यम से हल करती हैं।

┌─────────────┐ │ START: लक्ष्य│ └──────┬──────┘ │ ▼ ┌────────────────────────┐ │ सुपरवाइजर / राउटर │ └──────────┬─────────────┘ │ ┌──────────────────┴──────────────────┐ ▼ ▼ ┌─────────────────────┐ ┌─────────────────────┐ │ सीनियर देव एजेंट │ │ सुरक्षा QA एजेंट │ │ (विशेषीकृत प्रॉम्प्ट) │ │ (विशेषीकृत प्रॉम्प्ट) │ └──────────┬──────────┘ └──────────┬──────────┘ │ │ └──────────────────┬──────────────────┘ │ ▼ ┌────────────────────────┐ │ कन्वर्जेंस / गेट चेक │ │ (स्टेट मशीन सत्यापन) │ └──────────┬─────────────┘ │ ┌──────────────────┴──────────────────┐ [स्वीकृत] [अस्वीकृत] │ │ ▼ ▼ ┌─────────────┐ ┌─────────────┐ │ END: मर्ज │ │ रूट बैक │ └─────────────┘ └─────────────┘

नियतात्मक स्टेट ग्राफ डिजाइन (Deterministic State Graphs)

आधुनिक मल्टी-एजेंट आर्किटेक्चर एजेंटों को खुली संवादी थ्रेड्स के माध्यम से संचार करने की अनुमति देने से बचते हैं। इसके बजाय, वे सहयोग को Deterministic Finite Automata (DFA) / स्टेट ग्राफ्स के रूप में मॉडल करते हैं:

साझा स्थिति स्कीमा (Shared State Schema): एक एकल वैश्विक शब्दकोश या डेटाबेस मॉडल कार्य की स्थिति का प्रतिनिधित्व करता है (उदा. { "files_modified": [], "unit_test_status": "PENDING", "retry_count": 0 }).
स्पष्ट संक्रमण (Explicit Transitions): सुपरवाइजर एजेंट स्वतंत्र रूप से नहीं बोलता; यह एक टाइप किया हुआ एज ट्रांज़िशन उत्सर्जित करता है (उदा. NEXT -> QA_NODE).
गार्ड स्थितियां (Guard Conditions): हार्डकोडेड कोड गेट किसी एज ट्रांज़िशन की अनुमति देने से पहले invariants को सत्यापित करते हैं। यदि unit_test_status != "PASSED", तो स्टेट ग्राफ DEPLOY नोड में जाने से रोकता है, भले ही एलएलएम कुछ भी सिफारिश करे।

7. प्रोडक्शन इंजीनियरिंग: गार्डरेल्स, सुरक्षा और ऑब्जर्वेबिलिटी

एक एजेंट प्रणाली को प्रयोगात्मक प्रोटोटाइप से प्रोडक्शन में ले जाने के लिए व्यापक परिचालन सुरक्षा उपायों की आवश्यकता होती है।

परिचालन गार्डरेल्स

जोखिम वेक्टर	विफलता मोड	शमन रणनीति
रिकर्सिव डेडलॉक	एजेंट बार-बार उसी असफल कमांड का प्रयास करता रहता है।	एक्सपोनेंशियल बैकऑफ़, अधिकतम पुनरावृत्ति गहराई (`max_steps=15`), और नियतात्मक चक्र-पहचान स्टेट हैश।
कंटेक्स्ट बॉम्बिंग	एक API अप्रत्याशित रूप से बड़ा पेलोड (उदा. 50MB) लौटाता है, जिससे टोकन बजट समाप्त हो जाता है।	स्ट्रीम निरीक्षण, पेलोड ट्रंकेशन, और संदर्भ आईडी के साथ बाहरी ऑब्जेक्ट स्टोरेज में बड़ा डेटा सहेजना।
मनमाना कोड निष्पादन	एजेंट विनाशकारी शेल कमांड उत्पन्न करता है (`rm -rf /` या अनधिकृत नेटवर्क इग्रेस)।	सैंडबॉक्स्ड वातावरण (Docker, Firecracker microVMs, WebAssembly), गैर-रूट विशेषाधिकार, और अल्पकालिक भंडारण।
वित्तीय / संसाधन की बर्बादी	एजेंट अनियंत्रित लूप में प्रवेश करता है, जिससे भारी API क्रेडिट खर्च होते हैं।	प्रति-रन निश्चित खर्च सीमा, आक्रामक टोकन बजट सीमा और सख्त निष्पादन टाइमआउट।

ऑब्जर्वेबिलिटी और ट्रेसिंग (Observability & Tracing)

पारंपरिक APM टूल्स एजेंटों की स्टोकेस्टिक प्रकृति को कैप्चर करने में विफल रहते हैं। प्रोडक्शन परिनियोजन के लिए समर्पित ट्रेसिंग टूल्स (उदा. OpenTelemetry-आधारित LLM ट्रेसर्स, Langfuse, Arize Phoenix) की आवश्यकता होती है जो लॉग करते हैं:

तय किया गया सटीक ग्राफ पथ।
प्रत्येक मध्यवर्ती चरण के लिए पूर्ण टोकन गणना और लागत।
कच्चा इनपुट संदर्भ और मॉडल प्रतिक्रिया पेलोड।
टूल निष्पादन विलंबता और पहली टोकन तक का समय (TTFT)।

8. सारांश: मानसिकता में बदलाव

प्रोडक्शन-रेडी AI एजेंटों के निर्माण के लिए प्रॉम्प्ट-केंद्रित दृष्टिकोण से सिस्टम-केंद्रित दृष्टिकोण पर स्थानांतरित होने की आवश्यकता है:

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

मुख्य आर्किटेक्चरल निष्कर्ष

एजेंसी एक बाहरी लूप है: LLMs स्टेटलेस नेक्स्ट-टोकन प्रिडिक्टर हैं; सतत एजेंसी टूल कॉल्स को इंटरसेप्ट करने वाले होस्ट रनटाइम इंजन द्वारा संचालित होती है।
सीमाओं पर टाइप सुरक्षा: कच्चे स्ट्रिंग्स को सीधे निष्पादित न करें — OS प्रिमिटिव्स को छूने से पहले Pydantic या Zod स्कीमा के खिलाफ फ़ंक्शन कॉल को सत्यापित करें।
कंटेक्स्ट मेमोरी नहीं है: डिटरमिनिस्टिक कॉम्पैक्शन और पेलोड प्रूनिंग के साथ टियरड मेमोरी (वर्किंग, सिमेंटिक, स्ट्रक्चर्ड, एपिसोडिक) का उपयोग करके एजेंट की कार्य अवधि बढ़ाएं।
स्टेट ग्राफ्स के माध्यम से नियमों को लागू करें: अनियंत्रित एजेंट चैट को कोड-प्रवर्तित गार्ड गेट्स वाली नियतात्मक स्टेट मशीनों से बदलें।

संबंधित तकनीकी पुस्तक

Agentic AI Systems & Autonomous Agents

स्वायत्त AI एजेंट्स, डिटरमिनिस्टिक कंट्रोल लूप्स, Model Context Protocol (MCP) और प्रोडक्शन सुरक्षा पर आधारित आधिकारिक हैंडबुक।

पुस्तकों में देखें Amazon पर खरीदें (ASIN: B0H8FP3VGX)

संदर्भ और प्रामाणिक स्रोत

Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2022): ReAct: Synergizing Reasoning and Acting in Language Models. International Conference on Learning Representations (ICLR 2023). arXiv:2210.03629. उपलब्ध लिंक: https://arxiv.org/abs/2210.03629
Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., & Yao, S. (2023): Reflexion: Language Agents with Verbal Reinforcement Learning. Advances in Neural Information Processing Systems (NeurIPS 2023). arXiv:2303.11366. उपलब्ध लिंक: https://arxiv.org/abs/2303.11366
Anthropic (2024): The Model Context Protocol (MCP) Specification. ओपन-सोर्स टूल और रिसोर्स कनेक्टिविटी मानक। उपलब्ध लिंक: https://modelcontextprotocol.io/
Wang, L., Ma, C., Feng, X., Zhang, S., Yang, H., Zhang, J., Chen, Z., Tang, J., Chen, X., Lin, Y., Zhao, W. X., Wei, Z., & Wen, J. R. (2024): A Survey on Large Language Model based Autonomous Agents. Frontiers of Computer Science. arXiv:2308.11432. उपलब्ध लिंक: https://arxiv.org/abs/2308.11432
OpenTelemetry (2024): Semantic Conventions for Generative AI Operations and Spans. Cloud Native Computing Foundation (CNCF). उपलब्ध लिंक: https://opentelemetry.io/docs/specs/semconv/gen-ai/