दोपहर भर काम करने वाला कोडिंग एजेंट बहुत सारी हिस्ट्री जमा कर लेता है: पढ़ी गई फ़ाइलें, चलाए गए कमांड, टेस्ट आउटपुट, प्लान, सुधार। हर टर्न यह सब मॉडल को वापस भेजता है। इस बढ़ते कॉन्टेक्स्ट को आप कैसे मैनेज करते हैं, यह एक साथ तीन चीज़ें तय करता है: हर टर्न की लागत, जवाब की रफ़्तार, और यह कि एजेंट को अब भी याद है या नहीं कि वह क्या कर रहा था।
1M-टोकन विंडो इन समझौतों को बदलती है। उन्हें ख़त्म नहीं करती।
1M-टोकन विंडो लंबे चलने वाले एजेंट को क्या देती है?
BroadNet Inference पर DeepSeek V4.1 Flash और GLM 5.3 प्रति अनुरोध 1,048,576 टोकन तक स्वीकार करते हैं, प्रॉम्प्ट और जवाब मिलाकर। Qwen3.8 27B 262,144 स्वीकार करता है। छोटी विंडो में एजेंट को एक-दो घंटे के काम के बाद सारांश बनाना पड़ता है। दस लाख टोकन के साथ वह आम तौर पर पूरे सेशन की कच्ची हिस्ट्री रख सकता है और बहुत लंबे रन के आख़िर के पास ही compact करता है।
यह असली फ़ायदा है: सारांश में जानकारी खोती है, और हर सारांश उस एक ब्योरे को भूलने का मौक़ा है जो सबसे ज़रूरी था। लेकिन तीन लागतें फिर भी प्रॉम्प्ट के साथ बढ़ती हैं:
- पैसा, प्रति-टोकन key पर, क्योंकि हर टर्न पूरा प्रॉम्प्ट दोबारा भेजता है।
- लेटेंसी, क्योंकि सर्वर को पहला आउटपुट टोकन देने से पहले हर इनपुट टोकन प्रोसेस करना होता है।
- ध्यान। इनपुट बढ़ने पर गुणवत्ता गिर सकती है, जिसे context rot कहा जाता है। “Lost in the Middle” पेपर ने पाया कि मॉडल लंबे इनपुट की शुरुआत और अंत की जानकारी बीच की जानकारी से ज़्यादा भरोसेमंद ढंग से इस्तेमाल करते हैं। नए मॉडल बेहतर हैं, लेकिन ज़रूरी तथ्य किनारों के पास रखने की आदत अब भी फ़ायदा देती है।
नियम 1: हिस्ट्री append-only क्यों होनी चाहिए?
प्रॉम्प्ट कैशिंग प्रॉम्प्ट की शुरुआत से मिलान करती है। अगर इस टर्न के पहले 300,000 टोकन पिछले टर्न जैसे ही हैं, तो वे कैश से दिए जा सकते हैं; पहला बदला हुआ टोकन मिलान ख़त्म कर देता है। BroadNet का API, जब मॉडल रिपोर्ट करता है, इसे usage.prompt_tokens_details.cached_tokens में दिखाता है और कैश्ड इनपुट कम दर पर बिल करता है: DeepSeek V4.1 Flash पर $0.0055 प्रति 1M टोकन, जबकि नए इनपुट के लिए $0.175।
इसलिए हर अनुरोध एक ही क्रम में बनाएँ और हमेशा सिर्फ़ आख़िर में जोड़ें:
[ 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” ट्रिमिंग, जो हर बार सबसे पुराना टर्न हटाती है और उसके बाद का सब कुछ खिसका देती है। इनमें से हर चीज़ कैश्ड प्रॉम्प्ट को नया प्रॉम्प्ट बना देती है; कैशिंग के लिए प्रॉम्प्ट संरचना बाक़ी कारण गिनाती है, एक टेस्ट के साथ जो साबित करता है कि प्रीफ़िक्स कैश हुआ। लंबे सेशन में फ़र्क़ बड़ा है: प्रॉम्प्ट का ज़्यादातर हिस्सा नए इनपुट की जगह कैश्ड इनपुट हो सकता है। कैश्ड इनपुट का बिल कैसे बनता है।
नियम 2: कैश रेट कैसे मापें?
इसे हर अनुरोध पर लॉग करें। OpenAI SDK के साथ, कॉल के बाद की तीन लाइनें यह काम कर देती हैं:
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 एजेंट पहले टर्न के बाद हर टर्न पर कैश्ड हिस्सा ऊँचा दिखाता है। अचानक लगभग शून्य पर गिरना मतलब प्रॉम्प्ट की शुरुआत में कुछ बदला है। उसे ढूँढें और स्थिर करें। प्रॉम्प्ट कैशिंग कैलकुलेटर कैश रेट को प्रति सेशन पैसे में बदल देता है।
नियम 3: कॉन्टेक्स्ट बढ़े तो पहले क्या काटें?
जब कॉन्टेक्स्ट छोटा करना ही पड़े, तो यह मायने रखता है कि आप क्या हटाते हैं। ज़्यादातर एजेंट ट्रांसक्रिप्ट में भारी हिस्सा टूल आउटपुट होता है: 4,000 लाइनों का टेस्ट लॉग, एक फ़ंक्शन ढूँढने के लिए पढ़ी गई पूरी फ़ाइल, डायरेक्टरी लिस्टिंग। क़ीमती हिस्सा छोटा होता है: प्लान, फ़ैसले और उनके कारण, जो एरर ठीक किए गए।
काटने का क्रम, पहले से आख़िर तक:
- पुराना टूल आउटपुट। पुराने टूल नतीजों का मुख्य हिस्सा एक लाइन के stub से बदलें: “ran pytest: 3 failures in test_api.py (fixed in turn 14)”।
- पुराना पड़ चुका फ़ाइल कंटेंट। अगर एजेंट ने
api.pyपढ़ी, बदली, फिर दोबारा पढ़ी, तो पहली बार पढ़ा गया हिस्सा बेकार बोझ है। - बेनतीजा खोजबीन। वे खोजें और रीड जिनसे कोई बदलाव नहीं हुआ।
- तर्क और प्लान। इन्हें सबसे देर तक रखें। ये बताते हैं कि कोड ऐसा क्यों दिखता है।
टूल आउटपुट को बनते ही छोटा कर देना और भी बेहतर है। हर टूल नतीजे की सीमा तय करें (जैसे लॉग की आख़िरी 200 लाइनें और कुल लाइनों की गिनती) और ज़रूरत हो तो एजेंट को और माँगने दें। इससे हिस्ट्री append-only और छोटी रहती है।
नियम 4: एजेंट को अपनी हिस्ट्री कब compact करनी चाहिए?
Compaction (पुरानी हिस्ट्री का सारांश बनाकर उसे छोटे ब्लॉक में बदलना) भारी औज़ार है। यह प्रीफ़िक्स दोबारा लिखता है, इसलिए compaction के बाद वाला टर्न सिस्टम प्रॉम्प्ट के बाद की हर चीज़ के लिए पूरी इनपुट कीमत चुकाता है। हर कुछ टर्न पर थोड़ा-थोड़ा compact करने का मतलब है यह कीमत बार-बार चुकाना।
बेहतर तरीक़ा:
- ऊँची सीमा चुनें। 1M विंडो के साथ, मान लीजिए 60–70% भरने पर compact करना सारांश वाले टर्न और नए काम के लंबे सिलसिले के लिए जगह छोड़ता है।
- हाल का हिस्सा ज्यों का त्यों रखें। पुराने हिस्से का सारांश बनाएँ और आख़िरी टर्न का सिलसिला बरक़रार रखें। opencode के 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 करता है। जवाब खाली क्यों आते हैं।
यह भी याद रखें कि विंडो प्रॉम्प्ट और जवाब दोनों को मिलाकर गिनती है। प्रॉम्प्ट 1,048,576 टोकन के पास पहुँचे, तो जवाब के लिए कोई जगह नहीं बचती। वहाँ पहुँचने से पहले compact करें; कॉन्टेक्स्ट विंडो कैलकुलेटर दिखाता है कि कोई प्रॉम्प्ट कितनी जगह छोड़ता है।
क्या फ़्लैट प्लान पर यह मायने रखता है?
BroadNet प्लान सेशन पर DeepSeek V4.1 Flash का कोई टोकन मीटर नहीं है: Full Moon सेशन $60 प्रति माह है, प्रॉम्प्ट कितने भी लंबे हों। कैशिंग का पैसे वाला तर्क ग़ायब हो जाता है। बाक़ी दो नहीं। कई सर्विंग सिस्टम में कैश्ड प्रीफ़िक्स आम तौर पर तेज़ी से प्रोसेस होता है, और अच्छी तरह मैनेज किया गया कॉन्टेक्स्ट बेहतर जवाब देता है। आदतें वही हैं; सिर्फ़ कारण बदलता है। प्लान सेशन कैसे काम करते हैं।
कॉन्टेक्स्ट मैनेजमेंट चेकलिस्ट
- पूरे सेशन के लिए सिस्टम प्रॉम्प्ट और टूल लिस्ट स्थिर।
- हिस्ट्री में सिर्फ़ जोड़ा जाता है; पुराने टर्न कभी दोबारा फ़ॉर्मैट नहीं होते।
- हर अनुरोध पर कैश रेट लॉग।
- टूल आउटपुट बनते समय सीमित; पुराना आउटपुट बाद में stub से बदला।
- ऊँची सीमा पर compaction, हाल का हिस्सा ज्यों का त्यों।
- लक्ष्य, पाबंदियों और फ़ैसलों वाली एक नोट्स फ़ाइल।
- reasoning के लिए काफ़ी बड़ा आउटपुट बजट।
दस लाख टोकन की विंडो कब इस्तेमाल करना फ़ायदेमंद है, इस पर और जानकारी के लिए 1M कॉन्टेक्स्ट विंडो गाइड देखें। बिना प्रगति के बढ़ते सेशन रोकने के लिए एजेंट लूप की लागत पर नियंत्रण देखें।
