BroadRouter

AI कोडिंग एजेंट के एक रन की लागत: स्टेप, कॉन्टेक्स्ट और कैशिंग

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

एजेंट हर स्टेप पर अपना पूरा कॉन्टेक्स्ट दोबारा भेजता है, इसलिए इनपुट स्टेप की संख्या के वर्ग के साथ बढ़ता है: 60 स्टेप का इनपुट 30 स्टेप का लगभग 3.5 गुना होता है। बिल का ज़्यादातर फ़ैसला कैशिंग करती है; सिर्फ़ जोड़ी जाने वाली हिस्ट्री के साथ 90% से ज़्यादा इनपुट कैश्ड दर पर बिल हो सकता है। प्रति रन लागत को मासिक रन से गुणा करें और फ़्लैट सेशन से तुलना करें।

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

हर कॉल के अंदर के टोकन कहाँ से आते हैं (टूल स्कीमा, फ़ाइल पढ़ना, हिस्ट्री), इसके लिए देखें एजेंट लूप के टोकन कहाँ जाते हैं। यह पोस्ट पूरे रन के गणित के बारे में है।

एजेंट रन के दौरान कॉन्टेक्स्ट कैसे बढ़ता है?

हर कॉल में होता है:

  • एक बेस कॉन्टेक्स्ट जो हर कॉल पर भेजा जाता है: सिस्टम प्रॉम्प्ट, टूल परिभाषाएँ, rules फ़ाइलें, repo map;
  • पिछले स्टेप में जोड़ा गया सब कुछ: मॉडल के जवाब और टूल कॉल, फ़ाइलों की सामग्री और कमांड का आउटपुट;
  • नया निर्देश या टूल का नतीजा।

उस बेस कॉन्टेक्स्ट को B कहें और हर स्टेप में जुड़ने वाले टोकन को g। स्टेप 1 B भेजता है। स्टेप 2 B + g भेजता है। स्टेप n भेजता है B + (n − 1) × g। इन्हें जोड़ें तो n स्टेप का रन भेजता है:

कुल इनपुट = n × B + g × n × (n − 1) ÷ 2

दूसरा पद स्टेप की संख्या के वर्ग के साथ बढ़ता है। इसीलिए लंबे रन लोगों को चौंकाते हैं: 60 स्टेप वाले रन का आख़िरी स्टेप पहले से कहीं बड़ा होता है, और बीच का हर स्टेप सभी पिछले स्टेप का ख़र्च फिर से चुकाता है।

एक हल किया हुआ रन कैसा दिखता है?

एक एजेंट लें जिसका बेस कॉन्टेक्स्ट 15,000 टोकन है (सिस्टम प्रॉम्प्ट, दर्जन भर टूल और एक repo map)। हर स्टेप 3,000 टोकन जोड़ता है: एक फ़ाइल या टेस्ट लॉग और मॉडल का अपना जवाब। हर स्टेप 800 आउटपुट टोकन लिखता है, रीज़निंग समेत।

स्टेप कुल इनपुट आउटपुट सबसे बड़ी अकेली कॉल
10 285,000 8,000 42,000
30 1,755,000 24,000 102,000
60 6,210,000 48,000 192,000

30 से 60 स्टेप पर जाने से काम दोगुना होता है, लेकिन इनपुट लगभग 3.5 गुना। आउटपुट सिर्फ़ दोगुना होता है। इन रन में इनपुट आउटपुट का 36 से 130 गुना है, इसीलिए एजेंट के लिए इनपुट की कीमत, और कैश्ड इनपुट की कीमत, सबसे ज़्यादा मायने रखती है।

सबसे बड़ी कॉल को कॉन्टेक्स्ट विंडो में भी समाना होता है। 192,000 टोकन DeepSeek V4.1 Flash और GLM 5.3 (दोनों 1,048,576 टोकन) और Qwen3.8 27B (262,144) में समा जाते हैं। Gemma 4 VL 26B (32,768) में नहीं समाते: इस उदाहरण में सातवीं कॉल ही बहुत बड़ी हो जाती है।

कैशिंग बिल को कितना बदलती है?

प्रोवाइडर दोहराए गए प्रॉम्प्ट प्रीफ़िक्स का बिल कम कैश्ड इनपुट दर पर बनाते हैं। जो एजेंट अपनी हिस्ट्री में सिर्फ़ जोड़ता है, वह हर बार वही प्रीफ़िक्स और थोड़ा और भेजता है, इसलिए सबसे अच्छी स्थिति में सिर्फ़ पिछली कॉल के बाद जोड़े गए टोकन नए होते हैं:

नया इनपुट (सबसे अच्छी स्थिति) = B + (n − 1) × g

बाक़ी सब कैश हिट है। रन जितना लंबा होता है, कैश्ड इनपुट की हिस्सेदारी उतनी बढ़ती है:

स्टेप नया इनपुट, सबसे अच्छी स्थिति कैश्ड हिस्सेदारी
10 42,000 85%
30 102,000 94%
60 192,000 97%

असली एजेंट शायद ही सबसे अच्छी स्थिति तक पहुँचते हैं, इसलिए तीन स्थितियों की कीमत निकालना उपयोगी है। BroadNet की DeepSeek V4.1 Flash कीमतों पर (प्रति 1M टोकन $0.175 इनपुट, $0.0055 कैश्ड, $0.52 आउटपुट, 2026-11-14 को प्रकाशित), यह रही हर रन की लागत, 30 स्टेप की सबसे अच्छी स्थिति के सापेक्ष:

स्टेप सबसे अच्छा कैश 80% कैश्ड कोई कैश नहीं
10 0.33× 0.39× 1.37×
30 1× 2.07× 8.11×
60 2.33× 6.84× 28.2×

दो बातें सामने आती हैं। बिना कैश के 60 स्टेप का रन अच्छी तरह कैश हुए 30 स्टेप के रन का 28 गुना पड़ता है। और रन जितना लंबा होता है, कैशिंग उतनी ज़्यादा मायने रखती है। 30 स्टेप की सबसे अच्छी स्थिति में आउटपुट लागत का लगभग एक-तिहाई है, नया इनपुट आधे से कम और कैश्ड इनपुट एक-चौथाई से कम, इसलिए कैशिंग के बाद अगली बचत आउटपुट में है।

कैशिंग कोई स्विच नहीं जिसे आप चालू कर दें। यह इस पर निर्भर है कि प्रोवाइडर प्रीफ़िक्स को रखे और आपका एजेंट उसे न बदले। OpenAI का गाइड न्यूनतम कैश होने लायक लंबाई के साथ सटीक प्रीफ़िक्स मिलान बताता है। DeepSeek का अपना API हर अनुरोध के इनपुट और आउटपुट के अंत में कैश यूनिट स्टोर करता है, इसलिए पिछले अनुरोध को आगे बढ़ाने वाला अगला अनुरोध हिट कर सकता है। BroadNet का प्राइसिंग पेज कहता है कि कैश्ड इनपुट के लिए कोई सेटअप नहीं चाहिए, और उसके डॉक्स हिट को usage.prompt_tokens_details.cached_tokens में बताते हैं, जब मॉडल यह जानकारी देता है। BroadNet का मॉडल कैटलॉग DeepSeek V4.1 Flash को “models we never ran on our hardware” (अनुवाद: वे मॉडल जिन्हें हमने कभी अपने हार्डवेयर पर नहीं चलाया) में रखता है, और उसकी शर्तें (§7.3) इस मॉडल को “when partner-hosted” (अनुवाद: जब पार्टनर द्वारा होस्ट हो) कवर करती हैं, इसलिए BroadNet पर यह एक पार्टनर के ज़रिए सर्व होता है। DeepSeek के अपने आँकड़े मानकर चलने के बजाय अपनी हिट दर मापें। प्रीफ़िक्स ऐसे लिखें कि वह कैश हो सके: कैशिंग के लिए प्रॉम्प्ट की बनावट।

अपने रन का अनुमान कैसे लगाएँ?

यह स्क्रिप्ट BroadNet की सार्वजनिक pricing.json से मौजूदा कीमतें पढ़ती है, इसलिए कभी पुरानी नहीं होती, और हर कैश स्थिति के लिए टोकन का कुल और प्रति रन लागत छापती है:

import json, urllib.request

PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]

def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
    total_in = steps * base + growth * steps * (steps - 1) // 2
    if cache_rate is None:                      # best case: only new tokens miss
        new_in = base + (steps - 1) * growth
    else:
        new_in = round(total_in * (1 - cache_rate))
    return total_in, new_in, steps * out_per_step

def run_cost(total_in, new_in, out):
    return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6

for steps in (10, 30, 60):
    for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
        t, n, o = run_tokens(steps, cache_rate=rate)
        print(f"{steps:>3} steps  cache {label:>4}  input {t:>9,}  new {n:>9,}  "
              f"output {o:>6,}  cost/run {run_cost(t, n, o):.4f} USD")

डिफ़ॉल्ट को अपने आँकड़ों से बदलें। उनका अंदाज़ा न लगाएँ; उन्हें एक असली रन से पढ़ें:

  1. हर कॉल के लिए prompt_tokens, prompt_tokens_details.cached_tokens और completion_tokens लॉग करें, जैसे एजेंट टोकन बजट पोस्ट में है।
  2. B पहली कॉल का prompt_tokens है। g एक कॉल से अगली कॉल तक prompt_tokens में औसत बढ़त है।
  3. प्रति स्टेप आउटपुट औसत completion_tokens है। इसमें रीज़निंग टोकन शामिल हैं, जिनका बिल आउटपुट के रूप में बनता है।
  4. आपकी असली कैश दर = cached_tokens का जोड़ ÷ prompt_tokens का जोड़।

मुफ़्त एजेंट रन कॉस्ट एस्टिमेटर यही हिसाब आपके ब्राउज़र में चलाता है, ताकि आप बिना कोड के दूसरी स्टेप संख्या, बढ़त दर और कैश दर आज़मा सकें।

किस वजह से रन अनुमान से ज़्यादा महँगा पड़ता है?

  • रीट्राई। फ़ेल हुई टूल कॉल या 429 पर रीट्राई एक और पूरे कॉन्टेक्स्ट वाली कॉल है। इन्हें स्टेप के रूप में गिनें।
  • प्रीफ़िक्स बदलना। सिस्टम प्रॉम्प्ट में टाइमस्टैम्प, अलग क्रम में सूचीबद्ध टूल, या रन के बीच एडिट की गई rules फ़ाइल, बदलाव वाली जगह से आगे कैश्ड इनपुट को फिर से नए इनपुट में बदल देती है।
  • संक्षेपण (compaction)। हिस्ट्री का सारांश बनाने से कॉन्टेक्स्ट छोटा होता है, जिससे बाद का इनपुट घटता है, लेकिन नई हिस्ट्री कभी कैश नहीं हुई, इसलिए अगली कॉल पूरी इनपुट कीमत चुकाती है। संक्षेपण कभी-कभार और बड़े स्टेप में करें; कब करें, यह लंबे चलने वाले एजेंट के लिए कॉन्टेक्स्ट मैनेजमेंट में है।
  • बड़ा टूल आउटपुट। स्टेप 5 पर जोड़ा गया 20,000 लाइन का टेस्ट लॉग हर अगले स्टेप के साथ चलता है। फ़ॉर्मूले में यह 20,000 × (बचे हुए स्टेप) इनपुट टोकन जोड़ता है।
  • रीज़निंग effort। ऊँचा effort प्रति स्टेप आउटपुट को कई गुना कर सकता है। रूटीन एडिट के लिए reasoning_effort को low पर सेट करें।
  • भटकना। जो एजेंट 30 स्टेप के टास्क के लिए 60 स्टेप लेता है, वह दोगुना नहीं, वर्ग चुकाता है। स्टेप की सीमा लागत की सीमा है। कोडिंग एजेंट की लागत घटाने के दस तरीक़े में ये लीवर हैं।

फ़्लैट सेशन प्रति-टोकन बिलिंग से कब बेहतर है?

प्रति रन लागत को मासिक आँकड़े में बदलें: मासिक लागत = प्रति रन लागत × प्रति माह रन। फिर उसकी तुलना फ़्लैट प्लान से करें। BroadNet पर प्लान DeepSeek V4.1 Flash को बिना टोकन मीटर के कवर करते हैं: Full Moon $60 प्रति माह, Orbit $15 प्रति हफ़्ता और Meteor $1 प्रति घंटा, हर एक प्रति सेशन।

ब्रेक-ईवन के लिए प्रति माह रन = प्लान की कीमत ÷ प्रति रन लागत।

दो चीज़ें इस तुलना को दिखने से कम सीधा बनाती हैं:

  1. आपकी कैश दर प्रति-टोकन पक्ष तय करती है। ऊँची कैश दर के साथ Flash पर प्रति-टोकन बिलिंग सस्ती है, और $60 पार करने के लिए कई रन चाहिए। ख़राब कैश दर के साथ आप उसे जल्दी पार कर लेते हैं। फ़्लैट-रेट वाली पोस्ट ब्रेक-ईवन को मासिक वॉल्यूम के रूप में दिखाती है: 80% कैश्ड पर लगभग 917 मिलियन इनपुट और 46 मिलियन आउटपुट टोकन (ब्रेक-ईवन का हिसाब)।
  2. समय फ़्लैट पक्ष की ऊपरी सीमा तय करता है। एक सेशन एक समय में एक अनुरोध चलाता है। अगर एक कॉल औसतन 20 सेकंड लेती है (prefill, लगभग 100 टोकन प्रति सेकंड पर लगभग 800 आउटपुट टोकन, और टूल का समय), तो 30 स्टेप का रन लगभग 10 मिनट लेता है। तब एक सेशन में घंटे में ज़्यादा से ज़्यादा लगभग छह रन समाते हैं। ज़्यादा पैरेलल एजेंट को ज़्यादा सेशन चाहिए।

छोटे उछाल के लिए Meteor छोटे पैमाने पर इसी तरह काम करता है: अगर घंटे में छह रन समाते हैं, तो हर एक की लागत $1 ÷ 6 है। इसकी तुलना स्क्रिप्ट से निकली एक रन की प्रति-टोकन लागत से करें। अपने वॉल्यूम आज़माने के लिए फ़्लैट रेट बनाम प्रति टोकन कैलकुलेटर इस्तेमाल करें।

आपका पैटर्न आम तौर पर सस्ता
दिन में कुछ छोटे रन प्रति टोकन
ख़राब कैशिंग वाले लंबे रन फ़्लैट सेशन
कामकाजी दिन के ज़्यादातर हिस्से चलने वाले एजेंट फ़्लैट सेशन
दिन भर पैरेलल में कई एजेंट हर एजेंट के लिए एक फ़्लैट सेशन
BroadNet पर नेटिव टूल कॉलिंग चाहिए GLM 5.3 या Qwen3.8 27B पर प्रति टोकन

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

BroadNet usage ब्लॉक में कैश्ड और रीज़निंग टोकन बताता है, इसलिए आप ऊपर का हर आँकड़ा अपने रन से माप सकते हैं। DeepSeek V4.1 Flash की कैश्ड-इनपुट कीमत कम है और कॉन्टेक्स्ट 1,048,576 टोकन, और अनलिमिटेड प्लान इसका टोकन मीटर हटा देते हैं; सेशन कैसे काम करते हैं।

पहले एक सीमा जाँच लें। BroadNet के डॉक्स टूल कॉलिंग सिर्फ़ GLM 5.3 और Qwen3.8 27B के लिए सूचीबद्ध करते हैं, और इनमें से कोई भी फ़्लैट प्लान पर नहीं है। टेक्स्ट से एडिट करने वाले एजेंट, जैसे Aider, को नेटिव टूल कॉल की ज़रूरत नहीं। अगर आपके एजेंट को है, तो प्लान ख़रीदने से पहले DeepSeek V4.1 Flash को अपने एजेंट के साथ परखें, या GLM या Qwen का बजट प्रति टोकन रखें। और अगर आपका एजेंट सिर्फ़ कभी-कभार चलता है, तो प्रति टोकन भुगतान आम तौर पर किसी भी फ़्लैट प्लान से कम पड़ेगा।

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

AI कोडिंग एजेंट के एक रन की लागत कितनी होती है?

पहले टोकन गिनें, फिर उनकी कीमत लगाएँ। इस पोस्ट के उदाहरण में 15,000 टोकन के बेस कॉन्टेक्स्ट और हर स्टेप पर 3,000 जोड़े गए टोकन वाला 30 स्टेप का रन 1,755,000 इनपुट टोकन और 24,000 आउटपुट टोकन भेजता है। इसकी लागत ज़्यादातर इस पर निर्भर है कि इनपुट का कितना हिस्सा कैश्ड दर पर बिल होता है।

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

हर स्टेप अपने से पहले का सब कुछ दोबारा भेजता है। प्रति स्टेप इनपुट सीधी रेखा में बढ़ता है, इसलिए पूरे रन का कुल स्टेप की संख्या के वर्ग के साथ बढ़ता है। हल किए हुए उदाहरण में रन को 30 से 60 स्टेप करने पर इनपुट लगभग 3.5 गुना हो जाता है।

कोडिंग एजेंट से कितनी कैश हिट दर की उम्मीद करूँ?

यह एजेंट और प्रोवाइडर पर निर्भर है। सख़्ती से सिर्फ़ जोड़ी जाने वाली हिस्ट्री में सिर्फ़ सबसे नए टोकन मिस होते हैं, जिससे हमारे उदाहरणों में 85% से 97% मिला। एडिट की गई हिस्ट्री, सिस्टम प्रॉम्प्ट में टाइमस्टैम्प और लंबे ठहराव इसे घटाते हैं। इसे prompt_tokens_details.cached_tokens से मापें।

एजेंट के लिए फ़्लैट सेशन प्रति-टोकन बिलिंग से कब सस्ता है?

जब प्रति रन लागत × प्रति माह रन प्लान की कीमत से ज़्यादा हो। BroadNet पर DeepSeek V4.1 Flash के लिए Full Moon हर सेशन $60 प्रति माह का है। हल्का या कभी-कभार उपयोग आम तौर पर प्रति टोकन सस्ता पड़ता है।

क्या रीज़निंग टोकन अनुमान बदलते हैं?

हाँ। उनका बिल आउटपुट के रूप में बनता है, और आउटपुट प्रति टोकन इनपुट से महँगा है। जो रीज़निंग आप मापते हैं, उसे प्रति स्टेप आउटपुट में जोड़ें। BroadNet पर completion_tokens_details.reasoning_tokens इसे बताता है, जब मॉडल यह जानकारी देता है।

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