मुख्य कंटेंट तक स्किप करें

नेटिव मल्टी-एजेंट API: OpenAI का Responses मल्टी-एजेंट बीटा बनाम खुद बनाना

उन्नत

अठारह महीने तक "मल्टी-एजेंट" का मतलब था कि फ़ैन-आउट आप लिखते थे। आप कोऑर्डिनेटर प्रॉम्प्ट लिखते थे, N कॉल समानांतर चलाते थे, उनके JSON मर्ज करते थे और रीट्राई संभालते थे। 9 जुलाई 2026 को OpenAI ने यह सब एक रिक्वेस्ट पैरामीटर में समेट दिया: Responses API पर multi_agent.enabled: true, जिसे Sol Ultra Mode नाम के एक उपभोक्ता फ़ीचर में लपेटा गया है। मॉडल खुद तय करता है कि कितने सबएजेंट बनाने हैं, उन्हें समानांतर चलाता है और नतीजे का संश्लेषण करता है — सब कुछ एक ही HTTP कॉल के भीतर। किसी और फ़्रंटियर वेंडर ने ऐसा सममित प्रिमिटिव जारी नहीं किया है। यह पेज बताता है कि असल में क्या आया, उसके पीछे के आँकड़े, Anthropic इसके बजाय क्या देता है, और — जो हिस्सा मायने रखता है — वे तीन वर्कलोड जहाँ नेटिव प्रिमिटिव अपनी कीमत वसूलता है और वे दो जहाँ खुद का बनाया फ़ैन-आउट अब भी जीतता है।

What you'll learn
  • Responses API की मल्टी-एजेंट रिक्वेस्ट का सटीक बॉडी पढ़ें और जानें कि max_concurrent_subagents असल में किसे सीमित करता है
  • लागत का गणित करें: Sol की कीमतों पर 'मॉडल 4 सबएजेंट बनाता है' का असल में कितना शुल्क लगता है
  • Anthropic की ओर वही इलाका नक़्शे पर उतारें — Cowork, Managed Agents और Claude Code सबएजेंट — और प्रिमिटिव की खाई देखें
  • हर वर्कलोड के लिए सही प्रिमिटिव चुनें: नेटिव मल्टी-एजेंट, खुद का फ़ैन-आउट, A2A, या एक लंबा टर्न
  • उन चार विफलता-तरीक़ों से बचें जो 4-एजेंट Ultra कॉल को बिना सटीकता-लाभ के 4 गुना बिल बना देते हैं

एक वाक्य में​

Ultra Mode, Responses API पर multi_agent.enabled: true के ऊपर चढ़ाई गई एक उपभोक्ता परत है — एक नेटिव प्रिमिटिव जो मॉडल को एक रिक्वेस्ट के भीतर समानांतर सबएजेंट बनाने, उनके आउटपुट का संश्लेषण करने और एक ही रिस्पॉन्स लौटाने देता है। यह समानांतर किए जा सकने वाले कामों पर सटीकता में छोटा लेकिन असली उछाल देता है (Terminal-Bench 2.1: 88.8% → 91.9%), और टोकन बिल लगभग रैखिक रूप से उतना बढ़ता है जितने सबएजेंट मॉडल बनाना चुनता है।

9 जुलाई 2026 को असल में क्या आया​

उसी लॉन्च में दो चीज़ें उतरीं, और उन्हें अलग करके देखना उचित है:

  • Ultra Mode — ChatGPT और Codex के भीतर एक प्रोडक्ट टॉगल। फ़्लैगशिप टियर (Sol) पर उपलब्ध। चालू होने पर कठिन कार्य संश्लेषण से पहले समानांतर सबएजेंट रन में तोड़े जाते हैं। "4+ एजेंट बनाता है" के रूप में प्रचारित; OpenAI के अपने कुछ GA बेंचमार्क चार्ट BrowseComp और SEC-Bench Pro पर 16-एजेंट कॉन्फ़िगरेशन भी दिखाते हैं, पर कामकाजी डिफ़ॉल्ट चार है।
  • Responses API मल्टी-एजेंट बीटा — एक डेवलपर प्रिमिटिव। वही अंतर्निहित क्षमता, client.beta.responses.create() पर multi_agent.enabled: true के रूप में उजागर। अपना Ultra-जैसा अनुभव बनाना हो तो यही इस्तेमाल करेंगे।

मार्केटिंग से उपजा भ्रम असली है: बिल्डर पूछते रहते हैं "API से Ultra Mode कैसे कॉल करूँ?" जवाब यह है कि आप नहीं करते — आप मल्टी-एजेंट बीटा चालू करते हैं, जो प्रोडक्ट फ़ीचर के नीचे का प्रिमिटिव है।

Responses API की मल्टी-एजेंट रिक्वेस्ट​

ठोस रूप में, आकार यह है (Python SDK):

न्यूनतम मल्टी-एजेंट Responses API कॉल

from openai import OpenAI

client = OpenAI()

resp = client.beta.responses.create(
  model="gpt-5.6-sol",
  input="Audit this repo for auth-bypass patterns and write a report.",
  multi_agent={
      "enabled": True,
      "max_concurrent_subagents": 3,
  },
  tools=[...],  # your MCP tools, function tools, etc.
  extra_headers={"OpenAI-Beta": "responses_multi_agent=v1"},
)

इस रूप की चार बातें स्पष्ट नहीं हैं:

  • max_concurrent_subagents कुल बजट नहीं है। यह पूरे पेड़ में किसी भी क्षण सक्रिय सबएजेंट टर्न की सीमा तय करता है — रूट और उसके वंशज मिलाकर। मॉडल रिक्वेस्ट के जीवनकाल में कहीं ज़्यादा कुल सबएजेंट बना सकता है; बस एक साथ N से ज़्यादा चल नहीं सकते।
  • गहराई असीमित है। एक सबएजेंट खुद भी सबएजेंट बना सकता है। पेड़ की गहराई या प्रति-रन कुल सबएजेंट पर कोई तयशुदा सीमा नहीं है। आपकी लागत की सतह "N कॉल" नहीं है — यह एक पेड़ है जिसे मॉडल रनटाइम पर आकार देता है।
  • रूट संश्लेषण करता है। रूट एजेंट सबएजेंट रिस्पॉन्स को अंतिम उत्तर में मर्ज करने के लिए ज़िम्मेदार है। आपको संरचित {subagents: [...]} ऑब्जेक्ट वापस नहीं मिलता; आपको एक रिस्पॉन्स मिलता है, और बीच के एजेंट टर्न आपके कोड के लिए अपारदर्शी रहते हैं।
  • कुछ पैरामीटर चुपचाप निष्क्रिय हो जाते हैं। मल्टी-एजेंट चालू होने पर reasoning.summary और max_tool_calls समर्थित नहीं हैं, और मल्टी-एजेंट रिस्पॉन्स के लिए कॉम्पैक्शन एंडपॉइंट असमर्थित है। अगर आप ऑब्ज़र्वेबिलिटी के लिए रीज़निंग सारांश पर निर्भर हैं, तो इसे चालू करते ही वे चले जाते हैं।

लागत का गणित जो मार्केटिंग पेज पर नहीं छपता​

Sol की GA कीमत $5 इनपुट / $30 आउटपुट प्रति मिलियन टोकन पर यह अंकगणित बेरहम है। असली Ultra रन को रिवर्स-इंजीनियर करने वाले बिल्डरों के लेखों से:

  • वह कार्य जिसे Ultra 2 सबएजेंट में तोड़ता है ≈ एक अकेली Sol कॉल की आउटपुट टोकन लागत का 2 गुना — क्योंकि दोनों सबएजेंट आउटपुट बनाते हैं, और रूट उसके ऊपर संश्लेषण भी बनाता है।
  • वह कार्य जिसके लिए Ultra 5 सबएजेंट बनाता है ≈ 5 गुना — वही तर्क, साथ में पेड़ भर में अनुपात में ज़्यादा इनपुट टोकन रीप्ले।
  • 16-एजेंट कॉन्फ़िगरेशन दिखाने वाले BrowseComp / SEC-Bench चार्ट मुफ़्त का भोजन नहीं हैं: वे शोध-स्तर का प्रदर्शन हैं, डिफ़ॉल्ट नहीं। Sol पर 16 समवर्ती सबएजेंट के साथ, अकेले आउटपुट टोकन में प्रति कठिन क्वेरी दो अंकों के मध्य का डॉलर आँकड़ा बैठता है।

इसे ऐसे सोचें: आप Sol कॉलों के एक मोंटे कार्लो और उसके ऊपर एक संश्लेषण पास के पैसे दे रहे हैं। कभी इससे इतनी सटीकता मिलती है कि फ़र्क पड़े। कभी यह बस उस काम के लिए 4 गुना बिल होता है जिसे एक कॉल हल कर देती।

सटीकता असल में क्या दिलाती है​

समानांतर-योग्य इवैल्स पर — यानी जिन वर्कलोड के लिए Ultra Mode बना है — प्रकाशित अंतर असली हैं पर मामूली:

बेंचमार्कSol (अकेला)Sol Ultraअंतरइवैल क्या मापता है
Terminal-Bench 2.188.8%91.9%+3.1बहु-चरणीय कमांड-लाइन योजना, टूल समन्वय
BrowseComp87.5%92.2%+4.7बहु-स्रोत वेब शोध और संश्लेषण
SEC-Bench Pro—74.3%(सिंगल-मोड संख्या अप्रकाशित)बड़े कॉर्पस में नियामक दस्तावेज़ों पर तर्क

इस तालिका के बारे में तीन बातें:

  • +3–5 अंक की पट्टी उसके अनुरूप है जो समानांतर सैंपलिंग ने अन्य फ़्रंटियर पर ऐतिहासिक रूप से दिलाया है (best-of-N, self-consistency)। प्रिमिटिव वाक़ई उपयोगी है; यह अंतर कोई छलांग नहीं है।
  • ये सबसे अच्छी स्थिति हैं — मोड को दिखाने के लिए चुने गए इवैल्युएशन। अनुक्रमिक कामों (रैखिक कोड एडिट, एक फ़ाइल की पुनर्लेखन, छोटी चैट) पर Ultra सटीकता बदले बिना संश्लेषण की देरी और लागत जोड़ता है।
  • उसी Terminal-Bench 2.1 चार्ट पर Anthropic के Opus 4.8 ने 78.9% पाया — यानी Sol Ultra की बढ़त बेहतर बेस मॉडल और उसके ऊपर चढ़े मल्टी-एजेंट बूस्ट दोनों से आती है। अगर आप Opus से Sol Ultra पर जाते हैं, तो पूरे अंतर का श्रेय मल्टी-एजेंट प्रिमिटिव को न दें।

Anthropic इसके बजाय क्या करता है​

Anthropic ने सममित API प्रिमिटिव जारी नहीं किया है। सबसे नज़दीकी समतुल्य हर एक उसी समस्या का एक अलग टुकड़ा हल करता है:

  • Cowork — एक प्रोडक्ट सतह। एक एजेंटिक डेस्कटॉप वर्कस्पेस जहाँ एजेंट उपयोगकर्ता के साथ लगातार बहु-चरणीय काम करता है। फ़ीचर के रूप में Ultra Mode से तुलनीय, पर API प्रिमिटिव के रूप में नहीं।
  • Managed Agents और managed-agents memory stores — स्थायी स्टेट और शेड्यूलिंग वाला होस्टेड एजेंट लूप। यह "लंबे समय चलने वाला बैकग्राउंड एजेंट" वाला खाना भरता है, "4 समानांतर बनाओ और मर्ज करो" वाला नहीं।
  • Claude Code सबएजेंट और सबएजेंट फ़्लीट सीमाएँ — फ़र्स्ट-क्लास सबएजेंट प्रिमिटिव, पर Claude Code CLI तक सीमित। दस्तावेज़ित, समानांतर बनाने योग्य, और multi_agent.enabled का सबसे नज़दीकी समतुल्य — महत्वपूर्ण फ़र्क के साथ कि कोऑर्डिनेटर प्रॉम्प्ट आप खुद लिखते हैं।
  • Messages API पर एजेंट बनाना — खुद करने का रास्ता। आप N messages.create कॉल समानांतर फ़ैन-आउट करते हैं, संश्लेषण प्रॉम्प्ट खुद लिखते हैं और रीट्राई संभालते हैं। नतीजा वही, कोड ज़्यादा।

खाई यह है: फ़िलहाल कोई Anthropic API सतह एक बूलियन पलटकर यह नहीं करने देती कि मॉडल खुद तय करे कि कितने सबएजेंट बनाने हैं और उनका काम मर्ज करे। अगर आपको Claude के साथ यह व्यवहार चाहिए, तो आप इसे बनाते हैं — प्रोडक्ट-पक्ष की कहानी के लिए Cowork और Agent Teams और होस्टेड-लूप प्रिमिटिव के लिए Managed Agents देखें।

हर वर्कलोड के लिए सही प्रिमिटिव चुनना​

Guided walkthrough1 of 5
  1. अगर उप-कार्य एक-दूसरे के नतीजों का इंतज़ार किए बिना चल सकते हैं — किसी रिपॉज़िटरी का ऑडिट, कई स्रोतों में किसी विषय का शोध, N फ़ाइलों का स्वतंत्र रिफ़ैक्टर — तो फ़ैन-आउट का रूप अपनी लागत वसूलता है। अगर कार्य अनुक्रमिक है (A संपादित करो, फिर A का नतीजा पढ़ो, फिर B संपादित करो), तो कोई भी मल्टी-एजेंट प्रिमिटिव बिना लाभ के संश्लेषण का बोझ बढ़ाता है।

चार विफलता-तरीक़े जो Ultra को बेवजह 4 गुना बिल बना देते हैं​

  • इसे अनुक्रमिक कार्यों पर चालू करना। कार्य समानांतर न होने पर भी मॉडल तोड़ता और संश्लेषण करता है। आप उस काम के लिए समन्वय का बोझ भरते हैं जिसे उसकी कभी ज़रूरत नहीं थी। अंगूठे का नियम: अगर आप यह नहीं बता सकते कि पहला सबएजेंट चलते समय दूसरा क्या करेगा, तो मल्टी-एजेंट चालू न करें।
  • रीज़निंग-सारांश वाली ऑब्ज़र्वेबिलिटी अपने डैशबोर्ड पर छोड़ देना। मल्टी-एजेंट के साथ reasoning.summary चुपचाप असमर्थित है। अगर आपकी मॉनिटरिंग उस पर निर्भर है, तो आपको खाली फ़ील्ड मिलेंगे और आप सोचेंगे कि मॉडल सोच नहीं रहा। फ़्लैग पलटने से पहले स्कीमा परिवर्तन शिप करें।
  • max_tool_calls को सुरक्षा-सीमा की तरह इस्तेमाल करना। यह भी मल्टी-एजेंट के साथ चुपचाप निष्क्रिय है। जो सुरक्षा आपने सोची थी — "प्रति रिक्वेस्ट अधिकतम 20 टूल कॉल" — वह चली जाती है। टूल-कॉल की सीमाएँ टूल-एडेप्टर परत पर लागू करें, रिक्वेस्ट पैरामीटर के ज़रिए नहीं।
  • max_concurrent_subagents को लागत की सीमा मान लेना। यह किसी क्षण के सक्रिय सबएजेंट की सीमा है, रिक्वेस्ट भर में बने कुल की नहीं। एक अकेली Ultra कॉल क्रम से दर्जनों सबएजेंट बना सकती है और फिर भी max_concurrent_subagents: 3 की सीमा का पालन कर सकती है। अगर लागत आपकी छत है, तो रिक्वेस्ट-स्तर का max_output_tokens जोड़ें।

"नेटिव मल्टी-एजेंट" क्या नहीं है​

दो पड़ोसी प्रिमिटिव अक्सर इससे गड़बड़ा जाते हैं:

  • n > 1 सैंपलिंग नहीं। OpenAI का पुराना n पैरामीटर कई कम्प्लीशन सैंपल करके सब लौटाता है; आप एक चुनते हैं। मल्टी-एजेंट अलग-अलग सबएजेंट चलाता है जो अलग-अलग काम करते हैं और उनके आउटपुट का संश्लेषण करता है। पहला तापमान-सैंपलिंग है; दूसरा कार्य-विघटन।
  • बैच इन्फ़रेंस नहीं। बैच API बैकग्राउंड में कई स्वतंत्र रिक्वेस्ट प्रोसेस करता है। मल्टी-एजेंट एक इंटरैक्टिव रिक्वेस्ट के भीतर कई समन्वित सबएजेंट है। बैच थ्रूपुट-उन्मुख है, मल्टी-एजेंट नतीजा-उन्मुख।

यह किस ओर जा रहा है​

A2A प्रोटोकॉल (देखें A2A: एजेंट-टू-एजेंट प्रोटोकॉल) वेंडरों-के-बीच मल्टी-एजेंट को कवर करता है। multi_agent.enabled: true मॉडल-के-भीतर मल्टी-एजेंट को कवर करता है। जो खाना खाली है वह क्रॉस-वेंडर प्रिमिटिव है — वेंडर A का मॉडल वेंडर B पर एक सबएजेंट बनाए और नतीजा मर्ज करे — और उसके लिए अभी कोई सार्वजनिक स्पेक नहीं है। जब यह आएगा, तो A2A + एक नेटिव हैंडऑफ़ क्रिया के रूप में आएगा, किसी भी ओर के नए API के रूप में नहीं। इस क्षेत्र पर नज़र रखें।

Check yourself

0/4
  1. Responses मल्टी-एजेंट बीटा पर max_concurrent_subagents किसे सीमित करता है?
  2. आप मल्टी-एजेंट चालू करते हैं और आपके मॉनिटरिंग डैशबोर्ड पर रीज़निंग-सारांश के फ़ील्ड अचानक खाली दिखते हैं। क्या हुआ?
  3. आपको ऐसे समानांतर सबएजेंट चाहिए जो दो वेंडरों में अलग-अलग ग्राहक खातों में चलें। कौन-सा प्रिमिटिव सही है?
  4. इनमें से कौन Ultra Mode / multi_agent.enabled के लिए कमज़ोर उम्मीदवार है?
अभी कोई कार्ड नहीं — अध्ययन शुरू करने के लिए कुछ जोड़ें। 🃏

स्रोत और आगे पढ़ें​

आगे​