सेल्फ-इम्प्रूविंग लूप: Kimi K2.6 पर 300-एजेंट का झुंड, जिसे Opus 4.8 द्वारा सत्यापित किया गया है

एक मुफ्त ओपन-सोर्स मॉडल 300 समानांतर एजेंट चला रहा है, 4,000 समन्वित चरणों में, एक ही प्रॉम्प्ट से, और यह वास्तविक शोध कार्यों पर उन मॉडलों से बेहतर स्कोर करता है जिनके लिए आप 5 गुना अधिक भुगतान करते हैं।

ज्यादातर लोगों ने इसे कभी खोला ही नहीं।

वे Kimi खोलते हैं, एक सवाल टाइप करते हैं, जवाब पाते हैं, टैब बंद कर देते हैं। यह चैटबॉक्स है। यह काम करता है। लेकिन यह उत्पाद की लगभग 10% क्षमता है।

यह वह हिस्सा है जिसे ज्यादातर लोग छोड़ देते हैं:

स्वॉर्म (झुंड) सिर्फ तेज़ नहीं दौड़ता। इसे सही तरीके से चलाएँ और यह हर बार कुछ पीछे छोड़ जाता है - एक पुन: प्रयोज्य कौशल, एक तेज स्पेसिफिकेशन, एक बाधा जो अगली रन को आज की गलती दोहराने से रोकती है।

जिस स्वॉर्म ने कल आपका कार्य चलाया, वह आज उसे चलाने वाले स्वॉर्म से ज्यादा समझदार होना चाहिए।

https://x.com/Kimi_Moonshot/status/2047190578493096122

यही लूप है। Kimi काम और सीखना दोनों करता है। Opus 4.8 एक गेट पर बैठता है - वेरिफिकेशन गेट - और उसका एकमात्र काम यह है कि कचरा कौशल के रूप में सेव न हो। इंजन सीखता है। क्लोज़र इसे ईमानदार रखता है।

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

नतीजा आमतौर पर एक जैसा होता है: एक वर्कफ़्लो जो रन #50 पर बिल्कुल वही करता है जो रन #1 पर किया था।

यह वैसा नहीं है। यह एक स्वॉर्म का पूरा प्लेबुक है जो कंपाउंड करता है। 10 कदम। हर प्रॉम्प्ट कॉपी-पेस्ट है। हर संख्या सत्यापित है।

भाग 1 - लूप को एक बार बनाएँ। इसे हमेशा के लिए चलाएँ।

01. एक स्पेक लिखें, प्रॉम्प्ट नहीं

जब ज्यादातर लोग "300 एजेंट" सुनते हैं तो वे एक लाइन का प्रॉम्प्ट फायर करते हैं - "फिटनेस ऐप मार्केट पर शोध करें" - और शानदार परिणाम की उम्मीद करते हैं। यह क्रेडिट जलाने और कचरा पाने का सबसे तेज़ तरीका है।

एक लाइन का प्रॉम्प्ट स्वॉर्म को सब कुछ तय करने की अनुमति देता है, और वह गलत फैसला करेगा।

स्वॉर्म को जिन्न की तरह नहीं, बल्कि एक ठेकेदार की तरह समझें। एक स्पेक यह परिभाषित करता है कि क्या इकट्ठा करना है, क्या मान्य माना जाता है, कौन से स्रोत स्वीकार्य हैं, आउटपुट का सटीक प्रारूप, और विवाद की स्थिति में क्या करना है। यहाँ वह हिस्सा है जिसे ज्यादातर लोग छोड़ देते हैं: Kimi खुद डीकंपोज़िशन तय करता है।

आप एजेंटों को CrewAI की तरह नहीं बनाते, आप LangGraph की तरह ग्राफ नहीं जोड़ते, आप AutoGen की तरह संरचना परिभाषित नहीं करते। आप लक्ष्य का वर्णन करते हैं - स्वॉर्म अपना संगठन चार्ट खुद बनाता है।

स्पेक पूरे लूप में सबसे अधिक लीवरेज वाला आर्टिफैक्ट है, क्योंकि चरण 4 में यह आपके पुन: प्रयोज्य कौशल का बीज बन जाता है।

1# PROJECT: [name]
2GOAL: [one sentence — the deliverable, not the topic]
3SCOPE: [what's in, what's explicitly out]
4RULES: [validation — what counts as a verified row/finding]
5SOURCES: [official posts, papers, primary only — no aggregators]
6OUTPUT: [file type / count / naming / format details]
7ON CONFLICT: flag the row, never resolve silently
8STOP CONDITION: [when to halt and report instead of guessing]

02. एक पैसा खर्च करने से पहले डीकंपोज़िशन प्लान पढ़ें

यह वह कदम है जिसे पहली बार उपयोगकर्ता छोड़ते हैं, और इसे छोड़ना सबसे महंगा है।

स्पेक सबमिट करने के बाद, Kimi आपको चलाने से पहले एक्ज़ीक्यूशन प्लान दिखाता है - कितने उप-एजेंट, प्रत्येक क्या संभालता है, निर्भरता क्रम, स्टेप बजट।

इसे पढ़ें। गलत तरीके से डीकंपोज़ किया गया 200 एजेंटों का स्वॉर्म वास्तविक पैसा और घंटे खर्च करता है। प्लान की जाँच करने में कुछ नहीं लगता। आप तीन चीज़ें देख रहे हैं: क्या यह दायरे को समझता है, क्या एजेंटों की संख्या कार्य के आकार के लिए उचित है, और क्या आउटपुट प्लान आपकी वास्तविक ज़रूरत से मेल खाता है।

एक विवरण जानने लायक: 4,000 स्टेप पूरे स्वॉर्म का कुल समन्वित बजट है, प्रति एजेंट 4,000 स्टेप नहीं। 300 एजेंटों की रन में औसतन ~13 स्टेप प्रति एजेंट होते हैं - छोटे, विशेष उप-कार्य। यह आपको बताता है कि आपका कार्य इस आकार में फिट बैठता है या नहीं।

1Show me the proposed decomposition before running:
2- how many sub-agents, and what each one handles
3- the dependency order (what blocks what)
4- estimated step budget
5- where the biggest quality-drop risk sits
6Do NOT execute yet. Wait for my confirmation.

एक लाइन का प्रॉम्प्ट एक इच्छा है। एक स्पेक एक आदेश है। स्वॉर्म आदेशों का पालन करता है।

03. इसे बेकार होने दें - यही बात है

अब इसे चलाएँ। 300 तक उप-एजेंट समानांतर तरंगों में फायर होते हैं। पहली तरंग पूरी तरह से स्वतंत्र उप-कार्यों को संभालती है।

जैसे ही परिणाम आते हैं, ऑर्केस्ट्रेटर अगली तरंग उन कार्यों पर लॉन्च करता है जो पिछले परिणामों पर निर्भर थे, जब तक निर्भरता ग्राफ हल नहीं हो जाता।

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

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

क्योंकि Kimi $0.95/M इनपुट और $4.00/M आउटपुट पर चलता है - कैश हिट पर $0.16 - आप पहले प्रयास को फेंकने और फिर से चलाने का खर्च उठा सकते हैं। सस्ती वॉल्यूम बदल देती है कि आप क्या प्रयास करने को तैयार हैं।

1Execute the spec end to end.
2Parallelize wherever the plan allows.
3Report progress every 30 steps.
4Flag any blocker immediately — do not work around it silently.
5If a sub-agent stalls >10 min, reassign or report.
6Merge everything into the OUTPUT defined in the spec.

04. वास्तविक फ़ाइलों की मांग करें, चैट उत्तर की नहीं

स्वॉर्म का आउटपुट विंडो में टेक्स्ट नहीं है। यह संरचित डिलिवरेबल्स हैं जो सीधे आपके काम में जाते हैं - और यह वह हिस्सा है जो ज्यादातर लेख छोड़ देते हैं।

एक रन से PDF, स्प्रेडशीट, डेटासेट, स्लाइड डेक और काम करने वाला कोड मिलता है, सभी एक ही लॉन्च से, क्योंकि Kimi उन प्रारूपों को मूल रूप से उत्सर्जित करता है।

इसलिए स्पेक का नेतृत्व हमेशा आउटपुट से करें।

"एक व्यापक रिपोर्ट" एजेंटों को जल्दी रुकने की अनुमति देता है। "एक 40-पृष्ठ PDF + एक CSV जिसमें 20,000 पंक्तियाँ हों + 14 निर्यात-तैयार PNG चार्ट" उन्हें हिट करने का एक गुणवत्ता लक्ष्य देता है।

आउटपुट स्तर पर विशिष्टता ही अंतर है।

1OUTPUT: [file type] / [count] / [naming] / [format detail]
2
3# strong examples:
4OUTPUT: 1 .xlsx, one row per model, + 200-word brief
5OUTPUT: 30 HTML files, one per store, named by business
6OUTPUT: 40-page PDF + 20,000-row CSV + 14 PNG charts

05. ईमानदार मॉडल को आउटपुट पर इंगित करें और पूछें कि क्या गलत है

यहाँ एक बीट है जो Kimi नहीं है। स्वॉर्म की ज्ञात खामी: जब तक आप स्पष्ट रूप से सत्यापन की मांग नहीं करते, यह आत्मविश्वासपूर्ण, कम-उद्धृत दावे उत्पन्न करता है, और स्वतंत्र उप-एजेंट कभी-कभी एक-दूसरे का खंडन करते हैं। "दिखने में पूरा" और "सही है" अलग ग्रह हैं।

Opus 4.8 इसी गेट के लिए बनाया गया है। Anthropic रिपोर्ट करता है कि यह 4.7 की तुलना में लगभग 4 गुना कम संभावना है कि यह अपने कोड में एक दोष को अनदेखा कर दे, और यह पहला Claude है जो दोषपूर्ण परिणामों की आलोचनात्मक रिपोर्टिंग पर 0% स्कोर करता है।

यहाँ इसका एकमात्र काम खंडन करना है, प्रशंसा नहीं। आप प्रीमियम टोकन उत्पन्न करने के लिए नहीं दे रहे हैं - आप उन्हें मूक दोष को पकड़ने के लिए दे रहे हैं, इससे पहले कि चरण 4 इसे हमेशा के लिए एक कौशल में सेव कर ले।

सस्ती वॉल्यूम तभी एक सुपरपावर है जब कोई भरोसेमंद चीज़ काम की जाँच कर रही हो। वेरिफिकेशन गेट बनाए रखें।

06. पूरे वर्कफ़्लो को एक स्किल के रूप में सेव करें

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

पहली रन में 20 मिनट लगते हैं। उसके बाद हर रन में 30 सेकंड लगते हैं।

यह "स्व-सीखने" का ईमानदार संस्करण है। मॉडल आपके रनों के बीच अपने वज़न को फिर से प्रशिक्षित नहीं कर रहा है।

इसके चारों ओर का सिस्टम समझदार हो रहा है - आपकी स्किल लाइब्रेरी हर प्रोजेक्ट के साथ बढ़ती है, और हर भविष्य का स्वॉर्म उन कौशलों को स्वचालित रूप से लागू करता है।

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

1Save this entire workflow as a reusable Skill: "[name]"
2Capture:
3- input format (what files / spec shape it expects)
4- the agent steps that worked
5- the output format and naming convention
6- the validation rules from the spec
7Next time I run this, I attach new files and get the same shape.

07. अपने स्वयं के दस्तावेज़ों को स्वॉर्म ज्ञान के रूप में फ़ीड करें

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

यहाँ यह कंपाउंड होता है: आपके द्वारा फ़ीड किया गया हर PDF, ट्रांसक्रिप्ट या स्प्रेडशीट वह संदर्भ बन जाता है जिसके खिलाफ सभी 300 समानांतर एजेंट ग्राउंड कर सकते हैं, बजाय सामान्य प्रशिक्षण डेटा पर वापस जाने के।

जितना अधिक आप इसे फ़ीड करेंगे, हर बाद की रन उतनी ही सटीक होती जाएगी। रिपोर्टें सामान्य AI की तरह पढ़ना बंद कर देती हैं और आपके काम की तरह पढ़ी जाने लगती हैं।

1Capture this document as a reusable skill. Identify what makes it work:
2- structure and section order
3- tone and voice register
4- depth of analysis per section
5- the writing rhythm and formatting decisions
6Save it as "[name]". Then produce a new document on [different topic]
7using the captured skill — match the quality bar, not the content.

08. वेरिफिकेशन फीडबैक को एक स्थायी नियम में बदलें

चरण 5 एक बार एक दोष पकड़ता है। चरण 8 सुनिश्चित करता है कि स्वॉर्म इसे फिर कभी न करे। Opus की फिक्स लिस्ट लें और सिर्फ आउटपुट को पैच न करें - सबक को एक प्रोजेक्ट-स्तरीय कंस्ट्रेंट्स फ़ाइल में बेक करें जिसे Kimi हर सत्र की शुरुआत में स्वचालित रूप से पढ़ता है।

यह लूप अपनी विफलताओं से सीख रहा है। जिस बहाव को Opus ने रन #1 पर फ़्लैग किया था, वह रन #2 पर एक कठोर नियम बन जाता है।

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

1# CONSTRAINTS.md — loaded automatically
2- every claimed figure must trace to a primary source or be flagged
3- no silent conflict resolution — surface contradictions
4- [rule distilled from last run's Opus feedback]
5- [the mistake you never want repeated]
6Scope-lock: do not touch anything outside the spec's SCOPE block.

09. स्किल को नए इनपुट पर फिर से चलाएँ - लागत को गिरते हुए देखें

अब भुगतान। रन #2 शून्य से शुरू नहीं होता। यह स्किल, स्वॉर्म ज्ञान और कंस्ट्रेंट्स फ़ाइल से शुरू होता है जिसे आपने चरण 6-8 में बनाया था।

एक ही वर्कफ़्लो, नई फ़ाइलें, सेटअप का एक अंश।

यह वह जगह है जहाँ "कंपाउंडिंग" एक बज़वर्ड नहीं रह जाता और बिल पर दिखाई देता है। पहली प्रतिस्पर्धी निगरानी रन के लिए एक पूर्ण स्पेक और एक वेरिफिकेशन पास लगता है।

चौथी रन सेव की गई स्किल के खिलाफ 30 सेकंड का प्रॉम्प्ट है, और आउटपुट तेज है क्योंकि इसे इससे पहले के रनों के हर फिक्स को विरासत में मिलता है।

1Run the saved skill "[name]" on these new inputs.
2Apply CONSTRAINTS.md. Use the captured output format.
3[attach new files]
4Report only deviations from the skill's expected shape.

20 मिनट पहली रन पर। 30 सेकंड पचासवीं रन पर। यह अंतर ही एक लूप बनाने का पूरा कारण है, न कि एक प्रॉम्प्ट।

10. लूप को एक बैकग्राउंड एजेंट में प्रमोट करें

अंतिम कदम: एक बार जब लूप स्थिर और स्किल-समर्थित हो, तो आप इसे हाथ से लॉन्च करना बंद कर देते हैं।

Kimi को ट्रिगर पर इंगित करें - एक शेड्यूल, एक नई फ़ाइल ड्रॉप, एक प्रतियोगी का मूल्य निर्धारण पृष्ठ - और इसे पूरे लूप को सक्रिय रूप से चलाने दें, केवल डिलिवरेबल और विचलन को सतह पर लाएं।

प्रतिस्पर्धी निगरानी एक साफ उदाहरण है।

रन #1 आप हाथ से बनाते और सत्यापित करते हैं। जब तक यह एक बैकग्राउंड एजेंट बन जाता है, यह हर सप्ताह समानांतर में हर प्रतियोगी की जाँच कर रहा होता है और शून्य सीमांत समय लागत पर आपके इनबॉक्स में एक ब्रीफ ड्रॉप करता है।

लूप में बचा एकमात्र मानव वह प्रश्न है जो आपने सेट किया और उस उत्तर पर आपका निर्णय।

1Run skill "[name]" on a weekly schedule.
2Trigger: [schedule / new file / monitored URL]
3On each run: execute the swarm, apply CONSTRAINTS.md,
4verify, then deliver the OUTPUT + a diff vs last run.
5Only ping me if a deviation crosses [threshold].

निष्कर्ष:

जबकि बंद लैब्स एक समय में एक अधिक स्मार्ट चैटबॉट भेजती रहती हैं, एक ओपन मॉडल 300 एजेंटों को समानांतर में चला रहा है - और आपके द्वारा दी गई हर रन के साथ सिस्टम स्तर पर समझदार हो रहा है।

हमने यह सटीक फिंगरप्रिंट पहले भी एक बार देखा है। एक ओपन रिलीज़ उस चीज़ को फिर से परिभाषित करती है जो बंद फ्रंटियर के स्वामित्व में थी, और पूरा क्षेत्र रातों-रात पुन: कैलिब्रेट हो जाता है। यह DeepSeek के साथ हुआ।

एक ओपन-वेट मॉडल पर एक स्व-सीखने वाले स्वॉर्म का आकार एक जैसा है।

जो बिल्डर अभी भी बहस कर रहे हैं कि किस मॉडल ने "जीत" लिया, वे एक ऐसे प्रश्न का उत्तर दे रहे हैं जो अब मायने नहीं रखता।

अब प्रश्न यह नहीं है कि कौन सा मॉडल सबसे स्मार्ट है। यह है कि आप एक बार में कितने चला सकते हैं, कौन उनके काम की जाँच कर रहा है, और क्या आपका सेटअप आज कल से ज्यादा तेज है।

ज्यादातर लोग यह पढ़ेंगे और Kimi को एक चैटबॉक्स के रूप में उपयोग करते रहेंगे। कुछ लोग इस सप्ताह लूप का निर्माण करेंगे। पहली रन में 20 मिनट लगते हैं। उसके बाद हर रन वह लीवरेज है जो आपके पास है।

इसे बनाएँ। इसे सत्यापित करें। इसे डिस्टिल करें। फिर इसे हर बार चलाने पर सस्ता और तेज होते देखें।