BroadRouter

एजेंट टोकन बजट: एजेंट लूप के टोकन कहाँ जाते हैं

BroadNet Inference टीम · 5 मिनट में पढ़ें · प्रकाशित

एजेंट लूप हर कॉल पर अपना पूरा कॉन्टेक्स्ट दोबारा भेजता है: सिस्टम प्रॉम्प्ट, टूल परिभाषाएँ, बातचीत की हिस्ट्री, फ़ाइलों की सामग्री और टूल आउटपुट, साथ में नया स्टेप। इनपुट आम तौर पर आउटपुट से कई गुना भारी होता है। हर कॉल के prompt_tokens, cached_tokens और completion_tokens लॉग करें, सबसे बड़ा दोहराया जाने वाला हिस्सा खोजें, फिर टूल घटाएँ, टूल आउटपुट पर सीमा लगाएँ और लंबे सेशन दोबारा शुरू करें।

चैट की लागत होती है जो आप टाइप करते हैं, और जो मॉडल लिखता है। एजेंट की लागत इससे कहीं ज़्यादा होती है, क्योंकि वह मॉडल को दर्जनों बार कॉल करता है और हर बार लगभग सब कुछ दोबारा भेजता है। अगर आप यह लागत घटाना चाहते हैं, या बस कॉन्टेक्स्ट विंडो की सीमा से टकराना बंद करना चाहते हैं, तो आपको पता होना चाहिए कि हर अनुरोध का कौन-सा हिस्सा बड़ा है। यह पोस्ट एजेंट लूप को पाँच हिस्सों में बाँटती है, API के अपने usage डेटा से हर हिस्सा मापने का तरीक़ा दिखाती है, और बताती है कि पहले क्या घटाएँ।

एजेंट सब कुछ दोबारा क्यों भेजता है?

चैट कम्प्लीशन API स्टेटलेस हैं। मॉडल को कॉल के बीच कुछ याद नहीं रहता, इसलिए एजेंट हर स्टेप पर पूरा कॉन्टेक्स्ट भेजता है। 40 स्टेप वाला टास्क, जिसमें हर कॉल 30,000 टोकन ले जाती है, शायद 40,000 आउटपुट टोकन बनाने के लिए 12 लाख इनपुट टोकन पढ़ता है। यही 30-से-1 का अनुपात वजह है कि एजेंट के बिल में इनपुट टोकन और उनकी कैश कीमत हावी रहती है।

टोकन कहाँ जाते हैं?

हिस्सा यह क्या है हर कॉल पर दोहराया जाता है? आम वजह
सिस्टम प्रॉम्प्ट एजेंट के निर्देश, rules फ़ाइलें, प्रोजेक्ट नोट्स हाँ लंबी rules फ़ाइलें
टूल स्कीमा हर टूल का नाम, विवरण और JSON Schema हाँ बिल्ट-इन टूल और हर MCP सर्वर
हिस्ट्री पिछले संदेश, टूल कॉल और नतीजे हाँ, और बढ़ती है लंबे सेशन
फ़ाइल पढ़ना और टूल आउटपुट फ़ाइलों की सामग्री, टेस्ट लॉग, खोज के नतीजे हाँ, हटाए जाने तक पूरी फ़ाइलें पढ़ना, लंबा-चौड़ा आउटपुट देने वाली कमांड
आउटपुट दिखने वाला जवाब, टूल कॉल और रीज़निंग नहीं रीज़निंग effort, पूरी फ़ाइलें दोबारा लिखना

पहले दो तय ओवरहेड हैं। Cursor ने सितंबर 2026 में लिखा कि सिस्टम प्रॉम्प्ट और टूल परिभाषाएँ “had become one of the largest sources of spend that we fully control” (अनुवाद: हमारे पूरे नियंत्रण वाले ख़र्च के सबसे बड़े स्रोतों में से एक बन गए थे), और फ़ाइल पढ़ने को “another large source of token spend” (अनुवाद: टोकन ख़र्च का एक और बड़ा स्रोत) कहा। उसके बदलावों ने, जिनमें सिस्टम प्रॉम्प्ट का लगभग दो-तिहाई हिस्सा हटाना और 20% से कम बातचीत में इस्तेमाल होने वाले टूल को सिर्फ़ ज़रूरत पड़ने पर लोड करना शामिल था, यूज़र्स की टोकन लागत 7% घटाई। GitHub की VS Code टीम ने Copilot के लिए यही दो लागतें बताईं: दोहराया जाने वाला प्रॉम्प्ट प्रीफ़िक्स और टूल परिभाषाओं का ओवरहेड।

इसे कैसे मापें?

आपको किसी ट्रेसिंग प्रोडक्ट की ज़रूरत नहीं। हर जवाब का usage ब्लॉक काफ़ी है।

  1. usage चालू करें। स्ट्रीमिंग में stream_options: {"include_usage": true} जोड़ें; usage आख़िरी चंक में आता है। देखें स्ट्रीमिंग।
  2. हर कॉल पर लॉग करें: स्टेप नंबर, prompt_tokens, prompt_tokens_details.cached_tokens, completion_tokens और, जब बताया जाए, completion_tokens_details.reasoning_tokens।
  3. तय ओवरहेड एक बार मापें। सिर्फ़ सिस्टम प्रॉम्प्ट, टूल और “hi” शब्द के साथ एक अनुरोध भेजें। उसका prompt_tokens आपका न्यूनतम स्तर है।
  4. टूल का आउटपुट मापें। हर टूल नतीजे को जोड़ने से पहले उसके अक्षर गिनें। चार से भाग देने पर अंग्रेज़ी टोकन की मोटी गिनती मिलती है; अपने मॉडल के tokenizer पर सटीक आँकड़े के लिए एक नमूना मुफ़्त टोकन काउंटर में चिपकाएँ।
r = client.chat.completions.create(model=MODEL, messages=msgs, tools=tools)
u = r.usage
cached = getattr(u.prompt_tokens_details, "cached_tokens", 0) or 0
log.info("step=%d prompt=%d cached=%d out=%d", step, u.prompt_tokens, cached, u.completion_tokens)

prompt_tokens को स्टेप के हिसाब से प्लॉट करें। स्थिर ढलान का मतलब है हिस्ट्री बढ़ रही है। अचानक उछाल का मतलब है कोई बड़ी फ़ाइल या लॉग कॉन्टेक्स्ट में आया। ऊँचा न्यूनतम स्तर मतलब बहुत ज़्यादा टूल।

Aider में /tokens बताता है कि मौजूदा कॉन्टेक्स्ट में क्या है, और /drop उसमें से फ़ाइलें हटाता है।

पहले क्या घटाएँ?

जो सबसे आसान है उसके हिसाब से नहीं, आकार गुणा दोहराव के क्रम में:

  1. बिना इस्तेमाल वाले टूल। हर टूल स्कीमा हर कॉल के साथ जाता है। OpenAI का गाइड कहता है कि फ़ंक्शन परिभाषाएँ “are billed as input tokens” (अनुवाद: इनपुट टोकन के रूप में बिल होती हैं) और टर्न की शुरुआत में 20 से कम फ़ंक्शन का सुझाव देता है, एक ढीले नियम के रूप में। जो MCP सर्वर इस टास्क में इस्तेमाल नहीं हो रहे, उन्हें बंद करें; opencode के डॉक्स साफ़ कहते हैं कि MCP टूल मॉडल का कॉन्टेक्स्ट खाते हैं।
  2. टूल आउटपुट। कमांड के आउटपुट पर सीमा लगाएँ (टेस्ट लॉग की आख़िरी 200 लाइनें, 20,000 नहीं)। खोज के नतीजे पाथ और लाइन नंबर के रूप में लौटाएँ, फिर सिर्फ़ ज़रूरी हिस्सा पढ़ें।
  3. फ़ाइल पढ़ना। फ़ाइल नहीं, फ़ंक्शन पढ़ें। Aider का repo map पूरी फ़ाइलों के बजाय डिफ़ॉल्ट 1k-टोकन बजट (--map-tokens) इस्तेमाल करता है।
  4. हिस्ट्री। हर बदलाव के लिए नया टास्क शुरू करें। अगर सेशन जारी रखना ही है, तो पुराने टर्न को छोटे सारांश से बदल दें।
  5. सिस्टम प्रॉम्प्ट। वे नियम हटाएँ जिनका मॉडल पहले से पालन करता है। बाक़ी को स्थिर रखें।
  6. आउटपुट। पूरी फ़ाइलें नहीं, diff माँगें। रूटीन स्टेप के लिए reasoning_effort को low पर सेट करें। रीज़निंग टोकन का बिल आउटपुट के रूप में बनता है।

प्रीफ़िक्स स्थिर क्यों रखें?

प्रोवाइडर दोहराए गए प्रीफ़िक्स को कैश करते हैं और उसका बिल कम दर पर बनाते हैं। BroadNet Inference पर DeepSeek V4.1 Flash कैश्ड इनपुट का बिल प्रति 1M टोकन $0.0055 पर और नए इनपुट का $0.175 पर बनाता है। GLM 5.3 $0.173 बनाम $0.78 लेता है। सिस्टम प्रॉम्प्ट में टाइमस्टैम्प, या हर कॉल में अलग क्रम में सूचीबद्ध टूल, उस जगह से आगे कैश तोड़ देते हैं। स्थिर हिस्से पहले, तय क्रम में रखें, और बदलने वाले हिस्से आख़िर में। ज़्यादा जानकारी कैश्ड इनपुट टोकन की व्याख्या में है; प्रॉम्प्ट कैशिंग कैलकुलेटर दिखाता है कि कोई ख़ास हिट दर कितना बचाती है।

कैशिंग प्रीफ़िक्स की कीमत घटाती है, उसका आकार नहीं। कैश्ड टोकन तब भी कॉन्टेक्स्ट विंडो भरते हैं और प्रोसेस होने में समय लेते हैं।

एक हल किया हुआ एजेंट बजट कैसा दिखता है?

ऊपर वाला 40 स्टेप का टास्क लें, जिसका 80% इनपुट कैश्ड है:

हिस्सा टोकन किस दर पर बिल
नया इनपुट 240,000 इनपुट कीमत
कैश्ड इनपुट 960,000 कैश्ड इनपुट कीमत
रीज़निंग समेत आउटपुट 40,000 आउटपुट कीमत

हर कॉल से बिना इस्तेमाल वाले टूल स्कीमा के 5,000 टोकन हटाने पर इस टास्क से 200,000 इनपुट टोकन कम हो जाते हैं, कुल का लगभग छठा हिस्सा, और एजेंट के व्यवहार में कोई बदलाव नहीं। घटाने के अलावा लागत के दूसरे लीवर, जैसे मॉडल का चुनाव, कैशिंग और फ़्लैट प्लान, के लिए देखें कोडिंग एजेंट की LLM लागत घटाने के 10 तरीक़े। मल्टी-एजेंट सेटअप के लिए एजेंट की संख्या से गुणा करें; देखें मल्टी-एजेंट सेटअप की लागत। अपने लूप को स्टेप दर स्टेप मॉडल करने के लिए एजेंट रन कॉस्ट एस्टिमेटर इस्तेमाल करें।

BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference usage ब्लॉक में प्रॉम्प्ट और कम्प्लीशन टोकन लौटाता है, और मॉडल बताए तो कैश्ड व रीज़निंग टोकन भी, इसलिए ऊपर का मापने का तरीक़ा जैसा लिखा है वैसा ही काम करता है। DeepSeek V4.1 Flash पर इसकी कम कैश्ड-इनपुट कीमत स्थिर प्रीफ़िक्स को फ़ायदा देती है। अगर घटाने में समय लगाना फ़ायदेमंद न हो, तो अनलिमिटेड प्लान DeepSeek V4.1 Flash का टोकन मीटर $60 प्रति माह प्रति सेशन पर हटा देते हैं; कॉन्टेक्स्ट विंडो की सीमा तब भी लागू है, और हल्का कॉन्टेक्स्ट तब भी तेज़ चलता है। प्लान inference.broadnet.ai/plans पर हैं।

अक्सर पूछे जाने वाले सवाल

मेरा कोडिंग एजेंट इतने ज़्यादा इनपुट टोकन क्यों इस्तेमाल करता है?

क्योंकि API स्टेटलेस है। हर कॉल सिस्टम प्रॉम्प्ट, हर टूल परिभाषा, अब तक की बातचीत और कॉन्टेक्स्ट में मौजूद सभी फ़ाइलों की सामग्री दोबारा भेजती है। लंबा सेशन इसे स्टेप की संख्या से गुणा कर देता है।

कैसे देखूँ कि एजेंट का हर स्टेप कितने टोकन इस्तेमाल करता है?

हर जवाब का usage ब्लॉक पढ़ें। स्ट्रीमिंग में stream_options include_usage को true करें और आख़िरी चंक पढ़ें। prompt_tokens, prompt_tokens_details.cached_tokens और completion_tokens को स्टेप नंबर के साथ लॉग करें।

क्या टूल परिभाषाएँ इनपुट टोकन में गिनी जाती हैं?

हाँ। टूल की सूची प्रॉम्प्ट का हिस्सा है और हर कॉल पर भेजी जाती है। MCP सर्वर अपने टूल इसी सूची में जोड़ते हैं, इसीलिए opencode के डॉक्स कहते हैं कि सिर्फ़ ज़रूरी सर्वर जोड़ें।

क्या प्रॉम्प्ट कैशिंग से समस्या हल हो जाती है?

यह दोहराए गए प्रीफ़िक्स की कीमत घटाती है, उसका आकार नहीं। कैश्ड इनपुट तब भी कॉन्टेक्स्ट विंडो भरता है। BroadNet पर DeepSeek V4.1 Flash कैश्ड इनपुट का बिल प्रति 1M टोकन $0.0055 पर बनाता है, जबकि नए इनपुट का $0.175 पर।

क्या रीज़निंग टोकन बजट का हिस्सा हैं?

हाँ, आउटपुट की तरफ़। रीज़निंग मॉडल सोच को max_tokens में गिनते हैं और उपयोग के अनुसार भुगतान पर उसका बिल आउटपुट के रूप में बनाते हैं। रूटीन स्टेप के लिए reasoning_effort को low पर सेट करें।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें