Antigravity में कई एजेंट चलाने से तेज़, समानांतर AI वर्कफ़्लो खुलते हैं, लेकिन कोऑर्डिनेशन, टास्क आइसोलेशन और टाइमिंग के लिए सावधानी से योजना बनाना ज़रूरी है। यह लेख उन असली पैटर्न को समझाता है जो काम करते हैं, उन आम गलतियों को बताता है जो घंटों बर्बाद कर देती हैं, और यह भी दिखाता है कि समवर्ती एजेंटों को AI इमेज और टेक्स्ट जनरेशन टूल्स के साथ कैसे जोड़ें ताकि बेहतर, स्वचालित आउटपुट मिलें।
Antigravity में कई एजेंट चलाना आसान लगता है, जब तक तीसरा एजेंट चुपचाप क्रैश न हो जाए और आप चालीस मिनट यह सोचते न रह जाएँ कि आउटपुट आधा-अधूरा क्यों है। समानांतर एक्जीक्यूशन Antigravity की सबसे शक्तिशाली सुविधाओं में से एक है, लेकिन इसके लिए एक खास मानसिक मॉडल चाहिए। यह लेख बताता है कि प्रोडक्शन में वास्तव में क्या काम करता है, असली टीमें अपनी एजेंट पाइपलाइन कैसे बनाती हैं, और उन जालों से कैसे बचें जो पहली नज़र में हानिरहित लगते हैं।
ज़्यादातर एजेंट फ़्रेमवर्क डिफ़ॉल्ट रूप से सीरियल चलते हैं। आप एक टास्क परिभाषित करते हैं, एक एजेंट उसे उठाता है, पूरा करता है, और तभी अगला टास्क शुरू होता है। Antigravity इसे उलट देता है। इसका मुख्य शेड्यूलर एक समवर्ती इवेंट लूप पर बना है, जो एजेंट टास्क को पहली श्रेणी के नागरिक मानता है, न कि थ्रेड पूल के ऊपर बाद में जोड़ी गई चीज़।
मूल रूप से Antigravity एक रिएक्टिव लूप चलाता है। जब आप कोई एजेंट रजिस्टर करते हैं, तो आप नया प्रोसेस शुरू नहीं कर रहे होते। आप एक कोरूटीन रजिस्टर कर रहे होते हैं, जिसे शेड्यूलर मैनेज करता है। इसका मतलब है कि लेटेंसी थ्रेडेड सिस्टम से अलग तरह से जमा होती है। Antigravity में दस एजेंट एक साथ चलें तो वे आम तौर पर दस सीरियल कॉल से बेहतर प्रदर्शन करेंगे, क्योंकि I/O इंतज़ार का समय, जिसमें ज़्यादातर LLM कॉल अपना 80% समय बिताते हैं, पूरे पूल में साझा हो जाता है।
यहाँ मूल बात यह है: समवर्ती का मतलब अनियंत्रित होना नहीं है। Antigravity आपको बिल्डिंग ब्लॉक देता है, लेकिन कोऑर्डिनेशन का तर्क पूरी तरह आपका है।
और एजेंट जोड़ने से पहले यह समझना मददगार है कि सिंगल-एजेंट डिफ़ॉल्ट क्यों मौजूद है। एक सिंगल एजेंट अनुमानित व्यवहार करता है। वह एक कॉन्टेक्स्ट पढ़ता है, उस पर काम करता है, और एक परिणाम लौटाता है। जैसे ही आप एक दूसरा एजेंट जोड़ते हैं जो वही कॉन्टेक्स्ट पढ़ता है, अलग-अलग आउटपुट की संभावना पैदा हो जाती है। Antigravity इन्हें जादुई तरीके से नहीं मिलाता। यह काम आपका है।
💡 एक एजेंट से शुरू करें, देखें कि वह इंतज़ार में समय कहाँ बिताता है, और फिर तय करें कि कौन से इंतज़ार समानांतर करने लायक हैं।
Antigravity में कई एजेंट सेट करने के लिए शुरू में तीन फ़ैसले ज़रूरी हैं: एजेंट कैसे स्पॉन होंगे, क्या वे स्टेट साझा करेंगे, और परिणाम ऑर्केस्ट्रेटर तक कैसे वापस पहुँचेंगे।
सबसे सीधा तरीका है टास्क परिभाषा के स्तर पर स्पष्ट स्पॉनिंग। एजेंट को एक-एक करके कॉल करने के बजाय आप टास्क का एक बैच परिभाषित करते हैं और शेड्यूलर को उन्हें एक साथ डिस्पैच करने देते हैं।
tasks = [
agent.create_task("summarize", doc_a),
agent.create_task("summarize", doc_b),
agent.create_task("summarize", doc_c),
]
results = await asyncio.gather(*tasks)
महत्वपूर्ण बात: Antigravity में asyncio.gather एजेंट पूल के आकार का सम्मान करता है। अगर आप max_concurrent=3 सेट करते हैं और 10 टास्क डिस्पैच करते हैं, तो पहले तीन तुरंत शुरू होते हैं। बाकी सात कतार में लगते हैं। यह जानबूझकर किया गया रेट कंट्रोल है, कोई बग नहीं।
यही वह फ़ैसला है जो ज़्यादातर मल्टी-एजेंट सेटअप को तोड़ देता है। तीन मान्य पैटर्न हैं:
| पैटर्न | कब उपयोग करें | जोखिम |
|---|---|---|
| अलग (Isolated) | जब हर एजेंट को अलग डेटा चाहिए | कम: कोई टकराव नहीं |
| साझा रीड (Shared Read) | जब एजेंटों को एक ही बेस कॉन्टेक्स्ट चाहिए | मध्यम: मेमोरी का बोझ |
| साझा राइट (Shared Write) | जब एजेंट एक साझा ऑब्जेक्ट अपडेट करते हैं | अधिक: रेस कंडीशन |
अलग टास्क लगभग हमेशा सही डिफ़ॉल्ट होते हैं। अगर दो एजेंटों को डेटा का एक ही हिस्सा चाहिए, तो हर एक को उसकी कॉपी दें। मेमोरी की कीमत अनुमानित व्यवहार से मिलने वाले फ़ायदे के लायक है।
साझा राइट स्टेट को सुविधा के बजाय आखिरी उपाय समझें। अगर यह ज़रूरी ही हो, तो साधारण Python dict के बजाय Antigravity के बिल्ट-इन StateManager का उपयोग करें, जिसमें स्पष्ट लॉकिंग हो।
जब Agent A का आउटपुट Agent B को मिलता है, तो एक डिपेंडेंसी बन जाती है। Antigravity में डिपेंडेंसी अपनी परिभाषा से ही समानांतरता को तोड़ देती है। जो दो एजेंट एक-दूसरे पर निर्भर हैं, वे एक साथ नहीं चल सकते।
सबसे साफ़ पैटर्न है स्पष्ट हैंडऑफ़:
summary = await agent_a.run(document)
analysis = await agent_b.run(summary)
मिश्रित डिपेंडेंसी वाली बड़ी पाइपलाइन के लिए डिपेंडेंसी ग्राफ़ तरीका अपनाएँ। तय करें कि कौन से टास्क स्वतंत्र हैं (समानांतर चलेंगे) और कौन से क्रमिक हैं (क्रम में चलेंगे), और बाकी काम Antigravity के शेड्यूलर पर छोड़ दें।
तीन पैटर्न Antigravity में लगभग 90% मल्टी-एजेंट उपयोगों को संभालते हैं। ये विदेशी नहीं हैं। ये अपने सबसे अच्छे अर्थ में उबाऊ हैं।
फ़ैन-आउट पैटर्न बैच AI काम के लिए सबसे आम पैटर्न है। एक इनपुट, कई समानांतर एजेंट, एक संग्रह बिंदु।
यह कैसे काम करता है:
यह पैटर्न तब चमकता है जब टास्क पूरी तरह स्वतंत्र रूप से समानांतर हों: किसी भी एजेंट को यह जानने की ज़रूरत नहीं कि बाकी क्या कर रहे हैं। इमेज जनरेशन, दस्तावेज़ सारांश, वर्गीकरण और अनुवाद, सभी इस आकार में पूरी तरह फ़िट होते हैं।
💡 बहुत बड़े बैच के लिए, अधिकतम समवर्तिता नियंत्रित करने हेतु एक सेमाफ़ोर जोड़ें:
asyncio.Semaphore(10)सुनिश्चित करता है कि आप एक साथ 10 से ज़्यादा एजेंट कभी स्पॉन न करें, जिससे डाउनस्ट्रीम API रेट लिमिट सुरक्षित रहती है।
पाइपलाइन चेन फ़ैन-आउट का उलटा रूप है: एक सख्ती से क्रमिक प्रवाह जहाँ हर एजेंट पिछले एजेंट के आउटपुट पर आगे बढ़ता है।
Agent 1 (Research) → Agent 2 (Draft) → Agent 3 (Edit) → Agent 4 (Format)
सबसे अच्छा किसके लिए: ऐसे टास्क जहाँ गुणवत्ता धीरे-धीरे सुधार पर निर्भर करती है। लेखन, कोड जनरेशन और मल्टी-स्टेप रीज़निंग पाइपलाइन चेन से फ़ायदा उठाते हैं, क्योंकि बाद के एजेंट पहले के एजेंटों की गलतियाँ सुधार सकते हैं।
पाइपलाइन चेन का जोखिम है एरर प्रॉपेगेशन। अगर Agent 1 कोई दोषपूर्ण आउटपुट लौटाता है, तो Agent 2 से 4 उसी दोष पर आत्मविश्वास से आगे बनाते रहेंगे। हर चरण के बीच वैलिडेशन जोड़ें, भले ही वह सिर्फ़ लंबाई या स्कीमा की साधारण जाँच हो।
सुपरवाइज़र मॉडल तीनों में सबसे परिष्कृत है। एक एजेंट, यानी सुपरवाइज़र, वर्कर एजेंटों के एक पूल को ऑर्केस्ट्रेट करता है। सुपरवाइज़र असली काम नहीं करता। वह योजना बनाता है, काम सौंपता है, समीक्षा करता है, और तय करता है कि दोबारा प्रयास करना है या नहीं।
सुपरवाइज़र की ज़िम्मेदारियाँ:
इस पैटर्न के लिए, Kimi K2.6 और GPT 5.1 उत्कृष्ट सुपरवाइज़र मॉडल हैं। दोनों खास तौर पर एजेंट ऑर्केस्ट्रेशन कार्यों के लिए बने हैं, और GPT 5.1 विशेष रूप से AI एजेंट बनाने के लिए डिज़ाइन किया गया है। वर्कर के रूप में, Claude 4.5 Haiku या GPT 4.1 Mini जैसे हल्के मॉडल, अच्छी तरह से परिभाषित टास्क पर गुणवत्ता से समझौता किए बिना लागत में काफ़ी कमी लाते हैं।
| भूमिका | अनुशंसित मॉडल | कारण |
|---|---|---|
| सुपरवाइज़र | Kimi K2.6 | मज़बूत रीज़निंग, एजेंट के लिए बना |
| सुपरवाइज़र | GPT 5.1 | नेटिव एजेंट बनाने की क्षमताएँ |
| वर्कर | Claude 4.5 Haiku | तेज़, लागत-कुशल |
| वर्कर | GPT 4.1 Mini | कम लेटेंसी, भरोसेमंद आउटपुट |
| रीज़नर | Deepseek R1 | जटिल सब-टास्क के लिए गहरी रीज़निंग |
Antigravity में ज़्यादातर मल्टी-एजेंट विफलताएँ दो श्रेणियों में आती हैं। दोनों से बचा जा सकता है, बस यह जानना ज़रूरी है कि किस पर नज़र रखनी है।
रेस कंडीशन तब होती है जब दो एजेंट एक ही समय पर एक ही संसाधन में लिखते हैं और किसी को दूसरे के होने की जानकारी नहीं होती। Antigravity में यह आम तौर पर इन रूपों में दिखती है:
समाधान है कि लॉक के बिना कभी किसी साझा संसाधन में न लिखें। व्यवहार में इसका मतलब है:
lock = asyncio.Lock()
async def safe_write(lock, data, destination):
async with lock:
destination.append(data)
फ़ाइलों या APIs जैसे बाहरी संसाधनों के लिए, राइट्स को एक ही समर्पित राइटर एजेंट के ज़रिए क्रमबद्ध करें। बाकी एजेंट अपने आउटपुट राइटर को देते हैं; संसाधन को सिर्फ़ राइटर छूता है।
यह कम स्पष्ट है। जब आप कई एजेंट एक साथ चलाते हैं, तो हर एजेंट उसी मॉडल एंडपॉइंट से टोकन माँगता है। अगर आप कुल समवर्ती टोकन खर्च को नियंत्रित नहीं करते, तो आपको अप्रत्याशित अंतराल पर रेट लिमिट मिलेगी।
यहाँ पैटर्न है ऑर्केस्ट्रेटर स्तर पर टोकन बजटिंग। एजेंट स्पॉन करने से पहले बैच के लिए कुल टोकन ज़रूरत का अनुमान लगाएँ। अगर अनुमान आपकी रेट लिमिट विंडो से ज़्यादा है, तो देरी जोड़ें या बैच का आकार घटाएँ।
💡 भारी समानांतर वर्कलोड के लिए, Llama 4 Maverick Instruct और Deepseek v3.1 उच्च-थ्रूपुट विकल्प हैं, जिनकी रेट लिमिट उदार है, इसलिए ये ज़्यादा वॉल्यूम वाली एजेंट पाइपलाइन के लिए व्यावहारिक विकल्प बनते हैं।
टोकन बजट टकराव के आम लक्षण:
इनमें से कोई भी दिखे, तो अपने एजेंट लॉजिक में बग मानने से पहले समवर्ती टोकन खपत की जाँच करें।
जब आप टेक्स्ट और इमेज जनरेशन टास्क मिलाते हैं, तब मल्टी-एजेंट सेटअप ख़ास दिलचस्प हो जाते हैं। एक आम वास्तविक उपयोग: लेखों का एक बैच बनाएँ, फिर हर लेख के लिए समानांतर में अपने आप इमेज बनाएँ।
सबसे साफ़ तरीका अलग मीडिया टाइप के लिए अलग एजेंट रखना है। एक एजेंट सारी टेक्स्ट जनरेशन संभालता है। एक अलग एजेंट पूल सारी इमेज जनरेशन रिक्वेस्ट संभालता है। दोनों पूल एक साथ चलते हैं, लेकिन सीधे एक-दूसरे से इंटरैक्ट नहीं करते।
सामान्य संरचना:
यह अलगाव एक व्यावहारिक कारण से मायने रखता है: टेक्स्ट जनरेशन और इमेज जनरेशन की लेटेंसी प्रोफ़ाइल बहुत अलग है। 1000 शब्दों के लेख के लिए टेक्स्ट में शायद 8 सेकंड लगें। इमेज जनरेशन में 15 से 25 सेकंड लग सकते हैं। अगर आप उन्हें एक ही एजेंट पूल में मिला देते हैं, तो तेज़ टेक्स्ट टास्क धीमे इमेज टास्क के पीछे कतार में लगेंगे। उन्हें अलग रखने से दोनों का थ्रूपुट अधिकतम होता है।
ऐसे वर्कफ़्लो के लिए जिनमें लेखन और विज़ुअल प्रोडक्शन दोनों शामिल हों, LLM को कोऑर्डिनेटर और समर्पित इमेज मॉडल को वर्कर के रूप में इस्तेमाल करना एक बहुत प्रभावी आर्किटेक्चर है। LLM टास्क डिकम्पोज़िशन, प्रॉम्प्ट रिफ़ाइनमेंट और गुणवत्ता समीक्षा संभालता है। इमेज मॉडल असली जनरेशन करते हैं।
PicassoIA पर यह एक स्वाभाविक विभाजन में बदलता है:
💡 मल्टी-मोडल एजेंट पाइपलाइन बनाते समय प्रॉम्प्ट इंजीनियरिंग को पहली श्रेणी का काम मानें। एक LLM एजेंट को सिर्फ़ इस काम के लिए रखें कि वह कच्चे लेख के कंटेंट से इमेज प्रॉम्प्ट को रिफ़ाइन करे, फिर उन्हें इमेज मॉडल को भेजे। इस चरण से आउटपुट की गुणवत्ता काफ़ी सुधरती है।
स्टेट मल्टी-एजेंट सिस्टम की सबसे बड़ी छिपी हुई समस्या है। जो एजेंट बहुत ज़्यादा स्टेट रखते हैं, वे अप्रत्याशित हो जाते हैं। जो एजेंट बिल्कुल स्टेट नहीं रखते, वे बेकार हो जाते हैं। सबसे अच्छा संतुलन है स्टेटलेस एजेंट जिनमें कॉन्टेक्स्ट स्पष्ट रूप से इंजेक्ट होता है।
व्यवहार में इसका मतलब है:
यह पैटर्न, जिसे कभी-कभी मैसेज-पासिंग स्टाइल कहा जाता है, एजेंटों को टेस्ट, डीबग और स्केल करने में कहीं आसान बनाता है। आप किसी भी एजेंट को दूसरों को अपडेट किए बिना बदल सकते हैं, क्योंकि कोई एजेंट ऐसी स्टेट नहीं रखता जिस पर दूसरे निर्भर हों।
बचने योग्य एंटी-पैटर्न:
| एंटी-पैटर्न | क्या गलत होता है |
|---|---|
| ग्लोबल साझा dict | राइट टकराव, चुपचाप डेटा खोना |
| रनों के बीच एजेंट की "मेमोरी" | स्टेट ड्रिफ़्ट, अप्रत्याशित आउटपुट |
| हर एजेंट को पूरा बातचीत इतिहास देना | टोकन का बोझ, धीमे जवाब |
| एजेंट के अंदर हार्डकोडेड मॉडल नाम | अनम्य, मॉडल बदलना कठिन |
जब आप यह जानने में लगे हों कि बिना कोड बदले एजेंट का आउटपुट क्यों बदल गया, तो लगभग हमेशा दोषी स्टेट ड्रिफ़्ट ही होता है।
प्रोडक्शन मल्टी-एजेंट सिस्टम विफल होते हैं। नेटवर्क कॉल टाइम आउट होते हैं, मॉडल APIs एरर लौटाते हैं, और कभी-कभी कोई एजेंट ऐसा आउटपुट देता है जो आपके वैलिडेशन नियमों पर खरा नहीं उतरता। ऑर्केस्ट्रेटर में पहले दिन से रीट्राई लॉजिक बनाना, न कि बाद में जोड़ना, एक भरोसेमंद पाइपलाइन और नाज़ुक पाइपलाइन के बीच का फ़र्क है।
एक व्यावहारिक रीट्राई रणनीति:
उन रीज़निंग-भारी टास्क के लिए जहाँ एजेंट तकनीकी एरर के बजाय तार्किक रूप से गलत उत्तर देता है, Deepseek R1 को फ़ॉलबैक वैलिडेटर के रूप में इस्तेमाल करना उपयोगी है। इसकी चरण-दर-चरण रीज़निंग इसे उन तार्किक गलतियों को पकड़ने में अच्छा बनाती है जो दूसरे मॉडल छोड़ देते हैं।
रीट्राई बनाम फ़ॉलबैक:
हर विफलता उसी मॉडल के साथ रीट्राई का हकदार नहीं होती। एक फ़ॉलबैक पूल पर विचार करें जहाँ विफल टास्क किसी दूसरे मॉडल को सौंपे जाते हैं। GPT 5 Pro पर टाइम आउट होने वाला टास्क Claude 4.5 Sonnet पर सफलतापूर्वक पूरा हो सकता है, खासकर तब जब टाइम आउट कनेक्टिविटी के बजाय रीज़निंग की गहराई से हुआ हो।
Antigravity में कई एजेंट चलाना स्क्रिप्ट में और मॉडल जोड़ने का मामला नहीं है। यह पाइपलाइन में सोचने का मामला है, जहाँ हर चरण का साफ़ इनपुट, साफ़ आउटपुट और साफ़ विफलता मोड हो।
जो टीमें मल्टी-एजेंट Antigravity सेटअप से सबसे ज़्यादा फ़ायदा उठा रही हैं, वे एक सरल क्रम का पालन करती हैं:
PicassoIA का लार्ज लैंग्वेज मॉडल संग्रह इस आर्किटेक्चर की हर भूमिका के लिए ज़रूरी मॉडलों की पूरी रेंज देता है: तेज़ वर्कर, सक्षम सुपरवाइज़र और गहरे रीज़नर। चाहे आप कंटेंट प्रोडक्शन पाइपलाइन, स्वचालित रिसर्च टूल या मल्टी-मोडल क्रिएटिव वर्कफ़्लो बना रहे हों, सारे बिल्डिंग ब्लॉक उपलब्ध हैं।
आज ही PicassoIA पर अपनी पहली फ़ैन-आउट पाइपलाइन बनाकर देखें। कोई ऐसा बैच टास्क चुनें जिसे आप अभी हाथ से करते हैं, उसे Kimi K2.6 या GPT 5.1 का उपयोग करने वाले तीन समानांतर एजेंटों को सौंपें, और फ़र्क नापें। पहला नतीजा अक्सर ऑटोमेशन के बारे में आपकी सोच को हमेशा के लिए बदल देता है।
अपनी भाषा चुनें
