← सभी लेख

मापन

Claude Code की असल लागत: टोकन कहाँ जाते हैं

प्लान की तालिका प्राइसिंग वाले सवाल का आसान आधा हिस्सा है। महँगा आधा यह है कि एक सेशन आपके कॉन्टेक्स्ट के साथ टर्न दर टर्न क्या करता है — और उस हिस्से को गिना जा सकता है।

यह लेख Ted Mavera द्वारा लिखा गया है, जो HarnessUp में Product Manager हैं — वही कंपनी जो यहाँ बताया गया टूल बनाती है। इस ब्लॉग के पाठ कृत्रिम बुद्धिमत्ता की सहायता से लिखे जाते हैं और प्रकाशन से पहले टीम द्वारा समीक्षित होते हैं।

धातु की मशीन चमकते बैंगनी द्वार से पन्नों को लूप में भेज रही है, बगल में कैश किए पन्नों की काँच की दराज़, और फ़र्श पर एक ही पन्ना पड़ा है।

यह लेख क्यों मौजूद है

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

दूसरे सवाल का जवाब गणित में है, और वह जवाब पहले से आपकी मशीन पर है। यह लेख उसी पर चलता है: एक टर्न वास्तव में क्या दोबारा भेजता है, बिल की चार पंक्तियों में से कौन-सी हावी है, और साधारण काम में बर्बादी कहाँ छिपी है। हम उत्पाद को आख़िरी एक-तिहाई तक रास्ते से हटाकर रखेंगे, क्योंकि तरीक़ा उसके बिना भी टिकता है — और क्योंकि ऐसा लागत-विश्लेषण, जो केवल तब काम करे जब आप कुछ ख़रीदें, विश्लेषण नहीं है।

वह एक गुणा जो पूरा बिल समझाता है

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

8,000 tokens × 30 turns = 240,000 token-turns
15,000 tokens × 37 turns = 555,000 token-turns

इसे दो बार पढ़िए, क्योंकि यह उस सहज बोध को उलट देता है जो ज़्यादातर लोग यहाँ लेकर आते हैं। कम कोड लिखने वाला औज़ार सबसे ज़्यादा बचाने वाला नहीं होता। जो कॉन्टेक्स्ट से वह हटा देता है जो पहले ही इस्तेमाल हो चुका है, वही सबसे ज़्यादा बचाता है। टर्न 4 पर आई और कभी न जाने वाली 15k की फ़ाइल, टर्न 1 पर आई 8k की फ़ाइल से तीन गुना से अधिक महँगी है — और लोग आम तौर पर दूसरी वाली को ही अनुकूलित करने की कोशिश करते हैं।

चार पंक्तियाँ, एक नहीं: बिल किससे बना है

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

यही समय-सीमा वह हिस्सा है जिसे ज़्यादातर प्राइसिंग पोस्ट छोड़ देते हैं। प्रॉम्प्ट कैश एक छोटी अवधि का पट्टा है, और उसके व्यतीत होते ही मीटर रीसेट हो जाता है। Utilities डेमो में कैश टाइमर ठीक इसी के लिए मौजूद है: वह दिखाता है कि कुछ निष्क्रिय मिनटों के बाद गरम कैश ठंडा हो जाता है, ताकि आप वह पल देख सकें जब एक लंबा लंच चुपचाप आपके अगले टर्न की क़ीमत बढ़ा देता है। प्रतिशत क़ीमत-सूची के साथ बदलते हैं; तंत्र नहीं बदलता।

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

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

टोकन असल में कहाँ जाते हैं

एक सामान्य कार्यदिन के ज़्यादातर बचाव-योग्य भार के लिए पाँच श्रेणियाँ ज़िम्मेदार होती हैं। इनमें से कोई भी असामान्य नहीं है। सभी बाद में स्थानीय ट्रांसक्रिप्ट में दिखाई देती हैं।

1. वह कॉन्टेक्स्ट जो बार-बार पढ़ा जाता रहता है

आपका भेजा हर संदेश पूरी बातचीत को अपने पीछे खींच लाता है। टर्न 40 पर, टर्न 3 पर खोली गई फ़ाइल अब भी ट्रेन पर चढ़ी है, अब भी सीट ले रही है, अब भी बिल में जुड़ रही है। सामान्य समाधान — नया सेशन — काम करता है, पर लोग ग़लत पल चुनते हैं: वे तब रीस्टार्ट करते हैं जब बातचीत लंबी लगने लगती है, न कि तब जब प्रति-राउंड लागत कॉन्टेक्स्ट दोबारा बनाने की लागत से ऊपर चली जाती है। ये अलग-अलग बिंदु हैं, और इनमें से सिर्फ़ एक वह है जहाँ नवीनीकरण फ़ायदेमंद है।

2. एक फ़ंक्शन के लिए पूरी फ़ाइल

किसी एजेंट से validate() ठीक करने को कहना आम तौर पर पूरी auth.ts पहुँचा देता है। फिर पूरी फ़ाइल बाक़ी टर्नों तक कॉन्टेक्स्ट में बनी रहती है, जिसका ज़्यादातर हिस्सा अप्रासंगिक है। वही बर्बादी दूसरी दिशा में भी दिखती है: ऐसी खोज जो छह सौ मिलती पंक्तियाँ लौटा दे, जबकि पहली बीस पंक्तियाँ निर्णय लेने के लिए काफ़ी थीं।

3. टूल का वह आउटपुट जिसे कोई नहीं पढ़ता

एक टेस्ट रन जो नौ सौ पंक्तियाँ छापता है, किसी मोनोरेपो का बिल्ड लॉग, एक पैरामीटर जाँचने के लिए लाए गए दस्तावेज़ीकरण पृष्ठ का HTML। ट्रांसक्रिप्ट यह सब रख लेता है। मॉडल अगले टर्न पर यह सब पढ़ता है, चाहे उसे ज़रूरत हो या न हो।

4. यह पता लगाने में गए टर्न कि कोड कंपाइल नहीं होता

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

5. प्रस्तावना वाला जवाब

"शानदार सवाल — चलिए, मैं बताता हूँ कि मैं क्या करने जा रहा हूँ।" यह एक बार आउटपुट टोकन में चुकाया जाता है और उसके बाद हर टर्न पर इनपुट टोकन में, क्योंकि जवाब अब इतिहास का हिस्सा है। एक आदत को चालीस टर्नों से गुणा कीजिए और वह बिल की एक पंक्ति बन जाती है।

प्लान टियर क्या बदलता है, और क्या नहीं

Claude Code के प्लान विंडो में मापे जाते हैं — पाँच घंटे के ब्लॉक और एक साप्ताहिक सीमा — और यही ढाँचा प्राइसिंग वाली बहस को गोल-गोल घुमाता रहता है। बड़ा प्लान ऊँची क़ीमत पर अधिक जगह ख़रीदता है। यह उस तथ्य को नहीं बदलता कि 15k की फ़ाइल हर टर्न पर 15k की पड़ती है, और यह दोबारा पढ़ाई को सस्ता नहीं बनाता। काफ़ी बार अपग्रेड करते जाइए और बर्बादी प्लान के साथ बढ़ती जाएगी।

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

कुछ भी तय करने से पहले मापिए

यह लेख इसलिए विशिष्ट हो सकता है क्योंकि संख्याएँ स्थानीय हैं। Claude Code ट्रांसक्रिप्ट डिस्क पर लिखता है, प्रति टर्न वास्तविक टोकन उपयोग के साथ, और एक मापन परत उन्हें कहीं भी कुछ भेजे बिना पढ़ सकती है। हमारा Metering फ़्रंट इसी के लिए है और मुफ़्त है: Deep Scan सहेजी गई बातचीतों को पढ़कर ख़र्च को स्रोत के हिसाब से बाँटता है, Harness History हर बंद सेशन की रसीद खोलता है, Inside the Wallet नए इनपुट, कैश रीड, कैश राइट और आउटपुट को मॉडल के अनुसार अलग करता है, और Plan Usage दिखाता है कि सीमा नवीनीकृत होने से पहले हर विंडो ने क्या दिया।

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

HarnessUp कहाँ फ़िट होता है

यह वह हिस्सा है जहाँ हम कुछ बेचते हैं, इसलिए वह संख्या और ज़रूरी प्लान के साथ आता है। HarnessUp एक स्थानीय परत है जो Claude Code और Codex के आधिकारिक हुक्स के ज़रिए काम करती है — प्रॉक्सी नहीं, MCP सर्वर नहीं, ऐसा कुछ नहीं जो आपका टोकन या कुंजी पढ़े। इसमें दस फ़्रंटों में 151 टूल हैं, और Savings फ़्रंट का बड़ा हिस्सा ऊपर की पाँच श्रेणियों से एक-के-एक मेल खाता है।

Renew Session उस टर्न को चिह्नित करता है जहाँ जारी रखना दोबारा शुरू करने से महँगा पड़ता है, और वास्तविक इतिहास पर मापे गए एक counterfactual में यह बदलाव चुकाए गए कॉन्टेक्स्ट के 73% तक पहुँचा। Code Finder बड़ी फ़ाइल का ढाँचा पहली पढ़ाई में लौटाता है और मुख्य भाग केवल माँगने पर; Delta Read फ़ाइल के उस हिस्से से इनकार करता है जिसे एजेंट पहले ही देख चुका है; Head Limit ऐसे grep पर सीमा लगाता है जो एक विश्वकोश लौटा देता है; Terminal Guide और Output Diet लंबे लॉग की शुरुआत, अंत और त्रुटि वाली पंक्तियाँ रखते हैं। First Pass संपादन के तुरंत बाद कंपाइल करता है, ताकि टूटा हुआ बिल्ड अगले टर्न के साथ चले, न कि अपना एक टर्न ले। Response Diet तैयारी का पाठ काट देता है। Memory State कॉन्टेक्स्ट फ़ाइल को अपरिवर्तनीय खंडों में घुमाता है और 298 टर्न तक टिके रहने के साथ कॉन्टेक्स्ट का 4.27% मापा।

हमारी सबसे बड़ी संख्या कम चमकदार और ज़्यादा उपयोगी है: Build Now, जो संदेश के अंत में बिना कोई मॉडल टर्न ख़र्च किए बिल्ड चलाता है, उसने 2,769 बिल्ड और 806.7M इनपुट टोकन दर्ज किए जो दोबारा नहीं पढ़े गए। इनमें से कोई भी संख्या आपकी नहीं है। ये वही हैं जो उपकरण ने उन मशीनों पर मापीं जिन्होंने उसे चलाया, और counterfactual पेश करने का यही ईमानदार तरीक़ा है — और इसीलिए पैनल आपकी अपनी कटौतियाँ अनुमान से अलग दिखाता है।

यह विश्लेषण क्या वादा नहीं करता

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

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

अपने बिल से शुरू करें। HarnessUp मुफ़्त में इंस्टॉल करें, पिछले हफ़्ते के सेशनों पर Deep Scan चलाएँ, और वह एक पंक्ति खोजें जो वहाँ नहीं होनी चाहिए।

मुफ़्त में इंस्टॉल करें