जैसे-जैसे एजेंट अधिक महत्वाकांक्षी कार्य करते हैं, उन्हें निम्नलिखित में कठिनाई होती है:
- बड़े पैमाने पर काम को विश्वसनीय रूप से पूरा करना
- अपने स्वयं के संदर्भ का प्रबंधन करना
हम इन चुनौतियों से निपटने के लिए एक प्रयोग कर रहे हैं, जिसे हम गतिशील उप-एजेंट कह रहे हैं: सामान्य टूल कॉलिंग के माध्यम से उप-एजेंट कार्य जारी करने के बजाय, एजेंट एक छोटी स्क्रिप्ट लिखता है जो उप-एजेंट निष्पादन को संचालित करती है। इसका मतलब है कि मॉडल उन कोड पैटर्न पर भरोसा कर सकते हैं जिन्हें लिखने में वे अच्छे हैं (जैसे लूपिंग, ब्रांचिंग, या कंकरेंसी) ताकि कार्य के अनुरूप ऑर्केस्ट्रेशन लॉजिक लिखा जा सके।
गतिशील उप-एजेंट क्यों?
Deep Agents पहले से ही उप-एजेंट को सपोर्ट करता है। वे संदर्भ को अलग करते हैं, मुख्य एजेंट को काम की अलग-अलग इकाइयाँ सौंपने देते हैं, और मध्यवर्ती परिणामों को मुख्य कॉन्टेक्स्ट विंडो से बाहर रखते हैं। तो फिर हमें गतिशील उप-एजेंट की आवश्यकता क्यों है?
सामान्य उप-एजेंट के साथ, उन्हें एक बार में एक कॉल किया जाता है, मुख्य मॉडल द्वारा सीधे उन्हें आमंत्रित करके। यह छोटे पैमाने पर काम करता है। लेकिन जब आपको सैकड़ों उप-एजेंट उत्पन्न करने की आवश्यकता होती है, या जब ऑर्केस्ट्रेशन लॉजिक सशर्त या बहु-चरणीय होता है, तो यह विफल हो जाता है।
गतिशील उप-एजेंट प्रोग्रामेटिक ऑर्केस्ट्रेशन के साथ इस समस्या को हल करते हैं। टूल कॉल को एक-एक करके करने के बजाय, एजेंट एक छोटी स्क्रिप्ट लिखता है जो उप-एजेंट को ऑर्केस्ट्रेट और कॉल करती है, और इसे एक हल्के इंटरप्रेटर में चलाती है।
इसका विहित उदाहरण: 300 पेज के दस्तावेज़ के प्रति पेज एक उप-एजेंट। 300 बार उप-एजेंट टूल को कॉल करने के बजाय, एजेंट एक लूप लिखता है:
1const results = await Promise.all(pages.map(page =>2 task({ description: `Summarize page ${page.number}`, subagentType: "summarizer" })3));
यह दो ऐसी चीज़ें खोलता है जो टूल-कॉल-आधारित ऑर्केस्ट्रेशन विश्वसनीय रूप से प्रदान नहीं कर सकता:
बड़े पैमाने पर नियतात्मक कवरेज। संरचना के बिना, एजेंट दायरे के बारे में निर्णय लेते हैं, 500 में से 75 आइटम की जांच करके काम खत्म कर देते हैं। एक डिस्पैच लूप ऐसा नहीं करता। कवरेज एक संरचनात्मक गारंटी बन जाता है, न कि प्रॉम्प्ट इंजीनियरिंग की समस्या।
विश्वसनीय जटिल ऑर्केस्ट्रेशन। ऑर्केस्ट्रेशन को कोड के रूप में लिखना, मॉडल द्वारा इसे टूल कॉल के अनुक्रम के रूप में पुन: प्रस्तुत करने की तुलना में अधिक विश्वसनीय है, विशेष रूप से फैन-आउट + सिंथेसिस, मल्टी-फेज पाइपलाइन, या सशर्त ब्रांचिंग के लिए।
यह Claude Code में वर्कफ़्लो और Recursive Language Models (RLMs) के पीछे भी यही विचार है: एक मॉडल कोड लिखता है, और वह कोड अधिक एजेंटों को डिस्पैच करता है।
त्वरित आरंभ
गतिशील उप-एजेंट के लिए दो चीज़ों की आवश्यकता होती है: काम डिस्पैच करने के लिए उप-एजेंट, और एक कोड इंटरप्रेटर: एक सुरक्षित, हल्का रनटाइम जहाँ मॉडल ऑर्केस्ट्रेशन कोड लिखता और निष्पादित करता है। Deep Agents में QuickJS पर आधारित एक वैकल्पिक कोड इंटरप्रेटर शामिल है। इसका उपयोग करने के लिए, QuickJS मिडलवेयर पैकेज इंस्टॉल करें, फिर create_deep_agent पर middleware तर्क के माध्यम से CodeInterpreterMiddleware पास करें।
1pip install -U "deepagents[quickjs]"
1from deepagents import create_deep_agent2from langchain_quickjs import CodeInterpreterMiddleware34agent = create_deep_agent(5 model="openai:gpt-5.5",6 middleware=[CodeInterpreterMiddleware()],7)
Deep Agents एक सामान्य-उद्देश्य वाले उप-एजेंट के साथ आता है, इसलिए पहले से ही एक सामान्य उप-एजेंट प्रोफ़ाइल है जिसका उपयोग वर्कफ़्लो में किया जा सकता है। विशिष्ट वर्कफ़्लो के लिए, अपने स्वयं के नाम, विवरण और सिस्टम प्रॉम्प्ट के साथ कस्टम उप-एजेंट कॉन्फ़िगर करें: नाम और विवरण यह बताते हैं कि एजेंट को किस भूमिका का उपयोग करना है।
गतिशील उप-एजेंट को ट्रिगर करने के लिए, अपने एजेंट को "workflow" शब्द के साथ प्रॉम्प्ट करें, जैसे:
1result = await agent.ainvoke({2 "messages": [{"role": "user", "content": "Run a workflow that reviews every file in src/routes/ and summarizes the top risks."}]3})
कोडिंग एजेंट के साथ उपयोग करें
गतिशील उप-एजेंट आज़माने का सबसे तेज़ तरीका dcode के साथ है, जो हमारा टर्मिनल कोडिंग एजेंट है जो Deep Agent का उपयोग करके बनाया गया है। यह कोड इंटरप्रेटर सक्षम के साथ आता है, इसलिए कनेक्ट करने के लिए कुछ भी नहीं है — गतिशील उप-एजेंट बॉक्स से बाहर काम करता है।
इंस्टॉल करें
1curl -LsSf https://langch.in/dcode | bash
चलाएँ
1dcode
गतिशील उप-एजेंट को ट्रिगर करने के लिए, बस "workflow" के लिए पूछें। अपने आप काम करने की कोशिश करने या अपने मूल टास्क टूल के साथ उप-एजेंट फैन आउट को प्रबंधित करने के बजाय, एजेंट एक ऑर्केस्ट्रेशन स्क्रिप्ट लिखता है जो बिल्ट-इन task() ग्लोबल को कॉल करती है और इसे कोड इंटरप्रेटर में निष्पादित करती है। उदाहरण के लिए: "SQL injection के लिए src/ में हर फ़ाइल की समीक्षा करने के लिए एक workflow चलाएँ।"
जैसे ही उप-एजेंट स्पॉन होते हैं, dcode उन्हें डिस्पैच द्वारा चरणों में समूहित गतिशील उप-एजेंट पैनल में लाइव दिखाता है।
आप इसे dcode के साथ सबसे तेज़ आज़मा सकते हैं, लेकिन आप इसे ACP (जैसे Zed) के माध्यम से अपनी पसंद के टूल में भी उपयोग कर सकते हैं।
यह कैसे काम करता है
एजेंट को एक eval टूल दिया जाता है। यह JavaScript लिखता है जो इंटरप्रेटर के अंदर सुरक्षित रूप से निष्पादित होता है। जब उप-एजेंट कॉन्फ़िगर किए जाते हैं, तो इंटरप्रेटर एक बिल्ट-इन task() ग्लोबल प्रदर्शित करता है जो उन्हें कोड से डिस्पैच करता है। हाथ में कार्य के आधार पर, मॉडल अलग-अलग कोड लिखता है — एक लूप, एक ब्रांच, एक Promise.all — और इंटरप्रेटर इसे नियतात्मक रूप से चलाता है।
task() एक विवरण, एक subagentType, और एक वैकल्पिक responseSchema लेता है — जब प्रदान किया जाता है, तो परिणाम पहले से ही एक टाइप की गई वस्तु होती है, जो फ़िल्टर करने या अगले चरण में पास करने के लिए तैयार होती है।
1const result = await task({2 description: "Review src/auth/login.ts for security issues.",3 subagentType: "reviewer",4 responseSchema: {5 type: "object",6 properties: {7 severity: { type: "string", enum: ["high", "medium", "low"] },8 issues: { type: "array", items: { type: "string" } },9 },10 },11});1213const critical = result.severity === "high" ? result.issues : [];14critical; // model sees the last line
अधिक जानकारी के लिए, दस्तावेज़ में प्रोग्रामेटिक उप-एजेंट और इंटरप्रेटर देखें।
सामान्य ऑर्केस्ट्रेशन पैटर्न
Anthropic के डायनामिक वर्कफ़्लो ने समानांतर एजेंट कार्य के लिए ऑर्केस्ट्रेशन पैटर्न के एक सेट को लोकप्रिय बनाया। वे सुविधाएँ नहीं हैं जिन्हें आप चालू करते हैं। वे ऐसे आकार हैं जो स्वाभाविक रूप से काम से बाहर आते हैं, और कार्य बदलने पर एजेंट एक अलग आकार में स्थिर हो जाता है। नीचे दी गई तालिका प्रत्येक आकार को उस प्रकार के कार्य से मैप करती है जिसमें वह फिट बैठता है।
नीचे हम विस्तार से बताएंगे कि Deep Agents में प्रत्येक कैसे काम करता है, लाइव ट्रेस के साथ। हमने इन छह पैटर्न की व्याख्या करने वाला एक वीडियो भी तैयार किया है, जिसे आप यहाँ देख सकते हैं।
वर्गीकृत करें और कार्य करें
आइटम को पहले वर्गीकृत किया जाता है, फिर प्रत्येक आइटम को उसके वर्गीकरण के आधार पर एक विशेष उप-एजेंट द्वारा नियंत्रित किया जाता है। यह आपको मिश्रित इनपुट को संसाधित करने देता है जहाँ विभिन्न आइटम को विभिन्न विशेषज्ञता की आवश्यकता होती है।
उपयोग के मामले: सपोर्ट टिकट, एरर लॉग, उपयोगकर्ता प्रतिक्रिया, या आइटम के किसी भी बैच को ट्राइएज करना जिन्हें उनके प्रकार के आधार पर अलग-अलग हैंडलिंग की आवश्यकता होती है।
उदाहरण: सपोर्ट-टिकट बैकलॉग को ट्राइएज करना। एजेंट टिकट पढ़ता है और प्रत्येक को बग, फीचर अनुरोध, या प्रश्न के रूप में वर्गीकृत करता है। बग को बग-इन्वेस्टिगेटर के पास, फीचर अनुरोध को फीचर-एनालिस्ट के पास, और प्रश्नों को सपोर्ट-रेस्पॉन्डर के पास भेजा जाता है। परिणाम श्रेणी के अनुसार समूहित एक सारांश होता है।
ट्रेस यहाँ देखें।
फैनआउट और संश्लेषण
एजेंट एक ही प्रकार के काम को कई आइटमों में समानांतर रूप से डिस्पैच करता है, फिर परिणामों को जोड़ता है।
उपयोग के मामले: एक निर्देशिका में कोड समीक्षा, दस्तावेज़ों के बैच का विश्लेषण, लॉग फ़ाइलों को संसाधित करना, कई सेवाओं में एक ही जाँच चलाना।
उदाहरण: एक स्रोत ट्री में प्रति-फ़ाइल सुरक्षा समीक्षा। एजेंट src/ के अंतर्गत हर TypeScript फ़ाइल की खोज करता है और प्रति फ़ाइल समानांतर में एक सुरक्षा-समीक्षक डिस्पैच करता है। फिर यह सभी परिणामों को गंभीरता रेटिंग और उन पंक्तियों के साथ एक एकल प्राथमिकता वाली रिपोर्ट में मर्ज करता है जिन्हें बदलने की आवश्यकता है।
ट्रेस यहाँ देखें।
प्रतिकूल सत्यापन
एक दो-पास पैटर्न। पहला पास निष्कर्ष उत्पन्न करता है। दूसरा पास प्रत्येक निष्कर्ष को स्वतंत्र सत्यापनकर्ताओं के पास भेजता है, और केवल वे निष्कर्ष जो सहमति से बचे रहते हैं, रखे जाते हैं। यह झूठी सकारात्मकता को कम करता है जब विश्वास गति से अधिक मायने रखता है।
उपयोग के मामले: सुरक्षा ऑडिट जहाँ झूठी सकारात्मकता महंगी होती है, अनुपालन जाँच, कोई भी समीक्षा जहाँ आपको निष्कर्षों में उच्च विश्वास की आवश्यकता होती है।
उदाहरण: एक सुरक्षा ऑडिट जहाँ झूठी सकारात्मकता अस्वीकार्य है। एक ऑडिटर संभावित कमजोरियों के लिए एक विस्तृत जाल बिछाता है, फिर प्रत्येक निष्कर्ष को एक स्वतंत्र सत्यापनकर्ता को सौंप दिया जाता है जो कोड को नए सिरे से पढ़ता है और CONFIRMED या REFUTED का फैसला लौटाता है। केवल पुष्टि किए गए निष्कर्ष ही अंतिम रिपोर्ट में जीवित रहते हैं।
ट्रेस यहाँ देखें।
उत्पन्न करें और फ़िल्टर करें
कई उप-एजेंट एक ही समस्या के स्वतंत्र समाधान उत्पन्न करते हैं। एजेंट कोड में परिणामों की तुलना, स्कोर और फ़िल्टर करता है, केवल सर्वश्रेष्ठ को रखता है।
उपयोग के मामले: आर्किटेक्चर प्रस्ताव, रिफैक्टरिंग रणनीतियाँ, सामग्री विविधताएँ, कोई भी कार्य जहाँ प्रतिबद्ध होने से पहले कई विकल्पों की खोज करना बेहतर परिणाम उत्पन्न करता है।
उदाहरण: प्रतिस्पर्धी रेट-लिमिटर रिडिज़ाइन, रैंक किए गए। एजेंट के पास एक आर्किटेक्ट है जो rate-limiter.ts के कई स्वतंत्र रिडिज़ाइन तैयार करता है, प्रत्येक को अपनी फ़ाइल में लिखा जाता है ताकि वे एक-दूसरे को ओवरराइट न करें। फिर यह बर्स्ट के तहत शुद्धता, मल्टी-इंस्टेंस सपोर्ट और जटिलता पर उन्हें स्कोर करता है। सबसे मजबूत जीतता है, इस कारण के साथ कि क्यों।
ट्रेस यहाँ देखें।
टूर्नामेंट
विविधताओं की तुलना एक जज उप-एजेंट द्वारा आमने-सामने की जाती है, जिसमें विजेता एलिमिनेशन राउंड के माध्यम से आगे बढ़ते हैं।
उपयोग के मामले: व्यक्तिपरक मानदंडों के तहत अनुकूलन, शैली चयन, प्रतिस्पर्धी कार्यान्वयनों के बीच चयन करना।
उदाहरण: एक गड़बड़ createOrder हैंडलर के रीराइट पर पेयरवाइज ब्रैकेट। कई लेखक अलग-अलग प्राथमिकताओं के साथ प्रत्येक एक उम्मीदवार रीराइट तैयार करते हैं, फिर एक जज उनकी आमने-सामने तुलना करता है, विजेताओं को राउंड-दर-राउंड आगे बढ़ाता है जब तक कि एक चैंपियन सामने न आ जाए। यह जज के तर्क के साथ वापस आता है।
ट्रेस यहाँ देखें।
समाप्त होने तक लूप करें
एजेंट एक डिस्कवरी लूप चलाता है, जो पहले से मिल चुकी चीज़ों के मुकाबले डीडुप्लिकेट करता है, जब तक कि कोई नया परिणाम न आए। तब उपयोगी होता है जब काम का दायरा पहले से ज्ञात न हो।
उपयोग के मामले: व्यापक खोज, मृत कोड का पता लगाना, निर्भरता ऑडिट, कोई भी स्वीप जहाँ आप एक निश्चित संख्या के परिणामों के बजाय पूर्णता चाहते हैं।
उदाहरण: एक पास-आधारित सुरक्षा स्वीप। एजेंट एक स्कैन पास चलाता है, कोड में जो मिला उसका निरीक्षण करता है, और केवल तभी दूसरा पास शुरू करता है जब पिछले पास ने नए मुद्दों को सामने लाया हो। यह तब रुकता है जब एक पास में कुछ भी नया नहीं मिलता। यह समेकित निष्कर्षों की रिपोर्ट करता है और बताता है कि इसमें कितने पास लगे।
ट्रेस यहाँ देखें।
निष्कर्ष
गतिशील उप-एजेंट वह तरीका है जिससे आप एजेंटों को अधिक स्वायत्तता और बढ़ी हुई विश्वसनीयता देते हैं। कोड कवरेज और मध्यवर्ती संदर्भ को संभालता है, और मॉडल अभी भी निर्णय-भारी काम करता है। ऊपर दिए गए पैटर्न एक प्रारंभिक बिंदु हैं। व्यवहार में, एजेंट उन्हें कार्य की मांग के आधार पर रचना और मिश्रित करते हैं।
यह Recursive Language Model विचार का सबसे सरल रूप है। एक एजेंट जो कोड लिखता है, और वह कोड अधिक एजेंटों को डिस्पैच करता है। यह एक एजेंट है जो खुद को पुनरावर्ती रूप से कॉल कर रहा है और यह कॉन्टेक्स्ट विंडो द्वारा सीमित नहीं है या एक निश्चित वर्कफ़्लो में बंद नहीं है। एक एजेंट समस्या को जितना आवश्यक हो उतना तोड़ सकता है और टुकड़ों को जो भी आकार फिट बैठता है, पुन: इकट्ठा कर सकता है। ऊपर हाइलाइट किए गए ऑर्केस्ट्रेशन पैटर्न जो संभव है उसकी शुरुआती झलकियाँ हैं, लेकिन जैसे-जैसे मॉडल कोड लिखने में बेहतर होते जाएंगे, सीमा लगातार बढ़ती रहेगी।
गतिशील उप-एजेंट वह तरीका है जिससे Deep Agents इसे आज आपके हाथों में देता है। अपने एजेंट में एक कोड इंटरप्रेटर जोड़कर शुरू करें, या dcode का उपयोग करें जहाँ गतिशील उप-एजेंट बॉक्स से बाहर काम करता है।
आभार
@colifran_ और @huntlovell द्वारा सह-लेखक। @hwchase17, @masondrxy, और @chester_curme को विचारशील समीक्षा के लिए धन्यवाद।
