विषय-सूची

पिछली बार multi-agent system क्या है? में "कई AI को मिलाकर चलाने" की अवधारणा समझ लेने के बाद, अगला सवाल है कि असल में इसे कैसे बनाया जाए। यह लेख 2026 के वास्तविक मानक यानी supervisor pattern को आधार बनाकर, शुरुआती लोगों के लिए 5-चरण की व्यावहारिक प्रक्रिया समझाता है।

किसी framework की बात शुरू करने से पहले, सबसे ज़रूरी सिद्धांत यह है: "पहले एक ही agent से बनाएँ, और किसी सीमा से टकराने पर ही — न्यूनतम स्तर पर — और जोड़ें।" शुरू से ही multi बनाना अमूमन over-engineering होता है। कोड यहाँ किसी खास framework पर निर्भर न रहने वाले छद्म-कोड के रूप में दिखाया गया है, इसलिए चाहे आप MCP इस्तेमाल करें या कोई भी SDK, यह सब पर लागू होता है।

MULTI-AGENT कैसे बनाएँ · 5 चरण

छोटा बनाएँ, मापें, फिर बढ़ाएँ

— supervisor pattern, न्यूनतम setup से

1कार्य को विभाजित करें
2workers परिभाषित करें (3-5 तक)
3supervisor को डिज़ाइन करें
4handoff और context साझा करना तय करें
5मापें और सीमाओं के साथ चलाएँ

* इस लेख के चरण और आँकड़े सार्वजनिक सामग्री, व्यावहारिक गाइड और शोध रिपोर्टों से उद्धृत हैं (जून 2026 तक)। कोड अवधारणा दर्शाने वाला छद्म-कोड है; असली API के लिए हर framework के आधिकारिक दस्तावेज़ देखें।

1. बनाने से पहले: क्या आपको सचमुच multi की ज़रूरत है?

पहला पड़ाव तकनीकी नहीं — यह एक निर्णय है। Multi-agent शक्तिशाली है, लेकिन लगभग 80% उपयोग एक ही agent से चल जाते हैं। अगर नीचे दी गई कोई भी बात लागू नहीं होती, तो पहले एकल agent से ही बनाएँ।

multi अपनाने के 3 संकेत

  • विशेषज्ञता का विभाजन: ज्ञान एक ही prompt में नहीं समाता (शोध, कानून, कोड आदि कई क्षेत्रों में फैला है)
  • समानांतरता: कई काम एक साथ करने से साफ़ तौर पर तेज़ हो जाता है
  • निर्णय का पृथक्करण: "करने वाले" और "जाँचने वाले" को अलग करने पर गुणवत्ता बढ़ती है

इसके उलट, एक सीधी-सादी प्रक्रिया के लिए multi इस्तेमाल करने पर — जैसा पिछली बार बताया था — लागत 3-10x बढ़ जाती है और क्रमिक कार्यों में सटीकता उल्टे घट जाती है (Google के शोध में एकल की तुलना में −39-70% की रिपोर्ट)। "ज़्यादा agents का मतलब ज़्यादा समझदारी नहीं" — इसी मान्यता से शुरुआत करें।

2. आधार ढाँचा: supervisor (2026 का डिफ़ॉल्ट)

अगर तय न कर पाएँ कि किस pattern से बनाना है, तो बेझिझक supervisor pattern चुनें। Claude Code subagents, LangGraph Supervisor, OpenAI Agents SDK handoffs — प्रमुख implementations सभी इसी ढाँचे पर आकर मिल गए हैं। इसके कारण स्पष्ट हैं।

सबसे व्यापक framework समर्थन

प्रमुख frameworks में native समर्थन। संदर्भ implementations भरपूर।

ज्ञात failure mode

मुख्य विफलता "over-delegation" है, जिसे iteration cap से रोका जाता है।

audit करना आसान

"किसने क्या किया" स्पष्ट रहता है, जिससे debug करना आसान।

तंत्र सरल है। supervisor पूरा कार्य लेता है, उसे उप-कार्यों में बाँटता है, विशेषज्ञ workers को सौंपता है, और परिणामों को जोड़ता है। supervisor को यह जानने की ज़रूरत नहीं कि कोई worker अपना काम कैसे करता है — बस यह कि किस worker को और किस output format में बुलाना है। विशेषज्ञता workers के पास रहती है।

3. इसे 5 चरणों में बनाएँ

न्यूनतम supervisor setup को पाँच चरणों में जोड़ें। आम नियम: 2-3 workers से शुरू करें, और मापने से उचित ठहरने पर ही और जोड़ें।

STEP 1. कार्य को विभाजित करें

"अंतिम लक्ष्य" और ज़रूरी "विशेषज्ञ भूमिकाएँ" लिख लें। उदाहरण: किसी बाज़ार-शोध रिपोर्ट के लिए "1) जानकारी जुटाना → 2) विश्लेषण → 3) लेखन → 4) fact-check"। शुरू में ही साफ़-साफ़ विभाजित करें — यहाँ धुंधलापन पूरी चीज़ को ढहा देता है।

STEP 2. workers परिभाषित करें (3-5 तक)

हर worker को एक भूमिका, ज़रूरी tools, और एक output format दें। शुरुआत में लालची न बनें — अधिकतम 3-5। हर worker स्वतंत्र होता है और केवल अपने ही tools (search, code execution आदि) रखता है।

STEP 3. supervisor को डिज़ाइन करें

supervisor के prompt में उन worker नामों को स्पष्ट रूप से सूचीबद्ध करें जिन्हें वह बुला सकता है (एक hard cap)। तरकीब: किसी भी अकेले worker से ज़्यादा समय supervisor पर लगाएँ। यही समग्र गुणवत्ता तय करता है।

STEP 4. handoff और context साझा करना तय करें

workers के बीच क्या और किस format में सौंपा जाए इसे परिभाषित करें। सबको पूरा context देने से tokens फूल जाते हैं, इसलिए केवल ज़रूरी जानकारी ही सौंपें। agent-से-agent समन्वय का मानक protocol A2A है।

STEP 5. मापें और सीमाओं के साथ चलाएँ

agents जोड़ने से पहले हर handoff को मापें (observability कोई विकल्प नहीं है)। iterations, tokens और लागत पर सीमाएँ लगाएँ। साथ ही evals और guardrails भी तैयार करें।

4. न्यूनतम कोड उदाहरण (छद्म-कोड)

supervisor pattern का सार आश्चर्यजनक रूप से छोटा है। यहाँ framework से स्वतंत्र छद्म-कोड दिया गया है जो वह loop दिखाता है जिसमें supervisor एक worker चुनकर उसे चलाता है (असली API के लिए हर SDK के आधिकारिक दस्तावेज़ देखें)।

# workers परिभाषित करें: एक भूमिका + समर्पित tools
workers = {
  "researcher": Agent(tools=[web_search]),
  "writer":     Agent(tools=[]),
  "factcheck":  Agent(tools=[web_search]),
}

# supervisor: जिन worker नामों को बुला सकता है उन्हें hard-cap करें
supervisor = Agent(
  instructions="Decompose the goal and pick one worker to call next. "
               "Return 'DONE' when finished.",
  allowed_workers=["researcher", "writer", "factcheck"],
)

# Run loop (एक iteration cap over-delegation को रोकता है)
state = {"goal": "Write an AI market report", "history": []}
for step in range(MAX_STEPS):          # <- एक cap अनिवार्य है
  next_worker = supervisor.decide(state)
  if next_worker == "DONE":
    break
  result = workers[next_worker].run(state)
  state["history"].append({next_worker: result})   # केवल ज़रूरी context साझा करें
  log_handoff(next_worker, result)     # <- हर handoff को मापें

तीन सीखें: 1) हर worker एक भूमिका + समर्पित tools है, 2) supervisor जिन्हें बुला सकता है वह समूह सीमित है, 3) loop में हमेशा एक iteration cap होता है। इस ढाँचे पर माप, guardrails और evals जोड़ते जाएँ तो आप production गुणवत्ता के करीब पहुँचते हैं। Claude Agent SDK और Claude Code subagents भी इसी विचार पर चलते हैं।

5. आम गलतियाँ और उनके समाधान

multi-agent विकास में लोग जहाँ अटकते हैं, वे जगहें काफ़ी हद तक तय हैं। इनसे पहले ही निपट लें।

गलती समाधान
Over-delegation (supervisor हमेशा loop करता रहता है) iteration cap + बुलाने योग्य workers सीमित करें
token का फूलना (लागत 3-10x) पूरा context साझा करना बंद करें; केवल ज़रूरी सौंपें + cache
अस्थिर, अनिर्धार्य व्यवहार workers कम रखें (3-5) + output formats तय करें
क्रमिक कार्यों में सटीकता गिरना (−39-70%) सीधे-सादे काम के लिए एकल agent पर लौटें
पता नहीं चलता कहाँ विफल हुआ scale करने से पहले हर handoff को मापें (observability)

साझा सबक: "सफलता framework से ज़्यादा prompts, tool डिज़ाइन और eval harness तय करते हैं।" भड़कीले architecture के बजाय, छोटा बनाने, मापने, और तभी जोड़ने जब फ़ायदेमंद हो — यही अनुशासन अंत में सबसे तेज़ साबित होता है।

सारांश

multi-agent system बनाना डरावना नहीं है, अगर आप न्यूनतम setup से supervisor pattern से शुरुआत करें। आइए दोहराएँ।

मुख्य बातें

  • 🚦 पहले एकल। विशेषज्ञता / समानांतरता / निर्णय पृथक्करण के संकेत दिखने पर ही agents जोड़ें।
  • 🧠 आधार ढाँचा supervisor है (2026 डिफ़ॉल्ट)। supervisor के डिज़ाइन पर सबसे ज़्यादा समय लगाएँ।
  • 🔢 5 चरण: विभाजित करें → workers परिभाषित करें (3-5) → supervisor डिज़ाइन करें → handoff → मापें।
  • ⚠️ गलतियाँ: over-delegation, token का फूलना, अस्थिरता। caps, केवल-ज़रूरी साझाकरण और माप से ठीक करें।
  • 📏 अनुशासन: सफलता framework से ज़्यादा prompts, tools और evals तय करते हैं।

"छोटा बनाएँ, मापें, फिर बढ़ाएँ।" इस अनुशासन को बनाए रखें तो multi-agent system जटिल कामों के लिए एक शक्तिशाली साथी बन जाता है। अवधारणा के लिए देखें multi-agent system क्या है?; एकल agent बनाने के लिए AI agent कैसे बनाएँ।

FAQ

Q. सबसे पहले कौन-सा pattern बनाऊँ?

A. बेझिझक supervisor pattern। प्रमुख frameworks इसका समर्थन करते हैं, इसका failure mode ज्ञात है, और संदर्भ implementations सबसे ज़्यादा उपलब्ध हैं। सहज हो जाने पर अन्य patterns आज़माएँ।

Q. कितने workers से शुरू करूँ?

A. 2-3 से शुरू करें, और अधिकतम 3-5 तक ही रखें। जितने ज़्यादा जोड़ेंगे, उतना अस्थिर होता जाएगा और tokens उतने ही फूलेंगे। आम चलन यह है कि माप से ज़रूरत साबित होने पर ही और जोड़ें।

Q. क्या framework ज़रूरी है?

A. ज़रूरी नहीं। जैसा छद्म-कोड दिखाता है, एक loop और prompts से ही न्यूनतम setup बन सकता है। लेकिन अगर production में state persistence, observability और recovery चाहिए, तो एक सहायक framework शॉर्टकट है।

Q. लागत के विस्फोट को कैसे रोकूँ?

A. तीन चीज़ें मदद करती हैं: 1) iteration की संख्या पर cap लगाएँ, 2) पूरी चीज़ के बजाय केवल ज़रूरी context साझा करें, और 3) prompt caching इस्तेमाल करें। multi बनाने से एकल agent की तुलना में लागत 3-10x हो सकती है, इसलिए पहले दिन से ही caps अनिवार्य हैं।