Multi-Agent System कैसे बनाएँ: Supervisor Pattern की व्यावहारिक गाइड

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

किसी framework की बात शुरू करने से पहले, सबसे ज़रूरी सिद्धांत यह है: "पहले एक ही agent से बनाएँ, और सीमा से टकराने के बाद ही न्यूनतम रूप में agents जोड़ें।" शुरुआत से ही बहुत सारे agents जोड़ना आम तौर पर ज़रूरत से ज़्यादा engineering है। दूसरे हिस्से में आपको Claude Agent SDK और OpenAI Agents SDK के आधिकारिक दस्तावेज़ों के अनुसार लिखा गया, पढ़ने में आसान न्यूनतम कोड मिलेगा, साथ ही भूमिकाएँ बाँटने का तरीका और असल में होने वाली विफलताएँ। MCP से tools जोड़ने पर भी यही सोच लागू होती है।

नोट: कोड Claude Agent SDK और OpenAI Agents SDK के आधिकारिक दस्तावेज़ों के अनुसार लिखा गया है (4 अक्टूबर 2026 को जाँचा गया)। ये SDK तेज़ी से बदलते हैं, इसलिए चलाने से पहले हर parameter का नाम आधिकारिक दस्तावेज़ में मिला लें। लेख के हर आँकड़े के साथ उसका स्रोत दिया गया है।

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

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

इसके उलट, जैसा पिछले लेख में बताया था, एक-सीधी प्रक्रिया पर multi-agent लगाना महँगा पड़ता है। Google Research के अध्ययन (जनवरी 2026 में प्रकाशित, 180 configurations की तुलना) में सख़्ती से क्रमवार तर्क वाले काम (PlanCraft) पर, जाँचे गए सभी multi-agent रूप एकल agent से 39–70% ख़राब रहे। लागत भी बढ़ती है: Anthropic ने अपने research agent के विवरण में लिखा है कि agents एक chat से लगभग 4 गुना और multi-agent systems लगभग 15 गुना tokens इस्तेमाल करते हैं। "ज़्यादा agents का मतलब ज़्यादा समझदारी नहीं" — इसी आधार से शुरुआत करें।

2. आधार ढाँचा: supervisor pattern

अगर तय नहीं कर पा रहे कि कौन-सा pattern बनाएँ, तो supervisor pattern से शुरू करना सुरक्षित विकल्प है। प्रमुख SDK इसे आधिकारिक बुनियादी pattern के रूप में दर्ज करते हैं। Claude Agent SDK में मुख्य agent Agent tool से subagents को बुलाता है; OpenAI Agents SDK में इसका समकक्ष "agents as tools" है, जहाँ एक manager agent विशेषज्ञ agents को tools की तरह बुलाता है।

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

ध्यान दें: OpenAI Agents SDK में handoff का अर्थ STEP 4 के सामान्य handoff से संकरा है: triage agent बातचीत ही किसी विशेषज्ञ को सौंप देता है, और उसके बाद विशेषज्ञ सीधे उपयोगकर्ता को उत्तर देता है। यहाँ कोई supervisor नहीं बचता, इसलिए इसे supervisor से अलग pattern मानें (कब कौन-सा चुनें, यह खंड 6 में है)।

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

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

4. न्यूनतम कोड ①: Claude Agent SDK (Python)

पहले Anthropic के Claude Agent SDK से एक supervisor और दो workers (एक researcher और एक reviewer) बनाते हैं। तैयारी में बस pip install claude-agent-sdk और environment variable ANTHROPIC_API_KEY चाहिए (आधिकारिक quickstart; SDK .env फ़ाइल अपने-आप नहीं पढ़ता)। कोड आधिकारिक Subagents पेज के अनुसार है। पूरे SDK के लिए हमारी Claude Agent SDK गाइड देखें।

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition, ResultMessage

options = ClaudeAgentOptions(
    model="claude-opus-5-5",  # supervisor (मुख्य agent)
    system_prompt=(
        "You coordinate a research report. Delegate research to researcher and fact-checking "
        "to reviewer, and write the final text yourself. When delegating, always state the "
        "goal, the output format, and the scope."
    ),
    allowed_tools=["Agent", "WebSearch", "WebFetch"],  # बिना अनुमति पूछे चलने वाले tools
    agents={
        "researcher": AgentDefinition(
            description="Gathers primary sources. Use when facts or figures are needed.",
            prompt="Find primary sources for the question and return bullet points with source URLs. Never fill gaps with guesses.",
            tools=["WebSearch", "WebFetch"],  # इस भूमिका के पास सिर्फ़ यही tools
            model="sonnet",
            maxTurns=15,
        ),
        "reviewer": AgentDefinition(
            description="Fact-checks drafts. Always use before finalizing text.",
            prompt="Check each claim in the draft against its source and list every sentence that lacks support.",
            tools=["WebFetch"],
            model="sonnet",
            maxTurns=10,
        ),
    },
    max_turns=30,         # पूरे run के round trips की सीमा
    max_budget_usd=5.0,   # ख़र्च की सीमा (SDK का अनुमान)
    env={"CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH": "1"},  # workers अपने subagents नहीं बनाएँगे
)


async def main():
    try:
        async for message in query(
            prompt="Find three official statistics on workplace use of generative AI and write a short report",
            options=options,
        ):
            if isinstance(message, ResultMessage):
                print(message.subtype, message.total_cost_usd)
                print(message.result)
    except Exception as error:
        print(f"Stopped early: {error}")  # सीमा तक पहुँचने पर भी यहीं आता है


asyncio.run(main())

ध्यान देने लायक पाँच बातें:

• Workers को agents में AgentDefinition के रूप में रखा जाता है। Supervisor हर worker का description पढ़कर तय करता है कि किसे और कब बुलाना है, इसलिए साफ़ लिखें कि भूमिका क्या करती है और कब इस्तेमाल हो।
• tools की सूची देने पर भूमिका के पास सिर्फ़ वही tools रहते हैं। इसी वजह से reviewer के पास लिखने वाले tools नहीं हैं। वहीं allowed_tools उन tools की सूची है जो बिना अनुमति पूछे चलते हैं; यह किसी चीज़ को सीमित नहीं करती (आधिकारिक Python reference)।
• सीमाएँ तीन जगह लगाएँ। हर भूमिका के लिए maxTurns, पूरे run के लिए max_turns, और ख़र्च के लिए max_budget_usd। पूरे run की सीमा पर पहुँचते ही नतीजे का subtype error_max_turns या error_max_budget_usd हो जाता है और run रुक जाता है (agent loop दस्तावेज़)।
• Nesting रोकें। Subagents अपने subagents बना सकते हैं। Environment variable CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH को 1 करने पर workers काम ख़ुद करते हैं। CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS (डिफ़ॉल्ट 20) एक साथ चलने वालों की संख्या सीमित करता है।
• AgentDefinition के field नाम camelCase में हैं। maxTurns की जगह max_turns लिखने पर बनाते समय ही TypeError आता है (आधिकारिक नोट)। Supervisor में मौजूदा claude-opus-5-5 और workers में alias "sonnet" दिया है, ताकि नया version आने पर भी कोड बदलना न पड़े।

आधिकारिक दस्तावेज़ बताते हैं कि Opus 5 पहले के models की तुलना में subagents को काम ज़्यादा आसानी से सौंपता है, और सलाह देते हैं कि prompt के निर्देशों के साथ-साथ depth, concurrency और ख़र्च की सीमाएँ भी लगाएँ। निर्देश सिर्फ़ यह बदलता है कि Claude मदद कैसे माँगे; run को भरोसे से सिर्फ़ सीमाएँ ही रोकती हैं।

5. न्यूनतम कोड ②: OpenAI Agents SDK (Python)

OpenAI के Agents SDK में यही ढाँचा ऐसे बनता है: विशेषज्ञ agents को as_tool() से tools में बदलकर supervisor के tools में दिया जाता है (आधिकारिक "agents as tools")। तैयारी है pip install openai-agents और environment variable OPENAI_API_KEY (आधिकारिक quickstart)। model छोड़ देने पर SDK का डिफ़ॉल्ट model चलता है; यह डिफ़ॉल्ट SDK के version के साथ बदलता है, इसलिए Models पेज पर जाँच लें।

import asyncio
from agents import Agent, Runner, WebSearchTool

researcher = Agent(
    name="Researcher",
    instructions="Find primary sources for the question and return bullet points with source URLs. Never fill gaps with guesses.",
    tools=[WebSearchTool()],
)
reviewer = Agent(
    name="Reviewer",
    instructions="Check each claim in the draft you receive against its source and list every sentence that lacks support.",
)

manager = Agent(
    name="Manager",
    instructions=(
        "You coordinate a research report. Delegate research to research and fact-checking "
        "to review, and write the final text yourself."
    ),
    tools=[
        researcher.as_tool(
            tool_name="research",
            tool_description="Gather primary sources with citations",
            max_turns=10,  # इस भूमिका के round trips की सीमा
        ),
        reviewer.as_tool(
            tool_name="review",
            tool_description="Fact-check a draft",
        ),
    ],
)


async def main():
    result = await Runner.run(
        manager,
        input="Find three official statistics on workplace use of generative AI and write a short report",
        max_turns=10,  # पार होने पर MaxTurnsExceeded
    )
    print(result.final_output)


asyncio.run(main())

दोनों SDK में क्या एक जैसा है और क्या अलग:

• Worker को parent की बातचीत का पता नहीं होता। as_tool() से बुलाया गया agent parent run की बातचीत की स्थिति अपने-आप नहीं पाता (आधिकारिक दस्तावेज़)। Claude Agent SDK में भी यही है: subagent को parent से सिर्फ़ Agent tool का prompt मिलता है। फ़ाइल paths, error संदेश और लिए गए फ़ैसले सीधे काम सौंपने वाले संदेश में लिखें।
• सीमा है Runner.run(..., max_turns=)। पार होने पर MaxTurnsExceeded आता है। error_handlers={"max_turns": ...} देने पर exception की जगह तय किया हुआ उत्तर लौटाया जा सकता है (Running agents)।
• Handoff से लिखना हो तो Agent(..., handoffs=[billing_agent, refund_agent])। पाने वाला agent बातचीत सँभाल लेता है और डिफ़ॉल्ट रूप से पिछला पूरा इतिहास देखता है। अगर कोई जानकारी उस तक नहीं पहुँचनी चाहिए, तो input_filter से छाँटें।

6. भूमिकाएँ कैसे बाँटें: अच्छा और बुरा बँटवारा

कोड से कठिन है बँटवारा। Anthropic लिखता है कि हर subagent को एक लक्ष्य, एक output format, किन tools और स्रोतों का उपयोग करना है इसका मार्गदर्शन, और काम की साफ़ सीमाएँ चाहिए (वही विवरण)। नीचे वे बँटवारे हैं जो ये चार शर्तें पूरी करते हैं, और वे जो नहीं करते।

उसी विवरण में कितने agents इस्तेमाल करें, इसका पैमाना भी है। Anthropic ने अपने research supervisor के prompt में scaling नियम लिखे: सरल तथ्य खोजने के लिए 1 agent और 3–10 tool calls, सीधी तुलना के लिए 2–4 subagents और हर एक के 10–15 calls, और जटिल research में 10 से ज़्यादा subagents भी लग सकते हैं। ये संख्याएँ research के काम की हैं, इसलिए अपने काम में छोटे सिरे से शुरू करें और मापने के बाद ही बढ़ाएँ।

Supervisor और handoff में चुनाव के लिए OpenAI के दस्तावेज़ साफ़ कसौटी देते हैं। अगर अंतिम उत्तर किसी एक agent के पास होना चाहिए या कई विशेषज्ञों के नतीजे मिलाने हैं, तो supervisor (agents as tools)। अगर routing ही काम है और चुने गए विशेषज्ञ को सीधे उपयोगकर्ता को उत्तर देना है (जैसे support अनुरोधों की छँटाई), तो handoff। दोनों को मिलाया भी जा सकता है।

7. आम विफलताएँ और उनके समाधान

लोग कहाँ अटकते हैं, यह लगभग तय है। नीचे वे विफलताएँ हैं जो Anthropic के अनुसार उसके research agent में सच में हुईं, और वे बातें जिन पर दोनों SDK के आधिकारिक दस्तावेज़ चेतावनी देते हैं।

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

सारांश

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

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

FAQ