AI एजेंट स्वार्म्स (AI Agent Swarms) कैसे बनाएं (पूर्ण गाइड)

यह AI Agent Swarms (AI एजेंट स्वार्म्स) का एक पूर्ण A–Z विवरण है कि वे क्या हैं और उनका उपयोग कैसे करें।

वे AI के साथ काम करने के आपके तरीके को क्यों पूरी तरह बदल देते हैं।

इसे सेव कर लें, इससे पहले कि आप भूल जाएं।

Kimi K2.6, Moonshot AI का अप्रैल 2026 का ओपन-वेट फ्लैगशिप मॉडल, इस विचार का अब तक का सबसे गंभीर ओपन-सोर्स कार्यान्वयन है जो मैंने देखा है।

असली कार्यों की चौड़ाई होती है। पचास कंपनियों पर शोध करना।

दो सौ फाइलों का विश्लेषण करना। एक दर्जन उप-कार्य जो एक-दूसरे पर निर्भर नहीं हैं और उन्हें एक-दूसरे के पीछे लाइन में इंतजार नहीं करना चाहिए। एजेंट स्वार्म उसके लिए आर्किटेक्चर है।

यह गाइड बताती है कि यह कैसे काम करता है, प्रशिक्षण बुनियादी ढांचे से लेकर API तक, फिर उस पैटर्न को कवर करती है जो मेरे विचार में अभी सबसे महत्वपूर्ण है: Kimi निष्पादन के लिए, Claude Opus 4.8 योजना और सत्यापन के लिए।

यहाँ अंतिम वर्कफ़्लो कैसा दिखता है:

सेक्शन 1: एजेंट स्वार्म क्या है?

एक एजेंट स्वार्म एक साथ कई एजेंट होते हैं जो विघटित उप-कार्यों पर काम करते हैं, एक ऑर्केस्ट्रेटर द्वारा समन्वित होते हैं जो परिणामों को एकत्रित करता है।

एक अनुक्रमिक श्रृंखला से अंतर ही पूरा मुद्दा है:

• अनुक्रमिक श्रृंखला: एजेंट A चलता है, B को सौंपता है, B C को सौंपता है। कुल समय = A + B + C।
• स्वार्म: ऑर्केस्ट्रेटर लक्ष्य को विभाजित करता है, एजेंट A, B, C एक ही समय पर स्वतंत्र उप-कार्यों पर चलते हैं, परिणाम मर्ज हो जाते हैं। कुल समय ≈ max(A, B, C)।

जब किसी कार्य में वास्तविक समानांतर संरचना होती है, तो यह मिनटों और घंटों के बीच का अंतर होता है।

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

छह बिल्डिंग ब्लॉक्स

हर स्वार्म में समान मुख्य घटक होते हैं:

इन छह को सही पाएं और आपके पास एक स्वार्म है। किसी एक को गलत पाएं और आपके पास एक महंगा डिबगिंग सत्र होगा।

सेक्शन 2: Kimi K2.6 वास्तव में क्या है

स्वार्म व्यवहार में जाने से पहले, यह समझना उचित है कि इसके नीचे क्या है। K2.6 Moonshot AI का 1-ट्रिलियन-पैरामीटर मिक्सचर-ऑफ-एक्सपर्ट्स मॉडल है, जिसे 20 अप्रैल 2026 को एक संशोधित MIT लाइसेंस के तहत ओपन-वेट जारी किया गया है। $20M मासिक राजस्व या 100M मासिक सक्रिय उपयोगकर्ताओं से नीचे वाणिज्यिक उपयोग मुफ्त है - इसलिए यह अधिकांश बिल्डरों के लिए व्यावहारिक रूप से मुफ्त है।

0:29

आर्किटेक्चर स्पेक्स

INT4 QAT वेरिएंट मूल रूप से 4x H100 80GB पर चलता है। FP16 को 8x H100 80GB की आवश्यकता है। सभी तीन समर्थित इन्फ्रेंस फ्रेमवर्क (vLLM, SGLang, KTransformers) OpenAI-संगत APIs को उजागर करते हैं।

सेक्शन 3: MuonClip ऑप्टिमाइज़र, या ट्रेनिंग स्थिर क्यों है

ट्रिलियन-पैरामीटर स्पार्स MoE को बिना विस्फोट के प्रशिक्षित करना कठिन है। विशिष्ट विफलता मोड: जैसे-जैसे अनुक्रम लंबाई बढ़ती है, अटेंशन लेयर्स में क्वेरी-की (QK) डॉट प्रोडक्ट अनबाउंड हो सकता है। आपको लॉस स्पाइक्स मिलते हैं, और इस पैमाने पर एक लॉस स्पाइक अपुनर्प्राप्ति योग्य हो सकता है।

Kimi K2 तकनीकी पेपर (arxiv: 2507.20534) इससे निपटने के लिए MuonClip प्रस्तुत करता है।

Muon एक ग्रेडिएंट ऑप्टिमाइज़र है जो AdamW की तुलना में अधिक टोकन-कुशल है। समान गुणवत्ता, कम प्रशिक्षण चरण। पकड़: Muon अकेला ट्रिलियन-पैरामीटर पैमाने पर अटेंशन अस्थिरता पैदा करता है।

QK-Clip सॉफ्टमैक्स से पहले QK मैट्रिसेस पर प्रति-टोकन, प्रति-हेड क्लिपिंग जोड़ता है। यह अटेंशन स्कोर परिमाण को बाउंड करता है और विस्फोट पैथोलॉजी को मारता है। कोई मैन्युअल ट्यूनिंग नहीं, कोई लर्निंग रेट हैक नहीं।

पेपर एब्सट्रैक्ट से:

"हम MuonClip प्रस्तुत करते हैं, एक नवीन ऑप्टिमाइज़र जो टोकन-कुशल Muon एल्गोरिदम को QK-Clip नामक स्थिरता-वर्धक तंत्र के साथ एकीकृत करता है... MuonClip का उपयोग करते हुए, Kimi K2 AdamW बेसलाइनों की तुलना में काफी कम प्रशिक्षण टोकन की आवश्यकता होने पर प्रतिस्पर्धी प्रदर्शन प्राप्त करता है।"

एक बिल्डर को प्रशिक्षण विवरण की परवाह क्यों करनी चाहिए? क्योंकि K2.6 जिस कारण से 12+ घंटों में 4,000 टूल कॉल्स को बिना गिरावट के बनाए रख सकता है, वह इसी पर वापस जाता है। अटेंशन अस्थिरता के साथ प्रशिक्षित एक मॉडल लंबे-संदर्भ, उच्च-चरण-गणना स्थितियों में भ्रमित होने की प्रवृत्ति रखता है। जो कि बिल्कुल वही शासन है जिसमें एजेंट स्वार्म रहता है।

सेक्शन 4: PARL, स्वार्म के पीछे का शोध

एजेंट स्वार्म K2.6 के ऊपर जोड़ा गया कोई फ्रेमवर्क नहीं है। यह व्यवहार मॉडल में प्रशिक्षित किया गया था, एक प्रतिमान के माध्यम से जिसे Moonshot PARL: पैरेलल-एजेंट रीइन्फोर्समेंट लर्निंग कहता है, जिसे Kimi K2.5 तकनीकी पेपर (arxiv: 2602.02276) में वर्णित किया गया है।

प्रशिक्षण योग्य ऑर्केस्ट्रेटर, जमे हुए उप-एजेंट

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

PARL इससे बचता है:

• ऑर्केस्ट्रेटर प्रशिक्षण योग्य है, परिणाम पुरस्कारों पर RL के माध्यम से अद्यतन किया जाता है
• उप-एजेंट जमे हुए हैं, निश्चित मध्यवर्ती नीति चेकपॉइंट

उप-एजेंट प्रक्षेपवक्र को विभेदनीय निर्णय बिंदुओं के रूप में नहीं, बल्कि पर्यावरणीय अवलोकनों के रूप में माना जाता है। यह एक साथ दो कठिन समस्याओं को अलग करता है। क्रेडिट केवल ऑर्केस्ट्रेटर की क्रियाओं को जाता है, कभी भी 300 एक साथ उप-एजेंटों को नहीं। और प्रशिक्षण स्थिर रहता है क्योंकि केवल एक मॉडल अपडेट किया जा रहा है।

ऑर्केस्ट्रेटर सीखता है कि कब समानांतर करना है, कितने उप-एजेंट बनाने हैं, और काम कैसे विभाजित करना है। किसी ने उन व्यवहारों को हाथ से निर्दिष्ट नहीं किया। वे पुरस्कार अधिकतमीकरण से उभरते हैं।

तीन-भाग पुरस्कार फ़ंक्शन

ऑर्केस्ट्रेटर तीन संकेतों के विरुद्ध प्रशिक्षित होता है।

एक समानांतरता पुरस्कार इसे चीजों को अनुक्रमिक रूप से चलाने के बजाय समवर्ती उप-एजेंट बनाने के लिए प्रेरित करता है। इसके बिना, मॉडल एक बार में एक एजेंट पर डिफ़ॉल्ट होता है: सुरक्षित, अनुमानित, धीमा।

एक समाप्ति पुरस्कार सुनिश्चित करता है कि उप-एजेंट वास्तव में अपने कार्यों को पूरा करते हैं। यह "स्प्यूरियस पैरेललिज्म" को रोकता है, जहां ऑर्केस्ट्रेटर समानांतरता पुरस्कार प्राप्त करने के लिए केवल कुछ न करने वाले एजेंटों की भीड़ बनाता है।

एक प्रदर्शन पुरस्कार कार्य उद्देश्य के विरुद्ध अंतिम आउटपुट गुणवत्ता को स्कोर करता है। यह मूल सत्य है जिसकी सेवा बाकी सब कुछ करता है।

जो विवरण मुझे सबसे दिलचस्प लगता है: अनुकूलन मीट्रिक क्रिटिकल स्टेप्स (क्रिटिकल पाथ लंबाई) है, कुल कदम नहीं। मॉडल को कच्ची समवर्तीता को अधिकतम करने के लिए नहीं, बल्कि सबसे लंबी निर्भरता श्रृंखला को छोटा करने के लिए पुरस्कृत किया जाता है। यही वह चीज़ है जो वास्तव में दीवार-घड़ी के समय को कम करती है।

PARL परिणाम

• BrowseComp: स्वार्म मोड ने K2.5 पर 78.4% हासिल किया, जो सिंगल-एजेंट K2.5 (60.6%) से 17.8-पॉइंट का पूर्ण लाभ है, जिसने उस समय GPT-5.2 Pro (77.9%) को हराया था। K2.6 इसे 86.3% तक धकेलता है।
• WideSearch: आइटम-F1 पर 6.3-पॉइंट का पूर्ण सुधार (72.7% से 79.0%)
• दीवार-घड़ी का समय: सिंगल-एजेंट बेसलाइन की तुलना में समानांतर कार्यों पर 3-4.5x कमी
• समानांतर टूल कॉल्स: K2.6 में 4,000 समन्वित कदमों तक

सेक्शन 5: Mooncake, Kimi के पीछे का बुनियादी ढांचा

Moonshot का सर्विंग इन्फ्रास्ट्रक्चर बताता है कि K2.6 बिना पिघले 300 समानांतर एजेंटों को क्यों बनाए रख सकता है। मॉडल वजन कहानी का केवल आधा हिस्सा हैं; उनकी सेवा करने वाला सिस्टम दूसरा आधा है।

लंबे-संदर्भ कार्यों के लिए बुनियादी ढांचा अच्छी तरह से संरचित है।

KVCache-केंद्रित विघटित आर्किटेक्चर

Moonshot का सर्विंग प्लेटफ़ॉर्म Mooncake कहलाता है, जिसका वर्णन उनके 2024 के बुनियादी ढांचे के पेपर (arxiv: 2407.00079) में किया गया है। यह Kimi को पैमाने पर चलाने वाला इंजन है, और इसकी डिज़ाइन पसंद असामान्य है।

पारंपरिक LLM इन्फ्रेंस प्रीफिल (इनपुट प्रॉम्प्ट प्रोसेसिंग) और डीकोड (टोकन जनरेशन) को एक ही GPU इंस्टेंस पर चलाता है। Mooncake उन्हें अलग-अलग क्लस्टर में विघटित करता है:

• प्रीफिल क्लस्टर: प्रारंभिक प्रॉम्प्ट प्रोसेसिंग को संभालता है, लंबे-संदर्भ इनपुट के लिए स्वतंत्र रूप से स्केल करता है
• डीकोड क्लस्टर: टोकन जनरेशन को संभालता है, थ्रूपुट और लेटेंसी के लिए अनुकूलित

KV कैश, मध्यवर्ती अटेंशन स्थिति जो ऑटोरेग्रेसिव जनरेशन को कुशल बनाती है, को प्रथम श्रेणी के सिस्टम संसाधन के रूप में प्रबंधित किया जाता है। Mooncake GPU VRAM, CPU DRAM, और SSDs में फैला एक वितरित KV कैश बनाता है, जिसमें नोड्स के बीच कैश स्थानांतरित करने के लिए एक कस्टम ट्रांसफर इंजन होता है।

एजेंट स्वार्म के लिए यह क्यों मायने रखता है

जब 300 उप-एजेंट एक साथ चलते हैं, तो प्रत्येक अपना स्वयं का KV कैश उत्पन्न करता है। एक पारंपरिक आर्किटेक्चर में यह बड़े पैमाने पर GPU मेमोरी दबाव और शेड्यूलिंग विरोध है। Mooncake के विघटित कैश के साथ:

• पूर्ण उप-एजेंटों से KV कैश को DRAM या SSD पर हटाया जा सकता है और यदि आवश्यक हो तो वापस बुलाया जा सकता है
• प्रीफिल क्लस्टर प्रत्येक उप-एजेंट के लिए (अक्सर बड़े) सिस्टम प्रॉम्प्ट को स्वतंत्र रूप से संभालता है
• शेड्यूलर प्रति-एजेंट लेटेंसी SLOs को धारण करते हुए समग्र थ्रूपुट को अधिकतम करता है

Mooncake पेपर से: "बेसलाइन विधि की तुलना में, Mooncake कुछ अनुकरण परिदृश्यों में SLOs का पालन करते हुए थ्रूपुट में 525% तक की वृद्धि प्राप्त कर सकता है। वास्तविक कार्यभार के तहत, Mooncake का अभिनव आर्किटेक्चर Kimi को 75% अधिक अनुरोधों को संभालने में सक्षम बनाता है।"

अद्यतन पेपर रिपोर्ट करता है कि Mooncake "हजारों नोड्स पर संचालित होता है, प्रतिदिन 100 बिलियन से अधिक टोकन प्रोसेस करता है", और पिछले सिस्टम की तुलना में A800 क्लस्टर पर 115% अधिक और H800 क्लस्टर पर 107% अधिक अनुरोधों को संभालता है।

पैमाने पर PD विघटन: 128-GPU K2 तैनाती

LMSYS ने SGLang राउटर के माध्यम से 128 H200 GPUs पर प्रीफिल-डीकोड (PD) विघटन का उपयोग करके Kimi K2 के लिए एक तैनाती केस स्टडी प्रकाशित की। आर्किटेक्चर:

• SGLang राउटर: लेबल चयनकर्ताओं के माध्यम से प्रीफिल और डीकोड नोड्स की गतिशील सेवा खोज के लिए हल्की सेवा
• एक्सपर्ट पैरेललिज्म: K2 के 384 एक्सपर्ट नोड्स में वितरित, नेटवर्क स्तर पर रूटिंग के साथ
• OME (ओपन मॉडल इंजन): सर्विंग लेयर के लिए Kubernetes-मूल ऑर्केस्ट्रेशन

यह उत्पादन पैमाने पर K2 परिवार को चलाने वाला स्टैक है। यदि आप K2.6 को स्वयं होस्ट कर रहे हैं, तो यह आपका टेम्पलेट है।

सेक्शन 6: एजेंट स्वार्म कदम दर कदम कैसे काम करता है

K2.6 द्वारा स्वार्म मोड में कार्य निष्पादित करने पर यांत्रिक अनुक्रम:

चरण 1: कार्य विघटन

ऑर्केस्ट्रेटर कार्य का विश्लेषण करता है और निर्भरता ग्राफ बनाता है: कौन से उप-कार्य स्वतंत्र हैं और समानांतर में चल सकते हैं, कौन से पिछले आउटपुट पर निर्भर हैं।

"100 YC कंपनियों पर शोध करें और एक सेक्टर विश्लेषण तैयार करें" के लिए, ऑर्केस्ट्रेटर 100 स्वतंत्र शोध कार्यों, फिर 1 एकत्रीकरण कार्य, फिर 1 संश्लेषण कार्य की पहचान करता है। पहली परत पूरी तरह से समानांतर है।

चरण 2: विशेषज्ञ एजेंट स्पॉनिंग

ऑर्केस्ट्रेटर उप-कार्य प्रकार के आधार पर डोमेन-विशिष्ट उप-एजेंट बनाता है। K2.6 भूमिका-विशिष्ट निर्देशों और लक्षित उपकरण पहुंच के साथ गतिशील रूप से एजेंटों को इंस्टेंट करता है:

• वेब शोध एजेंट: सर्च + ब्राउज़र टूल्स
• डेटा विश्लेषण एजेंट: पायथन निष्पादन + स्प्रेडशीट टूल्स
• लेखन एजेंट: संश्लेषण और दस्तावेज़ निर्माण
• तथ्य-जांच एजेंट: क्रॉस-रेफरेंसिंग और सत्यापन

प्रत्येक उप-एजेंट अपने स्वयं के बाउंडेड स्थानीय संदर्भ के भीतर काम करता है। यह एक स्कोप्ड कार्य संभालता है, संरचित आउटपुट उत्पन्न करता है, और बाहर निकल जाता है। स्थानीय संदर्भ वह सब कुछ नहीं रखता जो ऑर्केस्ट्रेटर जानता है, केवल वही रखता है जो उस उप-एजेंट को चाहिए। इस प्रकार K2.6 उन कार्यों पर ओवरफ्लो होने से बचता है जो मिनटों में किसी एक एजेंट की विंडो भर देंगे।

चरण 3: तरंगों में समानांतर निष्पादन

एजेंट तरंगों में निष्पादित होते हैं। पहली तरंग पूरी तरह से स्वतंत्र कार्यों को संभालती है।

1. जैसे ही परिणाम आते हैं, ऑर्केस्ट्रेटर दूसरी तरंग उन कार्यों पर शुरू करता है जो पहली तरंग के आउटपुट पर निर्भर थे, और इसी तरह जब तक निर्भरता ग्राफ हल नहीं हो जाता।
2. K2.6 प्रति सत्र 300 उप-एजेंट और 4,000 समन्वित कदमों का समर्थन करता है। ऑर्केस्ट्रेटर वास्तविक समय में निष्पादन की निगरानी करता है, विफल या रुके हुए एजेंटों का पता लगाता है, और स्वचालित रूप से उनके कार्यों को पुन: असाइन करता है।
3. वह दोष सहनशीलता ही है जो बिना मानवीय निगरानी के 12+ घंटे के स्वायत्त रन को संभव बनाती है।

चरण 4: एकत्रीकरण और आउटपुट

एक बार जब सभी उप-एजेंट पूरे हो जाते हैं, ऑर्केस्ट्रेटर परिणामों को अंतिम डिलिवरेबल: दस्तावेज़, स्प्रेडशीट, वेबसाइट, स्लाइड डेक में एकत्रित करता है।

• यह एजेंट आउटपुट को संयोजित करने के बजाय उन्हें संश्लेषित करता है, ताकि परिणाम संरचनात्मक रूप से एक साथ रहे।
• एक और बात ध्यान देने योग्य: स्वार्म संरचना कॉन्टेक्स्ट विंडो समस्या का Kimi का उत्तर भी है।
• K2.6 की स्पष्ट नीति: "एक बार कॉन्टेक्स्ट विंडो सीमा से अधिक हो जाने पर, केवल टूल-संबंधित संदेशों का सबसे हालिया दौर बरकरार रखा जाता है।" स्वार्म उस नीति को बहुत लंबे कार्य क्षितिज पर टिकाऊ बनाता है।

सेक्शन 7: Kimi x Claude Opus 4.8 आर्किटेक्चर

कोई एक मॉडल स्वार्म की हर परत के लिए सही उत्तर नहीं है। Kimi K2.6 क्षैतिज पैमाने के लिए बनाया गया है - सैकड़ों एजेंटों में समानांतर निष्पादन, लंबे स्वायत्त रन, लागत-कुशल बल्क प्रोसेसिंग।

Claude Opus 4.8 निर्णय के लिए बनाया गया है - योजना, सूक्ष्म तर्क, और अपनी गलतियों को पकड़ना। वे संरचनात्मक रूप से एक-दूसरे के पूरक हैं, और प्रत्येक जो अंतर छोड़ता है वह दूसरे की ताकत के आकार के करीब है।

पैटर्न:

1[यूज़र गोल]
2      |
3[Claude Opus 4.8 - प्लानर]
4  गोल को एक संरचित टास्क स्पेक में विघटित करता है
5  समानांतर बनाम अनुक्रमिक उप-कार्यों की पहचान करता है
6  प्रत्येक उप-कार्य के लिए सफलता मानदंड को परिभाषित करता है
7      |
8[Kimi K2.6 एजेंट स्वार्म - एक्ज़ीक्यूटर]
9  संरचित टास्क स्पेक प्राप्त करता है
10  300 तक विशिष्ट उप-एजेंट बनाता है
11  टूल कॉल्स में समानांतर चलता है
12  संरचित परिणाम लौटाता है
13      |
14[Claude Opus 4.8 - वेरिफ़ायर]
15  Kimi के आउटपुट की सफलता मानदंड के विरुद्ध समीक्षा करता है
16  विफलताओं, अंतरालों, असंगतियों को चिह्नित करता है
17  अंतिम डिलिवरेबल को संश्लेषित करता है

योजना और सत्यापन के लिए Claude क्यों?

Opus 4.8 में सबसे कम सराहा गया परिवर्तन ईमानदारी में सुधार है: "Opus 4.8 अपने पूर्ववर्ती की तुलना में लगभग चार गुना कम संभावना रखता है कि वह अपने द्वारा लिखे गए कोड में दोषों को बिना टिप्पणी के पार जाने दे।" एजेंटिक सिस्टम में, झूठा आत्मविश्वास विनाशकारी विफलता मोड है।

• एक ऑर्केस्ट्रेटर जो "पूर्ण" कहता है जबकि वह नहीं है, 300 डाउनस्ट्रीम एजेंटों में त्रुटियों को कैस्केड करेगा। Claude की अनिश्चितता को चिह्नित करने और कार्य के बीच में अपनी गलतियों को पकड़ने की प्रवृत्ति इसे उन परतों के लिए सही एंकर बनाती है जहां गलत होना महंगा है।
• Opus 4.8 1M टोकन कॉन्टेक्स्ट विंडो का भी समर्थन करता है, जो सत्यापन पास के लिए मायने रखता है जब आप 50+ समानांतर शोध एजेंटों के आउटपुट को एक समीक्षा संदर्भ में खींच रहे हैं।

निष्पादन के लिए Kimi क्यों?

K2.6 का एजेंट स्वार्म 300 समानांतर उप-एजेंट और प्रति सत्र 4,000 समन्वित टूल चरणों का समर्थन करता है - यह एक प्रशिक्षित व्यवहार है, एप्लिकेशन-लेयर रैपर नहीं।

• Claude Code में Claude का डायनामिक वर्कफ़्लो सुविधा है, लेकिन यह वर्तमान में रिसर्च प्रीव्यू में है और एंटरप्राइज़/मैक्स प्लान तक सीमित है।
• Kimi की स्वार्म क्षमता अभी सभी के लिए API के माध्यम से उपलब्ध है। पैमाने पर टोकन अर्थशास्त्र भी मायने रखता है: K2.6 प्रति मिलियन इनपुट/आउटपुट टोकन पर $0.95/$4.00 पर चलता है। बल्क समानांतर निष्पादन के लिए यह कुछ नहीं है।

सेक्शन 8: आपको स्वार्म की कब आवश्यकता है (और कब नहीं)

मल्टी-एजेंट डिज़ाइन में सबसे आम गलती: सिंगल-एजेंट सीलिंग से टकराने से पहले स्वार्म जटिलता जोड़ना।

सिंगल-एजेंट रहें जब:

• कार्य एक कॉन्टेक्स्ट विंडो के भीतर फिट बैठता है (वास्तविक काम के ~50K टोकन से कम)
• कार्य स्वभाव से अनुक्रमिक है, प्रत्येक चरण पिछले पर निर्भर है
• आप अभी भी प्रोटोटाइप कर रहे हैं - सिंगल-एजेंट विफलता मोड को डीबग करना कहीं अधिक आसान है
• कार्य वैसे भी 10 मिनट से कम समय में पूरा हो जाएगा

एजेंट स्वार्म का उपयोग करें जब:

• कार्य में n समानांतर, स्वतंत्र उप-कार्य हैं जहां n > 5
• कॉन्टेक्स्ट ओवरफ्लो एक वास्तविक समस्या है (गहन शोध, बड़े कोडबेस, बैच संचालन)
• आपको एक साथ काम करने वाले डोमेन-विशिष्ट एजेंटों की आवश्यकता है
• कार्य एक अनुक्रमिक सत्र में गुणवत्ता बनाए रखने के लिए बहुत लंबा है
• आप एक आलोचक या सत्यापनकर्ता एजेंट को दूसरे एजेंट के काम की जांच करते हुए देखना चाहते हैं

Kimi + Claude Opus 4.8 हाइब्रिड का उपयोग करें जब:

• योजना की गुणवत्ता मायने रखती है और आप एक ऐसा मॉडल चाहते हैं जो योजना गलत होने पर पीछे हट जाए
• आउटपुट आगे किसी मानवीय समीक्षा के बिना शिप होता है - इसलिए सत्यापन को शामिल करना होगा
• आप उच्च-मात्रा निष्पादन चला रहे हैं जहां टोकन लागत तेजी से बढ़ती है
• आप निर्णय परतों पर Claude का निर्णय और कार्य परतों पर Kimi का पैमाना चाहते हैं

सेक्शन 10: चार स्वार्म आर्किटेक्चर पैटर्न

पैटर्न 1: ऑर्केस्ट्रेटर-वर्कर (सबसे आम)

एक केंद्रीय ऑर्केस्ट्रेटर वर्कर्स को उप-कार्य सौंपता है, वर्कर्स समानांतर में निष्पादित होते हैं, परिणाम एकत्रित होते हैं।

1[यूज़र गोल]
2    |
3[ऑर्केस्ट्रेटर - Claude Opus 4.8]
4    +-- [वर्कर: Kimi रिसर्च एजेंट x N]
5    +-- [वर्कर: Kimi डेटा एजेंट x N]
6    +-- [वर्कर: Kimi कोड एजेंट x N]
7    |
8[संश्लेषक - Claude Opus 4.8]
9    |
10[अंतिम आउटपुट]

सबसे उपयुक्त: स्पष्ट रूप से अलग-अलग उप-कार्यों और चर संख्या में वर्कर्स वाले कार्य।

पैटर्न 2: क्रिटिक-रिफ़ाइनर लूप

एक एजेंट उत्पादन करता है, दूसरा आलोचना करता है, गुणवत्ता सीमा पूरी होने तक दोहराएं।

1[Kimi K2.6 बिल्डर] -> ड्राफ्ट -> [Claude Opus 4.8 क्रिटिक] -> फीडबैक -> [Kimi K2.6 बिल्डर]
2                                        |
3                                   (अनुमोदित)
4                                [अंतिम आउटपुट]

सबसे उपयुक्त: कोड जनरेशन, तकनीकी लेखन, अनुपालन-संवेदनशील आउटपुट। हमेशा अधिकतम-पुनरावृत्ति सीमा निर्धारित करें।

पैटर्न 3: पदानुक्रमिक

एक रणनीतिक ऑर्केस्ट्रेटर डोमेन ऑर्केस्ट्रेटर का प्रबंधन करता है, जो वर्कर्स का प्रबंधन करते हैं।

1[Claude Opus 4.8 - रणनीतिक ऑर्केस्ट्रेटर]
2    +-- [Kimi K2.6 स्वार्म - शोध टीम (50 एजेंट)]
3    +-- [Kimi K2.6 स्वार्म - बिल्ड टीम (50 एजेंट)]

सबसे उपयुक्त: विशिष्ट डोमेन वाले बड़े एंटरप्राइज़ वर्कफ़्लो।

पैटर्न 4: क्लॉ ग्रुप्स (Kimi-मूल विषम स्वार्म)

K2.6 किसी भी मॉडल को चलाने वाले एजेंटों का समन्वय करता है, जिसमें स्थानीय मॉडल, Claude, और GPT शामिल हैं, साथ ही एक साझा संचालन स्थान में मानव कार्यकर्ता भी शामिल हैं। वर्तमान में रिसर्च प्रीव्यू में।

1[Kimi K2.6 कोऑर्डिनेटर]
2    +-- [Claude Opus 4.8 - रीज़निंग विशेषज्ञ]
3    +-- [Llama 3.3 स्थानीय - लागत-संवेदनशील बल्क कार्य]
4    +-- [Kimi K2.6 एजेंट x N - निष्पादन परत]
5    +-- [मानव समीक्षक - अनुमोदन चेकपॉइंट]

सबसे उपयुक्त: वर्कफ़्लो जिन्हें मॉडल विविधता, स्थानीय + क्लाउड हाइब्रिड, या ह्यूमन-इन-द-लूप आवश्यकताओं की आवश्यकता है।

सेक्शन 12: स्वार्म कार्यों के लिए प्रॉम्प्ट डिज़ाइन

विघटन प्रॉम्प्ट (ऑर्केस्ट्रेटर)

1आप एक कार्य वास्तुकार हैं। इस लक्ष्य को स्वतंत्र, समानांतर योग्य उप-कार्यों में विघटित करें।
2
3नियम:
4- प्रत्येक उप-कार्य एक विशिष्ट एजेंट द्वारा अलगाव में पूरा करने योग्य होना चाहिए
5- निर्भरता वाले उप-कार्यों को उनकी निर्भरता श्रृंखला के साथ चिह्नित किया जाना चाहिए
6- JSON के रूप में आउटपुट: {task_id, description, agent_type, depends_on, success_criteria}
7
8लक्ष्य: {user_goal}
9उपलब्ध एजेंट प्रकार: researcher, analyst, coder, writer, verifier

विशेषज्ञ सिस्टम प्रॉम्प्ट (उप-एजेंट)

1आप {DOMAIN} में विशेषज्ञता वाले {ROLE} एजेंट हैं।
2
3कार्य: {subtask_description}
4
5बाधाएं:
6- केवल मान्य JSON लौटाएं जो {output_schema} से मेल खाता हो
7- अपने कार्य क्षेत्र से आगे न जाएं
8- यदि आप कार्य पूरा नहीं कर सकते: {"error": "reason", "partial_results": [...]}
9- अधिकतम टूल कॉल: {max_tool_calls}
10
11संदर्भ: {context_from_orchestrator}

एकत्रीकरण प्रॉम्प्ट (संश्लेषक)

1{n} विशिष्ट एजेंटों से शोध को एक सुसंगत आउटपुट में संश्लेषित करें।
2
31. सभी प्रदान किए गए एजेंट आउटपुट पढ़ें
42. पहचानें कि वे कहां सहमत हैं, असहमत हैं, या अंतराल हैं
53. सभी निष्कर्षों को एकीकृत करते हुए एक {output_type} तैयार करें
64. स्पष्ट रूप से असंगतियों को उजागर करें - विरोधाभासों को चुपचाप हल न करें
7
8एजेंट आउटपुट: {agent_outputs_as_json}
9आउटपुट प्रारूप: {final_output_spec}

सेक्शन 13: सात गैर-परक्राम्य गार्डरेल्स

1. प्रति एजेंट अधिकतम पुनरावृत्ति। ऑर्केस्ट्रेटर को सूचित करने से पहले लूप पर हार्ड सीमा।

2. सत्र टाइमआउट। यदि स्वार्म N मिनट में पूरा नहीं हुआ है, तो समाप्त करें और आंशिक परिणाम लौटाएं।

3. संरचित आउटपुट प्रवर्तन। एजेंटों को JSON लौटाने के लिए बाध्य करें। मध्यवर्ती एजेंटों से गद्य डाउनस्ट्रीम पार्सिंग विफलताएं पैदा करता है।

4. विफलता अलगाव। एक विफल उप-एजेंट को ऑर्केस्ट्रेटर को क्रैश नहीं करना चाहिए।

1async def run_subagent_safely(kimi_client, task, agent_id):
2    try:
3        result = kimi_client.chat.completions.create(
4            model="kimi-k2.6",
5            messages=[{"role": "user", "content": task}],
6            max_tokens=4096
7        )
8        return {"agent_id": agent_id, "status": "success",
9                "output": result.choices[0].message.content}
10    except Exception as e:
11        return {"agent_id": agent_id, "status": "failed", "error": str(e)}

5. एक्सपोनेंशियल बैकऑफ़ के साथ पुनः प्रयास करें। 429s और क्षणिक त्रुटियों को स्थायी विफलताओं के रूप में प्रदर्शित किए बिना संभालें।

6. ह्यूमन-इन-द-लूप चेकपॉइंट। लिखने की पहुंच वाले स्वार्म (कोड तैनात करना, ईमेल भेजना, API म्यूटेशन करना) के लिए अनिवार्य अनुमोदन विराम डालें।

7. लागत निगरानी। प्रति-रन टोकन बजट निर्धारित करें। भगोड़ा लूप हर बार गुणवत्ता विफलताओं के रूप में दिखाने से पहले लागत विसंगतियों के रूप में दिखाई देते हैं।

पहले क्या बनाएं

सेक्शन 9 से तीन-एजेंट पाइपलाइन से शुरू करें। यह एक दोपहर में डीबग करने के लिए काफी छोटा है, यह योजना, समानांतर निष्पादन और सत्यापन का अभ्यास कराता है, और आप इसे एक घंटे से भी कम सेटअप में एक वास्तविक कार्य के विरुद्ध चला सकते हैं।

जब यह टूटता है - और यह टूटेगा - विफलता मोड आपको पढ़ने के एक और घंटे की तुलना में स्वार्म डिज़ाइन के बारे में अधिक सिखाएगा।

इसे बनाएं। इसे जानबूझकर तोड़ें। फिर एक ठोस संदर्भ बिंदु के साथ सेक्शन 11 के पैटर्न पर वापस आएं।

आर्किटेक्चर कठिन हिस्सा नहीं है। कठिन हिस्सा "परीक्षण में काम करता है" और "रात के 3 बजे बिना किसी निगरानी के काम करता है" के बीच का अंतर है, और वह अंतर पूरी तरह से गार्डरेल्स, ऑब्ज़र्वेबिलिटी और मेमोरी डिज़ाइन में है।

निष्कर्ष

Kimi 2.6 एक एजेंट क्रांति है कि कैसे रीइन्फोर्समेंट लर्निंग एजेंट स्वार्म स्थापित कर सकता है।

यह यह भी दिखाता है कि कैसे लंबे संदर्भ क्षितिज ऐसे ऑर्केस्ट्रेटर-आधारित बुनियादी ढांचे का उपयोग कर सकते हैं, जो एक ही मॉडल का उपयोग करके जटिल सिस्टम बनाने के लिए कई उप-एजेंट बनाने की अनुमति देता है।

अस्वीकरण

लेख लेखक के नोट्स में Kimi 2.6 तकनीकी दस्तावेज़ीकरण और शोध पत्रों का उपयोग करके लिखा गया है, और एक AI, Opus 4.7 द्वारा संपादित किया गया है।