एजेंट फ़्रेमवर्क एक असिस्टेंट से कई तक पहुँच गए हैं: एक ऑर्केस्ट्रेटर जो योजना बनाता है, सब-एजेंट जो कोड लिखते हैं, उसका रिव्यू करते हैं और टेस्ट चलाते हैं, और बैच वर्कर जो बैकलॉग निपटाते हैं। प्रति-टोकन API पर इनमें से हर एक बिल बढ़ाता है। फ़्लैट-रेट API पर सवाल बदल जाता है: एक ही पल में कितनी चीज़ें मॉडल को कॉल कर रही हैं?
फ़्लैट-रेट सेशन में क्या शामिल है?
BroadNet के अनलिमिटेड प्लान सेशन बेचते हैं। एक सेशन एक समय में एक अनुरोध चलाता है, अनलिमिटेड DeepSeek V4.1 Flash टोकन के साथ, बिना rolling window या साप्ताहिक सीमा के। यह एक एजेंट के काम करने के तरीक़े से मेल खाता है: वह अनुरोध भेजता है, जवाब पढ़ता है, कोई टूल चलाता है, और अगला अनुरोध भेजता है।
| सेटअप | पीक पर चलते अनुरोध | सेशन |
|---|---|---|
| एक टर्मिनल में एक कोडिंग एजेंट | 1 | 1 |
| ऑर्केस्ट्रेटर + 3 सब-एजेंट | 4 | 4 |
| 10 बैच वर्कर | 10 | 10 |
| 2 डेवलपर, हर एक का 1 एजेंट | 2 | 2 (हर एक अपने अकाउंट पर) |
हर Full Moon सेशन $60 प्रति माह का है। एक key में कई सेशन रह सकते हैं, या आप किसी प्लान के सेशन उसकी keys में बाँट सकते हैं, जैसे हर सर्वर या हर प्रोजेक्ट के लिए एक key, ताकि लीक हुई या रद्द की गई key सिर्फ़ अपने पीछे के एजेंट रोके। key और अकाउंट व्यक्तिगत हैं: आप प्लान को अपने प्रोडक्ट में इस्तेमाल कर सकते हैं, लेकिन key साझा नहीं कर सकते और न दोबारा बेच सकते हैं। सेशन के पूरे नियम।
पैरेलल एजेंट को कितने सेशन चाहिए?
एजेंट बहुत समय मॉडल को कॉल नहीं करते: टेस्ट चलाते हैं, फ़ाइलें पढ़ते हैं, बिल्ड का इंतज़ार करते हैं। चार सब-एजेंट, जिनमें से हर एक 40% समय मॉडल को कॉल करता है, शायद ही कभी एक साथ उसकी ज़रूरत पड़ती है। चार सेशन ख़रीदने से पहले:
- आपका फ़्रेमवर्क जो भी मॉडल अनुरोध करता है, हर एजेंट के लिए उसका शुरू और ख़त्म होने का समय लॉग करें।
- हर मिनट में एक साथ चलने वाले अनुरोधों की अधिकतम संख्या गिनें।
- सबसे ऊँचे पीक के लिए नहीं, उस ओवरलैप के लिए सेशन ख़रीदें जो ज़्यादातर समय होता है, और बाक़ी को अपने कोड में कतार में लगाएँ (नीचे semaphore देखें)। BroadNet के पेज यह नहीं बताते कि सीमा से ऊपर का अनुरोध इंतज़ार करता है या लौटा दिया जाता है, इसलिए एजेंट को उसे आँख मूँदकर न भेजने दें।
उदाहरण के लिए, अगर आपके लॉग दिखाते हैं कि ज़्यादातर समय दो अनुरोध चलते हैं और चार सिर्फ़ छोटे उछाल में, तो दो सेशन और क्लाइंट-साइड कतार सस्ता सेटअप हो सकता है।
एक छोटी स्क्रिप्ट गिनती कर देती है। आपके लॉग से सेकंड में (start, end) समय की सूची दी गई हो तो:
from collections import Counter
def overlap_histogram(requests):
events = sorted([(s, 1) for s, _ in requests] + [(e, -1) for _, e in requests])
in_flight, last_t, seconds_at = 0, None, Counter()
for t, delta in events:
if last_t is not None:
seconds_at[in_flight] += t - last_t
in_flight += delta
last_t = t
return dict(sorted(seconds_at.items())) # {requests in flight: seconds}
अगर नतीजा दिखाए कि ज़्यादातर समय एक या दो अनुरोध चलते हैं, तो दो सेशन ख़रीदें। अगर घंटों तक चार पर टिका रहे, तो चार ख़रीदें।
किस एजेंट पैटर्न को कितने सेशन चाहिए?
| पैटर्न | मॉडल को कैसे कॉल करता है | साइज़ तय करने का नियम |
|---|---|---|
| ऑर्केस्ट्रेटर + वर्कर | प्लानर कॉल करता है, फिर काम फैलाता है | साथ चलने वाले वर्कर, और प्लानर काम करता रहे तो उसके लिए एक |
| पाइपलाइन (लिखना → रिव्यू → टेस्ट) | हर टास्क में एक समय में एक चरण | पैरेलल चल रहे हर टास्क के लिए एक सेशन |
| बैच बैकलॉग | कई एक जैसे जॉब | हर वर्कर के लिए एक सेशन; ज़्यादा वर्कर जल्दी ख़त्म करते हैं |
| कई डेवलपर के एजेंट | स्वतंत्र | हर डेवलपर के लिए एक सेशन, हर एक अपने अकाउंट पर |
पैरेलल एजेंट को एक-दूसरे के रास्ते से कैसे दूर रखें?
मॉडल की क्षमता सिर्फ़ आधी समस्या है। एक ही फ़ाइल एडिट करने वाले दो एजेंट एक-दूसरे का काम मिटा देंगे। आम हल है हर एजेंट के लिए एक git worktree: हर एक को उसी रिपॉज़िटरी से अपना चेकआउट और ब्रांच मिलता है।
git worktree add ../agent-auth -b agent/auth
git worktree add ../agent-billing -b agent/billing
फिर टास्क को मॉड्यूल के हिसाब से बाँटें, ताकि एजेंट कम ही एक जैसी फ़ाइलें छुएँ, और रिव्यू स्टेप से मर्ज करें। उन्हें बिना निगरानी चलाने के लिए देखें रात भर कोडिंग एजेंट चलाना; अतिरिक्त एजेंट टोकन में कितना ख़र्च करते हैं, इसके लिए देखें मल्टी-एजेंट लागत।
पैरेलल एजेंट के लिए उपयोग के अनुसार भुगतान कब बेहतर है?
उपयोग के अनुसार भुगतान वाली key 4 चलते अनुरोध और प्रति मिनट 30 अनुरोध की अनुमति देती है। यह छोटे, अचानक उछलने वाले फ़ैन-आउट के लिए ठीक है: एक रिव्यू स्टेप जो बीस सेकंड के लिए चार चेकर शुरू करता है, फिर शांत हो जाता है। स्थिर लोड सेशन के लिए ठीक है, और उछाल वाला लोड प्रति-टोकन बिलिंग के लिए। कई सेटअप दोनों इस्तेमाल करते हैं: लंबे चलने वाले एजेंट के लिए प्लान सेशन, और उछाल व GLM 5.3 जैसे दूसरे मॉडल के लिए उपयोग के अनुसार भुगतान वाली key।
जब उपयोग के अनुसार भुगतान वाली key अपनी रेट लिमिट या concurrency सीमा पर पहुँचती है, तो वह 429 लौटाती है। रुकें और रीट्राई करें; देखें एरर कोड और कब रीट्राई करें। रेट लिमिट कैलकुलेटर दिखाता है कि आपके अनुरोध पैटर्न के लिए कोई सीमा कितनी दूर तक चलती है।
एजेंट को प्लान से कैसे जोड़ें?
ज़्यादातर एजेंट फ़्रेमवर्क OpenAI-कम्पैटिबल base URL लेते हैं। हर एजेंट को मॉडल broadnet/deepseek-v4.1-flash के साथ https://inference.broadnet.ai/v1 पर पॉइंट करें और हर एक को key दें:
export OPENAI_BASE_URL="https://inference.broadnet.ai/v1"
export OPENAI_API_KEY="$BROADNET_PLAN_KEY"
एक टर्मिनल कोडिंग एजेंट के लिए Aider गाइड में सटीक सेटिंग हैं; Cline और OpenCode के अपने गाइड हैं। अपने ख़ुद के ऑर्केस्ट्रेटर के लिए OpenAI Python SDK गाइड क्लाइंट सेटअप दिखाता है। अपने कोड में चलते अनुरोधों को सेशन की संख्या तक सीमित रखें, ताकि वे आपकी तरफ़ कतार में लगें, जहाँ आप उन्हें देख सकें:
import asyncio
SESSIONS = 4
gate = asyncio.Semaphore(SESSIONS)
async def ask(client, messages):
async with gate:
return await client.chat.completions.create(
model="broadnet/deepseek-v4.1-flash", messages=messages, max_tokens=4000)
पैरेलल एजेंट के साथ क्या ग़लत होता है?
- हर एजेंट को एक साथ शुरू करना। एक साथ आई पहली कॉल की बौछार तुरंत आपके सेशन से ज़्यादा हो जाती है। शुरुआत को कुछ सेकंड के अंतर पर रखें।
- रीट्राई का तूफ़ान। अगर हर एजेंट एक ही पल में रीट्राई करे, तो वे फिर टकराते हैं। backoff में jitter जोड़ें।
- बहुत कम
max_tokens। DeepSeek V4.1 Flash जवाब से पहले रीज़निंग करता है; छोटी सीमा ख़ाली जवाब लौटा सकती है। क्यों। - एक key कई लोगों में साझा करना। key व्यक्तिगत हैं। हर डेवलपर को उसका अपना अकाउंट दें।
हर एजेंट कितना कॉन्टेक्स्ट इस्तेमाल कर सकता है?
DeepSeek V4.1 Flash पर हर अनुरोध में 1,048,576 टोकन तक हो सकते हैं। सब-एजेंट छोटे किए गए सारांश के बजाय वह पूरा मॉड्यूल पढ़ सकता है जिस पर वह काम कर रहा है, और प्लान पर लंबा प्रॉम्प्ट अतिरिक्त ख़र्च नहीं लेता। 1M-टोकन विंडो कब काम आती है।
सेटअप को सस्ते में कैसे परखें?
जितने सेशन आपको लगता है कि चाहिए, हर एक के लिए एक Meteor घंटा ($1) ख़रीदें, और अपना असली एजेंट वर्कफ़्लो चलाएँ। अगर एजेंट बार-बार एक-दूसरे का इंतज़ार करें, तो एक सेशन जोड़ें। अगर कोई ख़ाली बैठा रहे, तो उसे हटा दें। फिर Full Moon या हफ़्ते भर वाले Orbit सेशन (हर एक $15) पर जाएँ।
BroadNet Inference कहाँ फ़िट होता है
प्लान सेशन एक मॉडल पर स्थिर, पैरेलल एजेंट के लिए ठीक हैं, क्योंकि बिल इस पर निर्भर करता है कि एक साथ कितने चलते हैं, न कि वे कितना पढ़ते हैं। अगर आपके एजेंट को कई अलग मॉडल चाहिए, या वे मॉडल को सिर्फ़ छोटे उछाल में कॉल करते हैं, तो उपयोग के अनुसार भुगतान वाली key या कोई राउटर कम ख़र्चीला हो सकता है। पहले ब्रेक-ईवन के हिसाब से तुलना करें।
