प्रॉम्प्ट कैशिंग की गलतियाँ आपके संगठन को हर AI टर्न पर लगभग 6x अधिक खर्च करा सकती हैं
एक टूटे हुए प्रॉम्प्ट कैश से उन संगठनों को क्या लागत होती है जो हार्नेस बनाते हैं, आंतरिक AI प्लेटफ़ॉर्म चलाते हैं या AI उत्पाद शिप करते हैं, यह 4 लैब्स के मॉडलों पर मापा गया है और लाइव ट्रैफ़िक के खिलाफ मूल्यांकित किया गया है, समाधान और इसे कैसे देखते रहें.
Developed by Robert E. Beckner III (Merlin) | rbeckner.com
वर्षों पहले मैं सोचने लगा कि AI कभी तारीख और समय को अच्छी तरह क्यों नहीं जानता. किसी बातचीत से पूछना कि आज कौन सा दिन है, कुछ सेकंड लग सकते हैं, और मैं एक त्वरित उत्तर की उम्मीद करता था. वह कंप्यूटर जो बातचीत चला रहा है, जानता है कि अभी समय क्या है.
तब से मैंने कारण का कुछ हिस्सा समझ लिया है. एक व्यक्ति अगले दिन बातचीत में वापस आ सकता है, और जिस समय पर बातचीत शुरू हुई थी वह पुरानी हो गई है. कुछ उसे फिर से प्रदान करना चाहिए. एक हार्नेस, मॉडल के चारों ओर का प्रोग्राम जो प्रत्येक अनुरोध को एकत्रित करता है और लूप चलाता है, यह कर सकता है वर्तमान समय को मॉडल के निर्देशों में हर अनुरोध से पहले लिखकर. वह एजेंट रनर जिसे हम उत्पादन में उपयोग करते हैं, वही करता है.
मैं लंबे समय से प्रॉम्प्ट कैशिंग के बारे में जानता हूँ. प्रदाता अनुरोध की शुरुआत को संग्रहीत करते हैं और अगले अनुरोध के शुरू होने पर उसी तरह कीमत का एक अंश बिल करते हैं. मैं इसके तंत्र को इतना अच्छी तरह नहीं जानता था कि देख सकूँ कि समय जैसी पंक्ति इसे कैसे प्रभावित करती है. हम अपने स्वयं के उत्पादन लागत में उत्तर पर ठोकर खाई, और मैंने प्रयोगों की एक श्रृंखला का निर्देशन किया ताकि इसे सही ढंग से मापा जा सके, प्रत्येक 4 लैब्स के एक वर्तमान मॉडल पर और OpenRouter के सार्वजनिक आंकड़ों के खिलाफ यह देखने के लिए कि अन्य सभी क्या भुगतान कर रहे हैं।
उत्तर महंगा है. GPT-6 Luna पर, गलत स्थान पर लिखे गए समय ने हर टर्न की बातचीत को 5.7× जितना महंगा बना दिया जितना उसे होना चाहिए था, और कुछ भी त्रुटि नहीं उठाई. ट्रैफ़िक संगठनों के बीच इन मॉडलों को भेजते हुए, इनपुट 96–99% टोकन और 66–87% डॉलर के वास्तविक भुगतान के रूप में है, इसलिए कैश बिल का अधिकांश हिस्सा तय करता है. अपनी खुद की हार्नेस बना रहे संगठन, आंतरिक AI प्लेटफ़ॉर्म चला रहे हैं या AI उत्पाद शिप कर रहे हैं, इस तरह की गलती हर टर्न की लागत को गुणा कर देती है, चुपचाप, जितना समय यह चलता है.
यहाँ हर प्रति-टर्न संख्या 23 सितंबर, 2026 को मापी गई थी, OpenRouter के माध्यम से। बाजार आंकड़े OpenRouter के अपने हैं, उसी दिन पढ़ें।
एक प्रॉम्प्ट कैश अनुरोध की शुरुआत को संग्रहीत करता है और इसे दसवें हिस्से पर बिल करता है#
मॉडल को हर कॉल पूरी बातचीत फिर से भेजता है: टूल परिभाषाएँ, सिस्टम प्रॉम्प्ट (हार्नेस द्वारा लिखे गए स्थायी निर्देश), हर पहले टर्न, और नया संदेश.
प्रदाता हाल के अनुरोधों के संसाधित प्रारंभ को रखते हैं. जब अगला अनुरोध उसी पाठ से शुरू होता है, प्रदाता उस संग्रहीत उपसर्ग को पढ़ता है बजाय इसे फिर से संसाधित करने के. GPT-6 Luna पर, OpenRouter ने एक पढ़ने को 0.10× सूचीबद्ध इनपुट कीमत पर और पहली लिखाई को 1.25× पर बिल किया। एक प्रॉम्प्ट जो हर टर्न पर फिर से लिखा जाता है, इसलिए बिना कैश वाले प्रॉम्प्ट से अधिक लागत आती है.
केवल अनुरोध की शुरुआत को पुनः उपयोग किया जा सकता है. किसी भी बिंदु पर परिवर्तन उसके बाद की सभी चीजों को अमान्य कर देता है:
Diagram source
graph LR
A[टूल परिभाषाएँ] --> B[सिस्टम प्रॉम्प्ट]
B --> C[पहले टर्न]
C --> D[नया उपयोगकर्ता संदेश]
B -. a changed line here voids B, C and D .-> D
कोई भी चीज़ जो हार्नेस द्वारा शुरुआत के पास लिखी जाती है और हर टर्न पर बदलती है, पूरी बातचीत को जोखिम में डाल देती है. वर्तमान समय सबसे सरल उदाहरण है.
हमने इसे अपनी ही बिल में पाया, अपनी ही लागत लेजर द्वारा छिपा हुआ#
खोज एक एजेंट में शुरू हुई जिसे हम उत्पादन में चलाते हैं. उसकी लागत लेजर ने हर कॉल को सूची मूल्य पर मूल्यांकित किया और कोई कैशिंग नहीं दिखाया. मैंने अलार्म उठाया और एक अलग मॉडल पर स्विच करने पर विचार करना शुरू किया.
जिस एजेंट के साथ मैं काम कर रहा था, उसने सबसे पहले पाया कि लेजर स्वयं गलत था. 33 कॉलों पर उसने $0.064 का अनुमान लगाया; प्रदाता ने $0.023, 2.7× कम बिल किया. टोकन गिनती से प्रत्येक कॉल का मूल्य निर्धारण करने से प्रदाता द्वारा लागू हर छूट मिट गई. प्रदाता-रिपोर्टेड लागत पढ़ने से दिखा कि कैशिंग प्रत्येक टर्न के भीतर काम कर रही थी और हर नए टर्न की शुरुआत में विफल हो रही थी.
उसका पहला स्पष्टीकरण एक गायब सत्र कुंजी था जो अनुरोधों को उसी सर्वर पर रखेगी. उसकी अपनी जाँच ने इसे खारिज कर दिया: समान प्रॉम्प्ट पहले से ही GPT-6 Luna पर टर्नों के बीच कैश से पढ़े जा रहे थे, और सत्र कुंजी, कैश कुंजी या स्पष्ट कैश मार्कर जोड़ने से कुछ भी नहीं बदला. कारण सिस्टम प्रॉम्प्ट स्वयं में था. रास्ते में लगभग 95% पर, रनर ने दो पंक्तियाँ लिखीं जो हर टर्न बदलती थीं: एक प्रति-टर्न कार्यशील निर्देशिका और एक मिनट तक घड़ी. एक टर्न के पहले कॉल ने पूरे प्रॉम्प्ट को फिर से 1.25× पर लिखा.
दोनों पंक्तियों को उपयोगकर्ता संदेश के अंत में ले जाने से उत्पादन में इसे ठीक कर दिया गया. टर्न 2 और 3 अब 0.47–0.51× पर खुलते हैं बजाय 1.25×. शेष एक प्रति-टर्न संदर्भ का ब्लॉक है जिसे रनर अभी भी उपयोगकर्ता संदेश में भेजता है.
जहाँ समय जाता है, वह तय करता है कि प्रॉम्प्ट पढ़ा गया है या फिर से लिखा गया है#
मेरा अनुमान, इससे पहले कि यह सब मापा गया, यह था कि एक निर्धारक जाँच केवल तब समय प्रदान कर सकती है जब वह पुरानी हो जाए, एक अलग संदेश के रूप में, और प्रॉम्प्ट के बाकी हिस्से को कैश्ड छोड़ दे. यह एक शर्त के साथ मान्य है, और वह शर्त वह नियम है जिस पर लेख का बाकी हिस्सा निर्भर करता है.
इसे सीधे परीक्षण करने के लिए, हमने एक प्रॉब बनाया जो उसी बातचीत को चलाता है, घड़ी को अलग-अलग स्थानों पर रखकर, 65 सेकंड के अंतर पर, ताकि हर जोड़ी के बीच मिनट बदल जाए. GPT-6 Luna, एक 8.5K-टोकन सिस्टम प्रॉम्प्ट, 3 प्रतिकृति करता है:
जहाँ घड़ी जाती है
खोलने के मोड़
कैश से पढ़ें
फिर से लिखा गया
कीमत बनाम सूचीबद्ध इनपुट
कोई घड़ी नहीं (नियंत्रण)
12
12
0
0.10×
सिस्टम प्रॉम्प्ट का अंत
12
0
12
1.25×
दूसरी सिस्टम संदेश
12
0
12
1.25×
उपयोगकर्ता संदेश की शुरुआत
12
12
0
0.10×
उपयोगकर्ता संदेश का अंत
12
12
0
0.10×
अपनी ही संदेश, हर टर्न
12
12
0
0.11×
अपनी ही संदेश, केवल जब पुरानी हो
12
12
0
0.10×
मेरी अलग संदेश ने कैश को दोनों रूपों में रखा, हर टर्न और केवल जब पुराना हो गया. शर्त वह जगह है जहाँ संदेश स्थित है. स्थिर निर्देशों के बाद, प्रदाता उससे पहले सब कुछ पढ़ता है. एक दूसरे सिस्टम संदेश के रूप में यह निर्देशों के बीच बैठता है, और GPT-6 Luna ने पूरे प्रॉम्प्ट को फिर से लिखा 12 के 12 टर्न पर.
इसके बाद आने वाला नियम छोटा है. जो कुछ भी टर्न के बीच बदलता है वह सब कुछ जो नहीं बदलता उसके बाद जाता है.
एक घड़ी कुछ भी लागत नहीं करती जब तक उसका पाठ नहीं बदलता#
कैश पाठ की तुलना करता है, इसलिए एक घड़ी हानिरहित है जब तक उसका पाठ वही रहता है. उसी प्रॉब में, जहाँ 4 सेकंड के अंतर पर घुमाव होते हैं, एक मिनट घड़ी सिस्टम प्रॉम्प्ट में हर बार कैश से पढ़ती है. जहाँ 65 सेकंड के अंतर पर घुमाव होते हैं, यह हर घुमाव पर पूरी पुनर्लेखन को मजबूर करता है.
समाधान तय करता है कि यह कितनी बार होता है. एक घंटे की घड़ी और एक तारीख पंक्ति दोनों ही सिस्टम प्रॉम्प्ट में कैश से पढ़ी जाती हैं सभी 12 टर्न ओपनिंग्स पर 65-सेकंड रन के, क्योंकि दोनों ने रोल ओवर नहीं किया. वे भी टूटते हैं, एक बार एक घंटे में और एक बार एक दिन में. एक मिनट घड़ी हर उस घुमाव पर टूटती है जो पिछले से बाद के मिनट में शुरू होता है.
कैश स्वयं भी समाप्त हो जाता है. एकल समयबद्ध रन में, GPT-6 Luna अभी भी अपने संग्रहीत प्रीफ़िक्स को 30 मिनट निष्क्रिय रहने के बाद पढ़ता है और पूरे प्रॉम्प्ट को फिर से लिखता है 1.25× बाद में 60. DeepSeek V4.1 Flash 10 मिनट के बाद पढ़ता है और 60 के बाद चूक जाता है. Claude Opus 5.5 पहले ही 10 के बाद चूक गया था, क्योंकि Anthropic का डिफ़ॉल्ट कैश 5 मिनट तक रहता है और उसका 1-घंटे का कैश लिखने में 2× लागत आती है. वह व्यक्ति जो अगले दिन एक वार्तालाप पर लौटता है, वह मामला जिससे यह लेख शुरू हुआ, सभी तीनों पर एक पुराना समय और एक ठंडा कैश पाता है. वह पहला घुमाव वापस भुगतान करता है पूरे प्रॉम्प्ट के लिए चाहे हार्नेस कुछ भी करे. स्थान निर्धारित करता है कि उसके बाद के मोड़ भी करते हैं.
GPT-6 Luna एक प्रदाता का उत्तर है. यह देखने के लिए कि पाठ कितना सामान्य है, हमने प्रत्येक 4 लैब से एक वर्तमान मॉडल पर वही प्लेसमेंट चलाए, एक समान 2.5K-टोकन प्रॉम्प्ट के साथ, प्रत्येक को एक ही प्रदाता से पिन किया:
Price of each turn's first call, by where the clock is written (median, multiple of the listed input price)Chart data
multiple of listed input price
GPT-6 Luna (OpenAI)
Claude Opus 5.5 (Anthropic)
DeepSeek V4.1 Flash (DeepInfra)
No clock
0.11
0.07
0.03
System prompt
1.25
1.24
0.13
Second system
1.25
0.08
0.04
User message
0.12
0.08
0.04
Reference line, listed input price: 1
GPT-6 Luna पूरे संदेशों को कैश करता है। एक बदली हुई पंक्ति संदेश को नष्ट कर देती है जो इसे रखता है और उसके बाद सब कुछ.
Claude Opus 5.5 केवल तब कैश करता है जब कॉलर इसे चिह्नित करता है। Anthropic के मॉडल केवल cache_control मार्कर तक कैश करते हैं जिसे हार्नेस रखता है। बिना मार्कर के, वही प्रॉम्प्ट हर कॉल पर पूर्ण मूल्य लेता है. सिस्टम प्रॉम्प्ट पर मार्कर के साथ, उस ब्लॉक के अंदर एक घड़ी का मूल्य 1.24× था, जबकि एक दूसरी सिस्टम संदेश में घड़ी ने 0.08× पर पढ़ा. GPT-6 Luna द्वारा दंडित प्लेसमेंट Opus पर सुरक्षित है. Opus कीमतों पर, टर्न खोलने पर अंतर $0.0214 बनाम $0.0023 था. Opus ने भी समान प्रॉम्प्ट को 4,056 टोकन के रूप में गिना जबकि GPT-6 Luna ने 2,395 गिना, इसलिए वही पाठ किसी भी मूल्य लागू होने से पहले 1.69× अधिक टोकन लागत रखता है.
DeepSeek V4.1 Flash 256-टोकन ब्लॉकों में कैश करता है और लिखने के लिए कोई अतिरिक्त शुल्क नहीं लेता। पढ़ने के परिणाम 256 के सटीक गुणकों में लौटे: अपरिवर्तित प्रॉम्प्ट के लिए 2,560 टोकन, सिस्टम प्रॉम्प्ट के अंत में घड़ी के साथ 2,304। एक बदली हुई पंक्ति केवल उस ब्लॉक की लागत होती है जो इसे रखता है. पहली कॉल्स साधारण इनपुट मूल्य पर बिल की गईं, और पढ़ने पर 0.03–0.04×. 8 रन प्रति प्लेसमेंट में, 2 एकल कॉल्स ने कैश मिस किया एक टर्न पर जिसे वही रन फिर पढ़ता है, जिसे एक अलग सर्वर पर अनुरोध आने के रूप में पढ़ा जाता है बजाय प्लेसमेंट के प्रभाव के. DeepSeek का अपना एंडपॉइंट एकमात्र है जिसे OpenRouter मार्क करता है कैशिंग को स्वचालित रूप से, और मेरे खाते की गोपनीयता सेटिंग इसे बाहर रखती है क्योंकि वह एंडपॉइंट भुगतानित ट्रैफ़िक पर प्रशिक्षित करता है। रन DeepInfra से गुजरे, जिसने कैश किया, जैसा कि Fireworks और Morph ने 2-कॉल जांच में किया।
Muse Spark 1.3 अपने कैश को टूल लूप के अंदर पढ़ता है और प्रत्येक नए टर्न की शुरुआत में मिस करता है। हमारे पहले प्रॉब्स, जो उसी सिस्टम प्रॉम्प्ट के खिलाफ एक नया प्रश्न पूछते हैं, अधिकतम 113 टोकन 10 कॉल्स में कैश से सेवा करते हैं, 2.9K पर, 8.9K और 19.4K टोकन. जब एक फॉलो‑अप कॉल ने पिछले अनुरोध को विस्तारित किया, जैसे कि एक एजेंट के टूल लूप करता है, Muse ने 2,801 के 2,966 टोकन पढ़े और 0.17× बिल किए. अगले उपयोगकर्ता टर्न में, पूरे इतिहास के सामने, कुछ नहीं पढ़ा. OpenRouter Muse के लिए लाइव ट्रैफ़िक पर एक 86.1% कैश हिट दर रिपोर्ट करता है, जो टूल लूप द्वारा प्रभुत्व वाले वर्कलोड के अनुरूप है. एक टर्न की शुरुआत में, घड़ी Muse पर कोई अंतर नहीं बनाती, क्योंकि वह कॉल चाहे जो भी हो मिस हो जाती है.
वही हार्नेस निर्णय प्रत्येक मॉडल पर अलग राशि का खर्च करता है. यह जानना कि आपका प्रदाता कौन सा तंत्र उपयोग करता है, किसी भी ट्यूनिंग से पहले आता है.
हम अपेक्षा करते थे कि कैश्ड टर्न तेज़ी से उत्तर देंगे. 10 GPT-6 Luna कॉल्स के क्रमिक जोड़ों पर 8.5K टोकन पर, मध्यवर्ती पहला कॉल कैश से 437 ms और बिना कैश के 490 ms लिया. वह अंतर नमूनों के प्रसार के भीतर है. इस आकार पर, कैशिंग एक टर्न की लागत बदल देती है और यह कितना समय लेता है लगभग वही रहता है.
इसलिए वह विराम जिसे मैं याद करता हूँ जब मैं समय पूछता हूँ, उसका कोई अन्य कारण है. गलत जगह पर घड़ी की लागत पैसा है.
सिस्टम प्रॉम्प्ट में घड़ी पूरी बातचीत से आगे होती है, इसलिए प्रत्येक पुनर्लेखन उसके पीछे बढ़ते इतिहास और निर्देशों को कवर करता है. यहाँ एक 12-टर्न GPT-6 Luna बातचीत की मापी गई लागत है, पूर्ण प्रदाता-रिपोर्टेड बिल के साथ, आउटपुट और प्रत्येक टर्न के भीतर कॉल्स सहित:
Cumulative cost of one 12-turn conversation on GPT-6 Luna (US cents)Chart data
US cents, cumulative
turn
Clock at the end of the system prompt
Clock at the end of the user message
1
0.119
0.119
2
0.237
0.14
3
0.357
0.161
4
0.477
0.182
5
0.599
0.203
6
0.722
0.225
7
0.846
0.247
8
0.971
0.269
9
1.097
0.291
10
1.224
0.313
11
1.352
0.335
12
1.482
0.358
दो पंक्तियाँ अपनी पहली टर्न साझा करती हैं, जब दोनों कैश लिखते हैं. तब से, सिस्टम प्रॉम्प्ट में घड़ी के साथ हर टर्न की लागत 5.7× वही टर्न की लागत से अधिक है जब घड़ी उपयोगकर्ता संदेश के अंत में होती है. टर्न 12 तक बातचीत की लागत 4.1× अधिक हो गई, और अंतर हर टर्न के साथ बढ़ता है.
सेंट के अंश स्केल पर एक लाइन आइटम बन जाते हैं. यह प्रक्षेपण प्रत्येक टर्न के पहले कॉल की कीमत बताता है एक उत्पाद के लिए जो 10,000 वार्तालाप प्रति दिन सेवा देता है, प्रत्येक के साथ एक 8.5K-टोकन सिस्टम प्रॉम्प्ट, 20 टर्न, और इतिहास जो हर टर्न पर 1,500 टोकन बढ़ता है. प्रत्येक मॉडल अपनी सूचीबद्ध कीमत और ऊपर दिखाए गए कैश व्यवहार का उपयोग करता है:
मॉडल
कैश व्यवहार
प्रति बातचीत, सिस्टम प्रॉम्प्ट में घड़ी
प्रति बातचीत, अंत में घड़ी
प्रति वर्ष, अंतर
GPT-6 Luna
पूरा संदेश
$0.057
$0.0057
$187K
Claude Opus 5.5
कॉलर का मार्कर
$2.28
$0.14
$7.8M
DeepSeek V4.1 Flash
256-टोकन ब्लॉक्स
$0.042
$0.0032
$141K
Muse Spark 1.3
हर टर्न के उद्घाटन पर चूक गया
$0.57
$0.57
$0
DeepSeek के ब्लॉक्स सिस्टम प्रॉम्प्ट को रखते हैं जब घड़ी बदलती है, और मॉडल अभी भी 13× अधिक महंगा निकलता है, क्योंकि घड़ी के पीछे का इतिहास कुछ टर्न के भीतर निर्देशों से आगे निकल जाता है. Muse Spark दूसरी तरफ दिखाता है: यह हमारे रन में हर टर्न की शुरुआत में चूक गया, इसलिए प्लेसमेंट ने वहाँ कुछ भी बचाया नहीं और हर टर्न के उद्घाटन पर पूरा मूल्य चुकाया गया, $2.1M एक वर्ष के लिए उसी ट्रैफ़िक के लिए.
लाइव ट्रैफ़िक पर, कैश हिट दर बिल का अधिकांश हिस्सा है#
हमारे माप एक नियंत्रित प्रॉम्प्ट का उपयोग करते हैं. OpenRouter वही मॉडल्स की लागत सभी के ट्रैफ़िक पर प्रकाशित करता है, और वही तंत्र वहाँ स्केल पर दिखाई देता है. लगभग सभी चीज़ें जो इन मॉडलों को भेजी जाती हैं, इनपुट हैं: 96.3% GPT-6 Luna के टोकन उसके पहले दिन पर, 98.5% Claude Opus 5.5 के और DeepSeek V4.1 Flash के, और 98.9% Muse Spark 1.3 के। इनपुट वह जगह है जहाँ कैशिंग लागू होती है, इसलिए हिट दर तय करती है कि एक व्यवसाय कितना भुगतान करता है.
ग्राहकों ने भुगतान किया $0.87 प्रति मिलियन इनपुट टोकन Claude Opus के लिए 5.5 विरुद्ध सूचीबद्ध $4.00, $0.30 विरुद्ध $1.25 Muse Spark के लिए 1.3, और $0.036 विरुद्ध $0.10 GPT-6 Luna. उसी दिन उसी मॉडल को सेवा देने वाले एंडपॉइंट्स पर, भुगतान की गई कीमत हिट दर का पालन करती है:
Claude Opus 5.5 on OpenRouter, input price actually paid by each endpoint's cache hit rate (USD per 1M tokens)Chart data
USD per 1M input tokens
92.2% hit
0.557
89.9% hit
0.658
88.7% hit
0.727
81.6% hit
0.974
77.4% hit
1.123
0% hit
4.399
Reference line, listed input price: 4
हर मिस को कैश लिखने और हर हिट को पढ़ने के रूप में मूल्य निर्धारण करने से 5 मुख्य एंडपॉइंट्स की पोस्ट की गई कीमतें 2–13% के भीतर पूर्वानुमानित होती हैं. केवल हिट दर ही अंतर को समझाती है. GPT-6 Luna पर वही पैटर्न $0.025 से एक 88.1% हिट दर पर चलती है $0.075 पर 49.4%, एक गुणक 3.
वही प्लेसमेंट निर्णय प्रत्येक प्रकार के संगठन पर अलग तरह से उतरता है जो इन APIs पर बनाता है.
हैरनेस बिल्डर्स एक बार में हर उपयोगकर्ता के लिए हिट दर सेट करते हैं। 5 ऐप्स जिन्होंने Claude Opus 5.5 को उसके पहले दिन सबसे अधिक ट्रैफ़िक भेजा, सभी एजेंट थे, प्रत्येक के बीच 2.9B और 16.3B टोकन. एक हैरनेस पर 10B इनपुट टोकन प्रति दिन उस मॉडल पर, कैश हिट दर का प्रत्येक बिंदु $175K एक वर्ष के बराबर है. ऊपर के 92.2% और 77.4% एंडपॉइंट्स के बीच का अंतर $2.07M एक वर्ष उस वॉल्यूम पर आता है. सिस्टम प्रॉम्प्ट में एक घड़ी जो हर टर्न ओपनिंग को फिर से लिखती है, लागत $1.75M और $8.76M एक वर्ष के बीच होती है, इस पर निर्भर करता है कि टर्न ओपनिंग्स 1 कॉल इन 10 या 1 इन 2 हैं. यह निर्णय भी यात्रा करता है: हर उत्पाद जो हैरनेस पर बनाया गया है, उसकी प्लेसमेंट को विरासत में लेता है. इसे लिखते समय हमने अपने दूसरे हैरनेस में वही सिस्टम-प्रॉम्प्ट घड़ी पाई, जो उसी रनर का एक पुराना बिल्ड चलाता है.
कंपनियाँ जो एक आंतरिक AI प्लेटफ़ॉर्म चलाती हैं, इसे हर टीम के लिए सेट करती हैं। एक गेटवे जो प्रत्येक अनुरोध के सिस्टम प्रॉम्प्ट को टाइमस्टैम्प या अनुरोध ID के साथ स्टैम्प करता है, ऑडिटिंग के लिए हर एप्लिकेशन के टर्न ओपनिंग्स को लिखने में बदल देता है, चाहे टीमें ऊपर क्या भी बनाती हों. लेखांकन दूसरा एक्सपोज़र है. सूची मूल्य पर चार्ज किया गया, इनपुट लागत GPT-6 Luna पर बिल से 2.8× बड़ी दिखती है, Muse Spark 1.3 पर 4.1× और Claude Opus 5.5 पर 4.6× है. हमारे अपने लेज़र ने 33 कॉल्स को 2.7× अधिक बताया, और मैं इसके आधार पर मॉडल बदलने के करीब था.
कंपनियाँ जो AI उत्पाद शिप करती हैं, हर बातचीत पर इसका भुगतान करती हैं। एक बातचीत के भीतर, गलत घड़ी लागत 5.7× प्रति टर्न. एक बाजार में, दांव बड़े होते हैं. 21 सितंबर को, Muse Spark 1.3 ने OpenRouter के माध्यम से 88.5B इनपुट टोकन लिए। सूची मूल्य पर वह $110.6K है; ग्राहकों ने $26.9K भुगतान किया, और उस ट्रैफ़िक पर हर हिट दर का बिंदु $355K एक वर्ष के बराबर है. DeepSeek V4.1 Flash ने उसी दिन 2.68T इनपुट टोकन लिए, और DeepInfra के कीमतों पर प्रत्येक बिंदु $1.33M एक वर्ष के बराबर है। ये आंकड़े एक राउटर को कवर करते हैं. ट्रैफ़िक जो सीधे प्रदाताओं को भेजा जाता है, वे उनमें दिखाई नहीं देता है.
समाधान: हर अनुरोध की शुरुआत को फ्रीज़ रखें और अंत में जो बदलता है उसे जोड़ें#
उन सभी लागतों का पता उसी तंत्र तक जाता है, और समाधान भी उसी तंत्र पर आधारित है. अच्छी तरह से बने एजेंट हैरनेस के नियम इसके परिणामों को पढ़ते हैं:
पहले स्थिर, बाद में बदलते हुए। टूल परिभाषाएँ और सिस्टम प्रॉम्प्ट पूरी बातचीत के लिए फ्रीज़ रहते हैं. समय, कार्यशील निर्देशिका, अनुरोध ID और अन्य सभी बदलने वाली चीजें नवीनतम संदेश के अंत में जाती हैं.
जोड़ें, कभी संपादित न करें। पहले के टर्न बिल्कुल वैसे ही भेजे जाते हैं जैसे थे. उन्हें संपादित करना, पुनः क्रमबद्ध करना या ट्रिम करना परिवर्तन के बाद की सभी चीजों को अमान्य कर देता है.
अपने प्रदाता के लीवर का उपयोग करें। GPT-6 Luna पर, सत्र कुंजियाँ और कैश मार्कर कुछ नहीं करते क्योंकि समान प्रॉम्प्ट पहले से ही हिट हो रहे थे. Claude Opus 5.5 पर, मार्कर पूरा तंत्र है. DeepSeek V4.1 Flash पर, प्रदाता का चयन तय करता है कि कैश मौजूद है या नहीं।
जो पहले रहना चाहिए उसे मोटा करें। सिस्टम प्रॉम्प्ट में एक तिथि पंक्ति एक दिन में एक बार टूटती है, और एक मिनट घड़ी हर बार टूटती है जब एक टर्न नए मिनट में शुरू होता है.
या घड़ी को बाहर रखें। एक हैरनेस मॉडल को ऐसा टूल दे सकता है जो समय लौटाता है, ताकि प्रॉम्प्ट कभी न बदले और मॉडल पूछे जब उसे जानना हो. यह एक राउंड ट्रिप की लागत है, उस क्षण जब प्रश्न पूछा जाता है.
बिल से निपटें। प्रदाता की रिपोर्टेड लागत से कीमतें कॉल करें. टोकन गिनती से बना एक लेजर, सूची मूल्य पर, इस सबको हमारे पास से छिपा देता है.
हिट दर पर नज़र रखें, क्योंकि जो इसे तोड़ता है वह लगातार बदलता रहता है#
ऊपर दिया गया सुधार एक ही संपादन है. इसके आसपास की शर्तें लगातार चलती रहती हैं. एक हार्नेस नया हुक प्राप्त करता है, एक गेटवे अनुरोधों को आईडी के साथ स्टैम्प करना शुरू करता है, एक टीम अलग कैश तंत्र वाले मॉडल पर जाती है, एक प्रदाता यह बदलता है कि एक निष्क्रिय प्रीफ़िक्स कितनी देर तक गर्म रहता है. यहाँ चार मॉडल चार अलग-अलग तरीकों से कैश करते हैं, और Claude Opus 5.5 ने एक कैश को निष्क्रिय समय के 10 मिनटों के भीतर ठंडा होने दिया. दूसरा हार्नेस जहाँ हमने वही घड़ी पाई, वह बस एक पुराने बिल्ड पर बना रहा. इनमें से कोई भी त्रुटि नहीं उठाता.
हर कॉल पहले से ही यह लौटाता है जो इसे देखने के लिए आवश्यक है: प्रॉम्प्ट टोकन, कैश्ड टोकन, कैश‑राइट टोकन और बिल्ड लागत. प्रति कॉल रिकॉर्ड किया गया, साथ ही यह कि कॉल ने एक टर्न खोला या जारी रखा, ये फ़ील्ड हर रूट और मॉडल के लिए तीन संख्याएँ देते हैं जिन्हें देखना चाहिए:
टर्न‑ओपनिंग रीड रेट। टर्न ओपनिंग का वह हिस्सा जो संग्रहीत प्रीफ़िक्स पढ़ता है. गलत स्थान पर घड़ी ने इसे हमारे रन में 12 के 12 से 0 के 12 तक ले गया.
लिखने का हिस्सा। सभी इनपुट का कैश‑राइट टोकन के रूप में हिस्सा. एक रूट जो हर टर्न पर लिखता है वह 1.25× का भुगतान करता है और कभी छूट नहीं लेता.
सूची के विरुद्ध प्रभावी इनपुट मूल्य। बिल का स्वयं का निर्णय, प्रदाता की रिपोर्ट की गई लागत से निपटाया गया न कि टोकन गिनती से.
उन संख्याओं पर एक सीमा अचानक गिरावट को पकड़ती है. डेटा के हफ्तों में कारण का नामकरण एक वर्गीकरण समस्या है, और मॉडल का एक नया वर्ग इसे सूट करता है. Jev, TypeSafe से, वह है जिसे उसके निर्माता System One एक मॉडल कहते हैं. यह पाठ उत्पन्न नहीं करता. यह एक स्थिति और टाइप किए गए प्रश्न लेता है और टाइप किए गए उत्तरों को एक प्रायिकता वितरण और आत्मविश्वास के साथ लौटाता है: विकल्पों में से एक चयन, हाँ की प्रायिकता, या एक क्रमबद्ध पैमाने पर स्थिति. एक मार्ग के दैनिक कैश प्रोफ़ाइल को देखते हुए, यह दिन के मेल खाते पैटर्न का नाम दे सकता है (स्वस्थ, टर्न ओपनिंग्स का पुनर्लेखन, टर्न के बीच कैश समाप्त होना, ट्रैफ़िक एक ऐसे एंडपॉइंट तक पहुँचता है जो कैश नहीं करता) और यह कितना सुनिश्चित है, यह कह सकता है, ताकि श्रेणी में बदलाव अलर्ट बन जाए. हम इसे उत्पादन में दस्तावेज़ों को वर्गीकृत करने के लिए उपयोग करते हैं और, अवलोकन में, समाप्त एजेंट एपिसोड को स्कोर करने के लिए. OpenRouter इसे $0.042 प्रति मिलियन इनपुट टोकन पर सूचीबद्ध करता है, आउटपुट के लिए कोई शुल्क नहीं. उस कीमत पर, प्रत्येक 1,000 मार्ग के लिए एक 2K-टोकन दैनिक प्रोफ़ाइल को वर्गीकृत करने की लागत लगभग $31 प्रति वर्ष है, जबकि ऊपर दिए गए हार्नेस स्केल पर एकल हिट दर बिंदु के लिए $175K प्रति वर्ष है.
एक प्रणाली जो अपने कैश को लगातार पुनर्लेखन करती है, हर बातचीत के हर टर्न पर प्रीमियम का भुगतान करती है, जितना समय तक यह चलती है, और बिल शायद ही कभी बताता है क्यों. सुधार उतना छोटा हो सकता है जितना समय लिखा गया है. इसे स्थिर रखना किसी को देखने के लिए एक संख्या लेता है.
ऊपर के हर मापे गए आंकड़े OpenRouter के अपने प्रति-काल फ़ील्ड (कैश्ड टोकन, कैश-राइट टोकन और बिल्ड लागत) से आते हैं, 23 सितंबर, 2026 को। बाज़ार के आंकड़े OpenRouter के सार्वजनिक मॉडल पृष्ठों से आते हैं, उसी दिन पढ़े गए: वास्तव में भुगतान की गई भारित इनपुट कीमत, प्रत्येक एंडपॉइंट की प्रभावी कीमत और कैश हिट रेट, और प्रति मॉडल एक दिन का टोकन गतिविधि। Claude Opus 5.5 और GPT-6 Luna 22 सितंबर को लॉन्च हुए, इसलिए उनकी गतिविधि के आंकड़े एक आंशिक प्रथम दिन को कवर करते हैं, और लेख उन्हें केवल शेयरों के रूप में उपयोग करता है. प्रयोगों की लागत कुल $0.63 थी, और प्रॉब ने खाता उपयोग के $1 कैप के करीब पहुँचने पर शुरू होने से इनकार कर दिया. कीमतें OpenRouter की सूचीबद्ध कीमतें हैं, उसी दिन पढ़ी गई। OpenRouter का कैशिंग गाइड OpenAI कैश रीड्स को 0.25–0.50× पर सूचीबद्ध करता है; GPT-6 Luna ने अपने रीड्स को 0.10× पर बिल किया, और यह लेख बिल किए गए को रिपोर्ट करता है।
अभी भी खुला है: प्रत्येक मॉडल के निष्क्रिय कैश के समाप्त होने का सटीक बिंदु, जो एकल समयबद्ध रन केवल सीमाबद्ध करते हैं; वास्तविक बातचीत के अंतराल पर एक घंटे या दिन की घड़ी कितनी बार टूटती है; क्यों Muse Spark प्रत्येक टर्न की शुरुआत में चूक गया जब इसका इतिहास अपरिवर्तित था; और DeepSeek का अपने स्वयं के एंडपॉइंट पर व्यवहार। प्रति-टर्न सुधार हमारे उत्पादन एजेंट में लाइव है, और वही खोज एक दूसरे हार्नेस के लिए कतारबद्ध की गई है जो उसी रनर का पुराना बिल्ड चलाता है.
मैंने। लेख के पीछे का सवाल: क्यों AI कभी तारीख और समय को अच्छी तरह नहीं जानता था, और इसे कहने में सेकंड लगते थे जब इसे तुरंत होना चाहिए था. यह विचार कि समय सत्र के दौरान पुराना हो जाता है और फिर से प्रदान किया जाना चाहिए, मेरा अनुमान कि एक निर्धारक, केवल-जब-पुराना संदेश प्रॉम्प्ट को कैश्ड छोड़ देगा, और इसे प्रयोग से परीक्षण करने का कॉल. लागत फ्रेमिंग: इन मॉडलों पर आधारित व्यवसायों के लिए मापी गई, बिल्डर से लेकर अपनी स्वयं की आंतरिक AI प्लेटफ़ॉर्म चलाने वाली कंपनियों तक, जैसा कि आज है और जैसे-जैसे यह बढ़ता है. चल रही अवलोकन पर समापन, System One मॉडल जैसे Jev के साथ, समय के साथ कैश प्रोफ़ाइल को वर्गीकृत करना, क्योंकि सुधार केवल तब तक रहता है जब तक कोई देखता रहता है.
Claude Opus 5.5 द्वारा। इसने पाया कि हमारी लागत लेज़र कैशिंग को छिपा रही थी, 2.7× 33 कॉल पर, और कारण को 2 लाइनों में ट्रेस किया जो हर टर्न में बदलती थीं. इसने रनर सुधार बनाया जो अब उत्पादन में है, प्रॉब, विश्लेषण, और हर संख्या के पीछे लागत मॉडल, और OpenRouter के सार्वजनिक बाज़ार आंकड़ों के खिलाफ तंत्र को मिलाया। 4 मॉडलों में, इसने 3 अलग कैश व्यवहार पहचाने, GPT-6 Luna के पूरे-मैसेज व्यवहार सहित, और एक चौथा मॉडल बिना उपयोगी कैश के.
रहने वाले आलोचनाएँ।
Claude Opus 5.5 से, उसके अपने पहले स्पष्टीकरण: एक गायब सत्र कुंजी. उसके प्रॉब ने इसे खारिज किया; समान प्रॉम्प्ट पहले से ही कैश से पढ़े गए थे टर्न्स के बीच.
Claude Opus 5.5 के मापों से, मेरे अनुमान के अनुसार: अलग समय संदेश केवल तब काम करता है जब यह स्थिर निर्देशों के बाद आता है. लेख मेरे विचार को उस शर्त के साथ ले जाता है.
साथ में पहुँचे। यह खोज कि एक घड़ी का कोई लागत नहीं होता जब तक उसका पाठ बदलता नहीं, और फिर पूरे प्रॉम्प्ट की लागत होती है. और नियम जिसे लेख चालू करता है: जो कुछ भी टर्न्स के बीच बदलता है वह सब कुछ जो नहीं बदलता उसके बाद जाता है.