---
title: "AI कोडिंग एजेंट रन की लागत: स्टेप और कैशिंग | BroadRouter"
description: "कोडिंग एजेंट का रन जितना लंबा चलता है, हर स्टेप उतना महँगा क्यों पड़ता है, कैशिंग कुल लागत कैसे बदलती है, और फ़्लैट सेशन कब जीतता है। टोकन का पूरा हिसाब।"
url: https://broadrouter.com/hi/blog/ai-coding-agent-run-cost/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/ai-coding-agent-run-cost/) (2026-11-15 को अपडेट किया गया).

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

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

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

## मुख्य बातें

-   एक रन का कुल इनपुट = स्टेप × बेस कॉन्टेक्स्ट + प्रति स्टेप बढ़त × स्टेप × (स्टेप − 1) ÷ 2। किसी भी दूसरे इनपुट से ज़्यादा स्टेप की संख्या मायने रखती है।
-   सिर्फ़ जोड़ी जाने वाली हिस्ट्री में पिछली कॉल के बाद जोड़े गए टोकन ही नए होते हैं। हल किए हुए उदाहरण में इससे 30 स्टेप वाले रन का 94% इनपुट कैश्ड रहता है।
-   BroadNet की प्रकाशित DeepSeek V4.1 Flash कीमतों पर वही 30 स्टेप वाला रन बिना कैश के, सबसे अच्छे कैश की तुलना में लगभग 8 गुना महँगा पड़ता है।
-   शुरुआती हिस्ट्री को संक्षिप्त या एडिट करने से कैश रीसेट हो जाता है। ऐसा कभी-कभार और बड़े स्टेप में करें।
-   फ़्लैट सेशन तब जीतता है जब मासिक रन × प्रति रन लागत प्लान की कीमत से ज़्यादा हो। एक सेशन एक समय में एक अनुरोध चलाता है, इसलिए प्रति रन समय तय करता है कि महीने में कितने रन समा सकते हैं।

**इस पेज पर**

1.  एजेंट रन के दौरान कॉन्टेक्स्ट कैसे बढ़ता है?
2.  एक हल किया हुआ रन कैसा दिखता है?
3.  कैशिंग बिल को कितना बदलती है?
4.  अपने रन का अनुमान कैसे लगाएँ?
5.  किस वजह से रन अनुमान से ज़्यादा महँगा पड़ता है?
6.  फ़्लैट सेशन प्रति-टोकन बिलिंग से कब बेहतर है?
7.  BroadNet Inference कहाँ फ़िट होता है

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

हर कॉल के अंदर के टोकन कहाँ से आते हैं (टूल स्कीमा, फ़ाइल पढ़ना, हिस्ट्री), इसके लिए देखें [एजेंट लूप के टोकन कहाँ जाते हैं](https://broadrouter.com/hi/blog/agent-token-budget/)। यह पोस्ट पूरे रन के गणित के बारे में है।

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

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

-   एक **बेस कॉन्टेक्स्ट** जो हर कॉल पर भेजा जाता है: सिस्टम प्रॉम्प्ट, टूल परिभाषाएँ, 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 गुना है, इसीलिए एजेंट के लिए इनपुट की कीमत, और कैश्ड इनपुट की कीमत, सबसे ज़्यादा मायने रखती है।

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

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

प्रोवाइडर दोहराए गए प्रॉम्प्ट प्रीफ़िक्स का बिल कम [कैश्ड इनपुट](https://broadrouter.com/hi/glossary/cached-input-tokens/) दर पर बनाते हैं। जो एजेंट अपनी हिस्ट्री में सिर्फ़ जोड़ता है, वह हर बार वही प्रीफ़िक्स और थोड़ा और भेजता है, इसलिए सबसे अच्छी स्थिति में सिर्फ़ पिछली कॉल के बाद जोड़े गए टोकन नए होते हैं:

**नया इनपुट (सबसे अच्छी स्थिति) = 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 का [प्राइसिंग पेज](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-ai-coding-agent-run-cost&utm_content=body) कहता है कि कैश्ड इनपुट के लिए कोई सेटअप नहीं चाहिए, और उसके डॉक्स हिट को `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 के अपने आँकड़े मानकर चलने के बजाय अपनी हिट दर मापें। प्रीफ़िक्स ऐसे लिखें कि वह कैश हो सके: [कैशिंग के लिए प्रॉम्प्ट की बनावट](https://broadrouter.com/hi/blog/prompt-structure-for-caching/)।

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

यह स्क्रिप्ट BroadNet की सार्वजनिक [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-ai-coding-agent-run-cost&utm_content=body) से मौजूदा कीमतें पढ़ती है, इसलिए कभी पुरानी नहीं होती, और हर कैश स्थिति के लिए टोकन का कुल और प्रति रन लागत छापती है:

```python
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` लॉग करें, जैसे [एजेंट टोकन बजट पोस्ट](https://broadrouter.com/hi/blog/agent-token-budget/) में है।
2.  **B** पहली कॉल का `prompt_tokens` है। **g** एक कॉल से अगली कॉल तक `prompt_tokens` में औसत बढ़त है।
3.  प्रति स्टेप आउटपुट औसत `completion_tokens` है। इसमें [रीज़निंग टोकन](https://broadrouter.com/hi/glossary/reasoning-tokens/) शामिल हैं, जिनका बिल आउटपुट के रूप में बनता है।
4.  आपकी असली कैश दर = `cached_tokens` का जोड़ ÷ `prompt_tokens` का जोड़।

मुफ़्त [एजेंट रन कॉस्ट एस्टिमेटर](https://broadrouter.com/tools/agent-run-cost-estimator/) यही हिसाब आपके ब्राउज़र में चलाता है, ताकि आप बिना कोड के दूसरी स्टेप संख्या, बढ़त दर और कैश दर आज़मा सकें।

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

-   **रीट्राई।** फ़ेल हुई टूल कॉल या 429 पर रीट्राई एक और पूरे कॉन्टेक्स्ट वाली कॉल है। इन्हें स्टेप के रूप में गिनें।
-   **प्रीफ़िक्स बदलना।** सिस्टम प्रॉम्प्ट में टाइमस्टैम्प, अलग क्रम में सूचीबद्ध टूल, या रन के बीच एडिट की गई rules फ़ाइल, बदलाव वाली जगह से आगे कैश्ड इनपुट को फिर से नए इनपुट में बदल देती है।
-   **संक्षेपण (compaction)।** हिस्ट्री का सारांश बनाने से कॉन्टेक्स्ट छोटा होता है, जिससे बाद का इनपुट घटता है, लेकिन नई हिस्ट्री कभी कैश नहीं हुई, इसलिए अगली कॉल पूरी इनपुट कीमत चुकाती है। संक्षेपण कभी-कभार और बड़े स्टेप में करें; कब करें, यह [लंबे चलने वाले एजेंट के लिए कॉन्टेक्स्ट मैनेजमेंट](https://broadrouter.com/hi/blog/long-running-agent-context-management/) में है।
-   **बड़ा टूल आउटपुट।** स्टेप 5 पर जोड़ा गया 20,000 लाइन का टेस्ट लॉग हर अगले स्टेप के साथ चलता है। फ़ॉर्मूले में यह 20,000 × (बचे हुए स्टेप) इनपुट टोकन जोड़ता है।
-   **रीज़निंग effort।** ऊँचा effort प्रति स्टेप आउटपुट को कई गुना कर सकता है। रूटीन एडिट के लिए `reasoning_effort` को `low` पर सेट करें।
-   **भटकना।** जो एजेंट 30 स्टेप के टास्क के लिए 60 स्टेप लेता है, वह दोगुना नहीं, वर्ग चुकाता है। स्टेप की सीमा लागत की सीमा है। [कोडिंग एजेंट की लागत घटाने के दस तरीक़े](https://broadrouter.com/hi/blog/cut-coding-agent-llm-costs/) में ये लीवर हैं।

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

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

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

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

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

छोटे उछाल के लिए Meteor छोटे पैमाने पर इसी तरह काम करता है: अगर घंटे में छह रन समाते हैं, तो हर एक की लागत $1 ÷ 6 है। इसकी तुलना स्क्रिप्ट से निकली एक रन की प्रति-टोकन लागत से करें। अपने वॉल्यूम आज़माने के लिए [फ़्लैट रेट बनाम प्रति टोकन कैलकुलेटर](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) इस्तेमाल करें।

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

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

BroadNet usage ब्लॉक में कैश्ड और रीज़निंग टोकन बताता है, इसलिए आप ऊपर का हर आँकड़ा अपने रन से माप सकते हैं। DeepSeek V4.1 Flash की कैश्ड-इनपुट कीमत कम है और कॉन्टेक्स्ट 1,048,576 टोकन, और अनलिमिटेड प्लान इसका टोकन मीटर हटा देते हैं; [सेशन कैसे काम करते हैं](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/)।

पहले एक सीमा जाँच लें। BroadNet के डॉक्स टूल कॉलिंग सिर्फ़ [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) और [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) के लिए सूचीबद्ध करते हैं, और इनमें से कोई भी फ़्लैट प्लान पर नहीं है। टेक्स्ट से एडिट करने वाले एजेंट, जैसे [Aider](https://broadrouter.com/hi/guides/aider-unlimited-deepseek/), को नेटिव टूल कॉल की ज़रूरत नहीं। अगर आपके एजेंट को है, तो प्लान ख़रीदने से पहले DeepSeek V4.1 Flash को अपने एजेंट के साथ परखें, या GLM या Qwen का बजट प्रति टोकन रखें। और अगर आपका एजेंट सिर्फ़ कभी-कभार चलता है, तो प्रति टोकन भुगतान आम तौर पर किसी भी फ़्लैट प्लान से कम पड़ेगा।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[AI एजेंट (AI agent)](https://broadrouter.com/hi/glossary/agent/)

AI एजेंट ऐसा सिस्टम है जिसमें लैंग्वेज मॉडल किसी लक्ष्य की ओर अपने क़दम ख़ुद तय करता है: कौन-से टूल कॉल करने हैं, चुनता है, नतीजे पढ़ता है और अंतिम जवाब या किसी सीमा तक दोहराता रहता है। तय बिंदुओं पर मॉडल को कॉल करने वाली स्क्रिप्ट को आम तौर पर workflow कहते हैं।

[इनपुट और आउटपुट टोकन (input and output tokens)](https://broadrouter.com/hi/glossary/input-and-output-tokens/)

इनपुट टोकन वे टोकन हैं जिन्हें लैंग्वेज मॉडल किसी अनुरोध में पढ़ता है, जिनमें सिस्टम प्रॉम्प्ट, बातचीत का इतिहास, टूल डेफ़िनिशन और इमेज शामिल हैं। आउटपुट टोकन वे हैं जो वह जवाब में बनाता है, रीज़निंग समेत। LLM API आम तौर पर दोनों की कीमत अलग रखते हैं, और आउटपुट आम तौर पर महँगा होता है।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[सिस्टम प्रॉम्प्ट (system prompt)](https://broadrouter.com/hi/glossary/system-prompt/)

सिस्टम प्रॉम्प्ट वह निर्देश टेक्स्ट है जो कोई ऐप्लिकेशन बातचीत से पहले लैंग्वेज मॉडल को भेजता है, आम तौर पर system या developer रोल वाले मैसेज के रूप में। यह मॉडल की भूमिका, नियम, लहजा और आउटपुट फ़ॉर्मैट तय करता है, और टकराव होने पर मॉडल को यूज़र के मैसेज के बजाय इसी का पालन करना होता है।

[उपयोग के अनुसार भुगतान (pay-as-you-go)](https://broadrouter.com/hi/glossary/pay-as-you-go/)

उपयोग के अनुसार भुगतान (pay-as-you-go) एक प्राइसिंग मॉडल है जिसमें आप सिर्फ़ उतना देते हैं जितना इस्तेमाल करते हैं, जिसे टोकन, अनुरोध या ऑडियो मिनट जैसी इकाइयों में मापा जाता है, बिना सब्सक्रिप्शन या न्यूनतम प्रतिबद्धता के। ज़्यादातर LLM API इसी तरह बिल बनाते हैं, प्रीपेड बैलेंस या समय-समय पर बनने वाले इनवॉइस से।

[रीज़निंग टोकन (reasoning tokens)](https://broadrouter.com/hi/glossary/reasoning-tokens/)

रीज़निंग टोकन वे टोकन हैं जो रीज़निंग मॉडल अपना दिखने वाला जवाब लिखने से पहले किसी समस्या को हल करने के लिए बनाता है। इनका बिल आम तौर पर आउटपुट टोकन की तरह बनता है, ये आउटपुट लिमिट और कॉन्टेक्स्ट विंडो में गिने जाते हैं, और API इन्हें छिपा सकता है या इनका सारांश दे सकता है।

[AI कोडिंग एजेंट (AI coding agent)](https://broadrouter.com/hi/glossary/coding-agent/)

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

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

### 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 इसे बताता है, जब मॉडल यह जानकारी देता है।

## आगे पढ़ें

-   [एजेंट टोकन बजट: एजेंट लूप के टोकन कहाँ जाते हैं](https://broadrouter.com/hi/blog/agent-token-budget/)
-   [कोडिंग एजेंट की LLM लागत घटाने के 10 तरीक़े, अनुमानित बचत के साथ](https://broadrouter.com/hi/blog/cut-coding-agent-llm-costs/)
-   [फ़्लैट रेट बनाम प्रति टोकन LLM API: ब्रेक-ईवन का हिसाब](https://broadrouter.com/hi/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [कैश्ड इनपुट टोकन क्या हैं: LLM API का बिल कैसे घटाएँ](https://broadrouter.com/hi/blog/cached-input-tokens-explained/)
-   [लंबे चलने वाले एजेंट में 1M विंडो के साथ कॉन्टेक्स्ट मैनेजमेंट](https://broadrouter.com/hi/blog/long-running-agent-context-management/)
-   [ओपन मॉडल के साथ Claude Code: प्रॉक्सी, नेटिव एंडपॉइंट और सीमाएँ](https://broadrouter.com/hi/blog/claude-code-with-openai-compatible-models/)
-   [सस्ते मॉडल पर OpenClaw और Hermes Agent: सेटअप और टोकन का हिसाब](https://broadrouter.com/hi/blog/openclaw-hermes-agent-cheap-model/)
-   [गाइड: एजेंट के लिए अनलिमिटेड LLM API प्लान कैसे काम करते हैं](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/)
-   [गाइड: Aider को अनलिमिटेड DeepSeek V4.1 Flash पर चलाएँ](https://broadrouter.com/hi/guides/aider-unlimited-deepseek/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-ai-coding-agent-run-cost&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: usage फ़ील्ड, cached\_tokens, रीज़निंग max\_tokens में गिनी जाती है, सीमाएँ (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [BroadNet Inference प्राइसिंग पेज और pricing.json, कीमतें 2026-11-14 को अपडेट (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [BroadNet Inference प्लान पेज: हर सेशन पर एक समय में एक अनुरोध, कोई टोकन मीटर नहीं (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [OpenAI प्रॉम्प्ट कैशिंग गाइड: प्रीफ़िक्स मिलान और न्यूनतम कैश होने लायक लंबाई (2026-11-15 को जाँचा गया)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [DeepSeek API डॉक्स, कॉन्टेक्स्ट कैशिंग: अनुरोध की सीमाओं पर कैश यूनिट (2026-11-15 को जाँचा गया)](https://api-docs.deepseek.com/guides/kv_cache)
