---
title: "लंबे चलने वाले LLM एजेंट का कॉन्टेक्स्ट मैनेजमेंट | BroadRouter"
description: "1M-टोकन विंडो के साथ लंबे एजेंट सेशन को सटीक और सस्ता कैसे रखें: append-only हिस्ट्री, कैश के अनुकूल प्रॉम्प्ट, कब compact करें और पहले क्या हटाएँ।"
url: https://broadrouter.com/hi/blog/long-running-agent-context-management/
lang: hi
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

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

# लंबे चलने वाले एजेंट में 1M विंडो के साथ कॉन्टेक्स्ट मैनेजमेंट

BroadNet Inference टीम · 6 मिनट में पढ़ें · प्रकाशित 2026-11-14 · अपडेट किया गया 2026-11-16

कॉन्टेक्स्ट को append-only लॉग की तरह रखें: पहले स्थिर सिस्टम प्रॉम्प्ट और टूल लिस्ट, फिर सिर्फ़ बढ़ने वाली हिस्ट्री, ताकि हर टर्न कैश्ड प्रीफ़िक्स दोबारा इस्तेमाल करे। DeepSeek V4.1 Flash जैसी 1,048,576-टोकन विंडो के साथ कभी-कभार और बड़े क़दमों में compact करें, पहले भारी टूल आउटपुट छाँटें, और स्थायी तथ्य एक छोटी नोट्स फ़ाइल में रखें जिसे एजेंट दोबारा पढ़ता है।

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

-   बड़ी विंडो कॉन्टेक्स्ट की समस्याओं को टालती है, ख़त्म नहीं करती। सीमा के पास क्या होगा, इसकी योजना बनाएँ।
-   append-only हिस्ट्री प्रॉम्प्ट का प्रीफ़िक्स स्थिर रखती है, इसलिए कैश्ड इनपुट सस्ता बना रहता है।
-   पिछली हिस्ट्री को दोबारा लिखने से उस जगह के बाद से कैश टूट जाता है।
-   तर्क और फ़ैसलों से पहले भारी टूल आउटपुट (लॉग, फ़ाइल डंप) छाँटें।
-   कभी-कभार और बड़े क़दमों में compact करें, और स्थायी तथ्यों की एक छोटी नोट्स फ़ाइल रखें।

**इस पेज पर**

1.  1M-टोकन विंडो लंबे चलने वाले एजेंट को क्या देती है?
2.  नियम 1: हिस्ट्री append-only क्यों होनी चाहिए?
3.  नियम 2: कैश रेट कैसे मापें?
4.  नियम 3: कॉन्टेक्स्ट बढ़े तो पहले क्या काटें?
5.  नियम 4: एजेंट को अपनी हिस्ट्री कब compact करनी चाहिए?
6.  नियम 5: नोट्स फ़ाइल में क्या होना चाहिए?
7.  reasoning टोकन बजट पर क्या असर डालते हैं?
8.  क्या फ़्लैट प्लान पर यह मायने रखता है?
9.  कॉन्टेक्स्ट मैनेजमेंट चेकलिस्ट

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

1M-टोकन विंडो इन समझौतों को बदलती है। उन्हें ख़त्म नहीं करती।

## 1M-टोकन विंडो लंबे चलने वाले एजेंट को क्या देती है?

BroadNet Inference पर [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) और [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) प्रति अनुरोध 1,048,576 टोकन तक स्वीकार करते हैं, प्रॉम्प्ट और जवाब मिलाकर। [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) 262,144 स्वीकार करता है। छोटी विंडो में एजेंट को एक-दो घंटे के काम के बाद सारांश बनाना पड़ता है। दस लाख टोकन के साथ वह आम तौर पर पूरे सेशन की कच्ची हिस्ट्री रख सकता है और बहुत लंबे रन के आख़िर के पास ही compact करता है।

यह असली फ़ायदा है: सारांश में जानकारी खोती है, और हर सारांश उस एक ब्योरे को भूलने का मौक़ा है जो सबसे ज़रूरी था। लेकिन तीन लागतें फिर भी प्रॉम्प्ट के साथ बढ़ती हैं:

-   **पैसा**, प्रति-टोकन key पर, क्योंकि हर टर्न पूरा प्रॉम्प्ट दोबारा भेजता है।
-   **लेटेंसी**, क्योंकि सर्वर को पहला आउटपुट टोकन देने से पहले हर इनपुट टोकन प्रोसेस करना होता है।
-   **ध्यान।** इनपुट बढ़ने पर गुणवत्ता गिर सकती है, जिसे [context rot](https://broadrouter.com/hi/glossary/context-rot/) कहा जाता है। [“Lost in the Middle”](https://arxiv.org/abs/2307.03172) पेपर ने पाया कि मॉडल लंबे इनपुट की शुरुआत और अंत की जानकारी बीच की जानकारी से ज़्यादा भरोसेमंद ढंग से इस्तेमाल करते हैं। नए मॉडल बेहतर हैं, लेकिन ज़रूरी तथ्य किनारों के पास रखने की आदत अब भी फ़ायदा देती है।

## नियम 1: हिस्ट्री append-only क्यों होनी चाहिए?

प्रॉम्प्ट कैशिंग प्रॉम्प्ट की शुरुआत से मिलान करती है। अगर इस टर्न के पहले 300,000 टोकन पिछले टर्न जैसे ही हैं, तो वे कैश से दिए जा सकते हैं; पहला बदला हुआ टोकन मिलान ख़त्म कर देता है। BroadNet का API, जब मॉडल रिपोर्ट करता है, इसे `usage.prompt_tokens_details.cached_tokens` में दिखाता है और कैश्ड इनपुट कम दर पर बिल करता है: DeepSeek V4.1 Flash पर $0.0055 प्रति 1M टोकन, जबकि नए इनपुट के लिए $0.175।

इसलिए हर अनुरोध एक ही क्रम में बनाएँ और हमेशा सिर्फ़ आख़िर में जोड़ें:

```text
[ system prompt ]        never changes during a session
[ tool definitions ]     fixed order, never changes
[ project notes ]        changes rarely, and only by appending
[ turn 1 ... turn N ]    grows at the end
[ new message ]
```

प्रीफ़िक्स तोड़ने वाली आम चीज़ें हैं: सिस्टम प्रॉम्प्ट में टाइमस्टैम्प, बदलते क्रम में टूल डेफ़िनिशन, और पुराने टूल नतीजों को दोबारा रेंडर करना। एजेंट के लिए एक और जोड़ें: “sliding window” ट्रिमिंग, जो हर बार सबसे पुराना टर्न हटाती है और उसके बाद का सब कुछ खिसका देती है। इनमें से हर चीज़ कैश्ड प्रॉम्प्ट को नया प्रॉम्प्ट बना देती है; [कैशिंग के लिए प्रॉम्प्ट संरचना](https://broadrouter.com/hi/blog/prompt-structure-for-caching/) बाक़ी कारण गिनाती है, एक टेस्ट के साथ जो साबित करता है कि प्रीफ़िक्स कैश हुआ। लंबे सेशन में फ़र्क़ बड़ा है: प्रॉम्प्ट का ज़्यादातर हिस्सा नए इनपुट की जगह कैश्ड इनपुट हो सकता है। [कैश्ड इनपुट का बिल कैसे बनता है](https://broadrouter.com/hi/blog/cached-input-tokens-explained/)।

## नियम 2: कैश रेट कैसे मापें?

इसे हर अनुरोध पर लॉग करें। OpenAI SDK के साथ, कॉल के बाद की तीन लाइनें यह काम कर देती हैं:

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

resp = client.chat.completions.create(model="broadnet/deepseek-v4.1-flash", messages=history, max_tokens=8000)
u = resp.usage
cached = (u.prompt_tokens_details.cached_tokens if u.prompt_tokens_details else 0) or 0
print(f"turn prompt={u.prompt_tokens:,} cached={cached:,} ({cached / max(1, u.prompt_tokens):.0%})")
```

एक स्वस्थ append-only एजेंट पहले टर्न के बाद हर टर्न पर कैश्ड हिस्सा ऊँचा दिखाता है। अचानक लगभग शून्य पर गिरना मतलब प्रॉम्प्ट की शुरुआत में कुछ बदला है। उसे ढूँढें और स्थिर करें। [प्रॉम्प्ट कैशिंग कैलकुलेटर](https://broadrouter.com/tools/prompt-caching-calculator/) कैश रेट को प्रति सेशन पैसे में बदल देता है।

## नियम 3: कॉन्टेक्स्ट बढ़े तो पहले क्या काटें?

जब कॉन्टेक्स्ट छोटा करना ही पड़े, तो यह मायने रखता है कि आप क्या हटाते हैं। ज़्यादातर एजेंट ट्रांसक्रिप्ट में भारी हिस्सा टूल आउटपुट होता है: 4,000 लाइनों का टेस्ट लॉग, एक फ़ंक्शन ढूँढने के लिए पढ़ी गई पूरी फ़ाइल, डायरेक्टरी लिस्टिंग। क़ीमती हिस्सा छोटा होता है: प्लान, फ़ैसले और उनके कारण, जो एरर ठीक किए गए।

काटने का क्रम, पहले से आख़िर तक:

1.  **पुराना टूल आउटपुट।** पुराने टूल नतीजों का मुख्य हिस्सा एक लाइन के stub से बदलें: “ran pytest: 3 failures in test\_api.py (fixed in turn 14)”।
2.  **पुराना पड़ चुका फ़ाइल कंटेंट।** अगर एजेंट ने `api.py` पढ़ी, बदली, फिर दोबारा पढ़ी, तो पहली बार पढ़ा गया हिस्सा बेकार बोझ है।
3.  **बेनतीजा खोजबीन।** वे खोजें और रीड जिनसे कोई बदलाव नहीं हुआ।
4.  **तर्क और प्लान।** इन्हें सबसे देर तक रखें। ये बताते हैं कि कोड ऐसा क्यों दिखता है।

टूल आउटपुट को बनते ही छोटा कर देना और भी बेहतर है। हर टूल नतीजे की सीमा तय करें (जैसे लॉग की आख़िरी 200 लाइनें और कुल लाइनों की गिनती) और ज़रूरत हो तो एजेंट को और माँगने दें। इससे हिस्ट्री append-only और छोटी रहती है।

## नियम 4: एजेंट को अपनी हिस्ट्री कब compact करनी चाहिए?

Compaction (पुरानी हिस्ट्री का सारांश बनाकर उसे छोटे ब्लॉक में बदलना) भारी औज़ार है। यह प्रीफ़िक्स दोबारा लिखता है, इसलिए compaction के बाद वाला टर्न सिस्टम प्रॉम्प्ट के बाद की हर चीज़ के लिए पूरी इनपुट कीमत चुकाता है। हर कुछ टर्न पर थोड़ा-थोड़ा compact करने का मतलब है यह कीमत बार-बार चुकाना।

बेहतर तरीक़ा:

-   **ऊँची सीमा चुनें।** 1M विंडो के साथ, मान लीजिए 60–70% भरने पर compact करना सारांश वाले टर्न और नए काम के लंबे सिलसिले के लिए जगह छोड़ता है।
-   **हाल का हिस्सा ज्यों का त्यों रखें।** पुराने हिस्से का सारांश बनाएँ और आख़िरी टर्न का सिलसिला बरक़रार रखें। opencode के [compaction डॉक्स](https://opencode.ai/docs/compaction/) यही बताते हैं: यह बातचीत का सारांश बनाता है और सबसे हाल का हिस्सा रखता है, डिफ़ॉल्ट रूप से लगभग 15,000 टोकन।
-   **पूरे प्रॉम्प्ट के साथ सारांश बनाएँ।** सारांश वाले अनुरोध में पूरी बातचीत भेजने से वह पिछले टर्न का कैश दोबारा इस्तेमाल कर पाता है।
-   **एक बार compact करें, फिर से append करें।** compaction के बाद नया प्रीफ़िक्स स्थिर रहता है, और कैशिंग वहीं से फिर शुरू होती है।

## नियम 5: नोट्स फ़ाइल में क्या होना चाहिए?

कुछ तथ्यों को कितने भी compaction के बाद बचे रहना चाहिए: लक्ष्य, पाबंदियाँ, लिए गए फ़ैसले, प्रोजेक्ट को build और test करने वाले कमांड। इन्हें एक छोटी नोट्स फ़ाइल (`NOTES.md` या कोई टास्क फ़ाइल) में रखें, जिसमें एजेंट जोड़ता है और जिसे दोबारा पढ़ता है। यह प्रॉम्प्ट के ऊपरी हिस्से के पास रहती है, कभी-कभार बदलती है, और रन दोबारा शुरू होने पर नया सेशन सबसे पहले इसे ही पढ़ता है।

यह मेमोरी का सबसे सस्ता रूप भी है: कुछ हज़ार टोकन, जो एजेंट को हर सारांश के बाद वही तथ्य फिर से खोजने से बचाते हैं।

## reasoning टोकन बजट पर क्या असर डालते हैं?

DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब देने से पहले reasoning करते हैं, और reasoning `max_tokens` में गिनी जाती है। लंबा सेशन इसे नहीं बदलता, लेकिन बड़े प्रॉम्प्ट लोगों को “जगह बचाने” के लिए `max_tokens` घटाने को लुभाते हैं। ऐसा न करें। तंग आउटपुट बजट खाली जवाब पैदा करता है, जिन्हें एजेंट फिर retry करता है। [जवाब खाली क्यों आते हैं](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)।

यह भी याद रखें कि विंडो प्रॉम्प्ट और जवाब दोनों को मिलाकर गिनती है। प्रॉम्प्ट 1,048,576 टोकन के पास पहुँचे, तो जवाब के लिए कोई जगह नहीं बचती। वहाँ पहुँचने से पहले compact करें; [कॉन्टेक्स्ट विंडो कैलकुलेटर](https://broadrouter.com/tools/context-window-calculator/) दिखाता है कि कोई प्रॉम्प्ट कितनी जगह छोड़ता है।

## क्या फ़्लैट प्लान पर यह मायने रखता है?

BroadNet प्लान सेशन पर DeepSeek V4.1 Flash का कोई टोकन मीटर नहीं है: Full Moon सेशन $60 प्रति माह है, प्रॉम्प्ट कितने भी लंबे हों। कैशिंग का पैसे वाला तर्क ग़ायब हो जाता है। बाक़ी दो नहीं। कई सर्विंग सिस्टम में कैश्ड प्रीफ़िक्स आम तौर पर तेज़ी से प्रोसेस होता है, और अच्छी तरह मैनेज किया गया कॉन्टेक्स्ट बेहतर जवाब देता है। आदतें वही हैं; सिर्फ़ कारण बदलता है। [प्लान सेशन कैसे काम करते हैं](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/)।

## कॉन्टेक्स्ट मैनेजमेंट चेकलिस्ट

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

दस लाख टोकन की विंडो कब इस्तेमाल करना फ़ायदेमंद है, इस पर और जानकारी के लिए [1M कॉन्टेक्स्ट विंडो गाइड](https://broadrouter.com/hi/blog/million-token-context-window-guide/) देखें। बिना प्रगति के बढ़ते सेशन रोकने के लिए [एजेंट लूप की लागत पर नियंत्रण](https://broadrouter.com/hi/blog/cut-coding-agent-llm-costs/) देखें।

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

-   [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/)

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

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

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

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

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

[कॉन्टेक्स्ट कॉम्पैक्शन (context compaction)](https://broadrouter.com/hi/glossary/context-compaction/)

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

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

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

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

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

[कैश्ड इनपुट टोकन (cached input tokens)](https://broadrouter.com/hi/glossary/cached-input-tokens/)

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

[कॉन्टेक्स्ट रॉट (context rot)](https://broadrouter.com/hi/glossary/context-rot/)

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

[कॉन्टेक्स्ट विंडो (context window)](https://broadrouter.com/hi/glossary/context-window/)

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

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

### अगर मॉडल की विंडो 1M है, तो कॉन्टेक्स्ट मैनेज करने की ज़रूरत क्यों?

क्योंकि प्रॉम्प्ट बढ़ने के साथ लागत, लेटेंसी और सटीकता तीनों बदलती हैं। लंबे प्रॉम्प्ट प्रोसेस होने में ज़्यादा समय लेते हैं, प्रति-टोकन key पर हर टर्न में ज़्यादा ख़र्च होते हैं, और रिसर्च दिखाती है कि मॉडल लंबे इनपुट के बीच की जानकारी कम भरोसेमंद ढंग से इस्तेमाल करते हैं।

### कैसे पता करूँ कि मेरा एजेंट कैश hit कर रहा है?

जब मॉडल इसे रिपोर्ट करता है, तो usage ब्लॉक में prompt\_tokens\_details.cached\_tokens होता है। हर अनुरोध के लिए इसे prompt\_tokens से भाग दें और यह दर लॉग करें।

### क्या फ़्लैट प्लान पर compaction मायने रखता है?

बिल के लिए नहीं, क्योंकि प्लान सेशन में टोकन मीटर नहीं होता। फिर भी बहुत लंबे सेशन में स्पीड और जवाब की गुणवत्ता के लिए यह मायने रखता है।

## आगे पढ़ें

-   [1M-टोकन कॉन्टेक्स्ट विंडो कब फ़ायदेमंद है (और कब नहीं)](https://broadrouter.com/hi/blog/million-token-context-window-guide/)
-   [कैश्ड इनपुट टोकन क्या हैं: LLM API का बिल कैसे घटाएँ](https://broadrouter.com/hi/blog/cached-input-tokens-explained/)
-   [कोडिंग एजेंट की LLM लागत घटाने के 10 तरीक़े, अनुमानित बचत के साथ](https://broadrouter.com/hi/blog/cut-coding-agent-llm-costs/)
-   [कोडिंग एजेंट को रात भर बिना निगरानी के सुरक्षित कैसे चलाएँ](https://broadrouter.com/hi/blog/overnight-coding-agent-runs/)
-   [AI कोडिंग एजेंट के एक रन की लागत: स्टेप, कॉन्टेक्स्ट और कैशिंग](https://broadrouter.com/hi/blog/ai-coding-agent-run-cost/)
-   [ओपन मॉडल के साथ Claude Code: प्रॉक्सी, नेटिव एंडपॉइंट और सीमाएँ](https://broadrouter.com/hi/blog/claude-code-with-openai-compatible-models/)
-   [गाइड: chat completions स्ट्रीम करें और टूटे कनेक्शन सँभालें](https://broadrouter.com/hi/guides/streaming-chat-completions/)
-   [गाइड: रीज़निंग मॉडल ख़ाली जवाब क्यों लौटाता है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)
-   [गाइड: एजेंट के लिए अनलिमिटेड LLM API प्लान कैसे काम करते हैं](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/)

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

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

**स्रोत**

-   [BroadNet Inference API रेफ़रंस, reasoning और कैश्ड टोकन (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-long-running-agent-context-management&utm_content=sources)
-   [Liu et al., Lost in the Middle: How Language Models Use Long Contexts (arXiv)](https://arxiv.org/abs/2307.03172)
-   [opencode डॉक्स, compaction](https://opencode.ai/docs/compaction/)
