AI एजेंट इतने टोकन क्यों उपयोग करते हैं (20-चरणीय उदाहरण)

आप एक एजेंट से एक सवाल पूछते हैं, वह कुछ मिनटों तक काम करता है, और उपयोग पृष्ठ पर सैकड़ों हज़ार टोकन दिखते हैं। कुछ भी टूटा नहीं है। एक एजेंट एक लूप है, और लूप के हर मोड़ पर अब तक कही गई हर बात (टूल सूची, इतिहास, जो भी टूल ने लौटाया) इनपुट टोकन के रूप में फिर से भेजी जाती है। जो जवाब वह लिखता है वह छोटा होता है। जो वह बार-बार पढ़ता है वह छोटा नहीं होता।

एक तस्वीर में एजेंट क्या है#

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

Anthropic के टूल-उपयोग दस्तावेज़ (26 अक्टूबर 2026 को जाँचा गया) लूप का वर्णन इस तरह करते हैं:

1. आपका ऐप उपयोगकर्ता संदेश और टूल्स की सूची भेजता है।
2. मॉडल stop_reason: "tool_use" और एक tool_use ब्लॉक के साथ जवाब देता है: कौन सा टूल, किन तर्कों के साथ।
3. आपका ऐप टूल चलाता है और दूसरा अनुरोध भेजता है। इसमें पहले के संदेश, मॉडल का टूल कॉल, एक tool_result ब्लॉक और वही टूल्स सूची होती है।
4. मॉडल जवाब देता है, या एक और टूल माँगता है, और लूप फिर से चलता है।

वही पृष्ठ कहता है कि टूल-उपयोग अनुरोधों का बिल भेजे गए कुल इनपुट पर लगता है, जिसमें टूल्स पैरामीटर भी शामिल है, साथ ही आउटपुट पर। तो चरण 3 कभी भी "सिर्फ नया हिस्सा" नहीं होता: यह पूरी बातचीत फिर से होती है।

Request 1  tools + system + task
Request 2  tools + system + task + call 1 + result 1
Request 3  tools + system + task + call 1 + result 1 + call 2 + result 2
...

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

हर कदम पर तीन चीज़ें साथ चलती हैं#

टूल सूची। हर टूल के नाम, विवरण और पैरामीटर स्कीमा हर अनुरोध में जाते हैं, भले ही मॉडल इस बार उनमें से कोई भी उपयोग न करे। दस्तावेज़ एक छोटा अतिरिक्त जोड़ते हैं: टूल्स चालू होने पर, API अपना खुद का टूल-उपयोग प्रॉम्प्ट जोड़ता है, Claude Sonnet 5.5, Opus 5.5 और Haiku 5.5 पर 286 टोकन, और अन्य मॉडलों की संख्याएँ अलग होती हैं।

इतिहास। आपका कार्य, मॉडल के पहले के टूल कॉल, उसके नोट्स।

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

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

20-चरणीय रन, गिना गया#

मान लें कि आप तीन टूल्स (एक फ़ाइल पढ़ना, खोजना, टेस्ट चलाना) के साथ एक छोटा कोडिंग एजेंट चलाते हैं और उसे एक कार्य देते हैं जिसमें 20 कदम लगते हैं। ये मान लें:

• टूल परिभाषाएँ: 1,500 टोकन, सिस्टम प्रॉम्प्ट: 500, आपका कार्य: 200, तो हर अनुरोध 2,200 टोकन से शुरू होता है;
• हर कदम पर मॉडल 150 टोकन का एक टूल कॉल लिखता है, और टूल 800 टोकन लौटाता है;
• दोनों इतिहास में जुड़ते हैं, तो हर कदम अगले अनुरोध में 950 टोकन जोड़ता है।

रन का कुल योग पाने के लिए, सभी 20 अनुरोधों को जोड़ें। 2,200 का आधार 20 बार भेजा जाता है, और राउंड बाद के चरणों द्वारा आगे बढ़ाए जाते हैं: चरण 1 कोई नहीं ले जाता, चरण 2 एक, और इसी तरह 19 तक, जो कुल मिलाकर 190 राउंड हैं।

20 × 2,200 = 44,000

950 × 190 = 180,500

44,000 + 180,500 = 224,500 इनपुट टोकन, और 20 × 150 = 3,000 आउटपुट टोकन।

एजेंट ने 3,000 टोकन लिखे और 224,500 पढ़े। आउटपुट टोकन की लागत प्रत्येक इनपुट टोकन से अधिक होती है (देखें इनपुट बनाम आउटपुट टोकन), लेकिन वे इतने कम हैं कि बिल अभी भी इनपुट पक्ष तय करता है। यहाँ वर्तमान कीमतों पर वह रन है:

DeepSeek-V4-Flash पर ऐसा एक रन $0.0037 आता है, GLM-5.3-Flash पर $0.0046। सौ रन 22,450,000 इनपुट और 300,000 आउटपुट टोकन हैं: DeepSeek-V4-Flash पर $0.367। ऊपर की तालिका इनपुट और आउटपुट को एक साथ गिनती है, और कुल मिलाकर वहाँ के मॉडल OpenRouter से सस्ते निकलते हैं।

चरणों की संख्या जितनी दिखती है उससे अधिक मायने रखती है। उन्हीं मान्यताओं के साथ 5-चरणीय रन:

5 × 2,200 = 11,000

950 × 10 = 9,500

11,000 + 9,500 = 20,500 इनपुट टोकन। चार गुना चरणों ने लगभग ग्यारह गुना इनपुट दिया, क्योंकि हर नया चरण सभी पुराने चरणों को भी फिर से पढ़ता है।

कहाँ काटें: चार आदतें#

एक टूल परिणाम बचाने की सबसे आसान जगह है। मान लें कि चरण 3 पर एक टेस्ट रन 4,000-टोकन का लॉग लौटाता है। फिर इसे बाद के 17 अनुरोधों द्वारा फिर से भेजा जाता है:

• पहले: 4,000 × 17 = 68,000 इनपुट टोकन उस एक लॉग द्वारा ले जाए गए;
• बाद में, यदि टूल केवल 40 प्रासंगिक पंक्तियाँ लौटाता है (लगभग 400 टोकन): 400 × 17 = 6,800।

वही कार्य, वही जवाब, उस एक परिणाम से इनपुट का दसवाँ हिस्सा। इससे चार आदतें मिलती हैं:

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

अपना खुद का रन गिनें#

हर प्रतिक्रिया बताती है कि उसने कितने टोकन अंदर लिए और बाहर दिए, अपने usage फ़ील्ड में। उन्हें सभी चरणों में जोड़ें और आपके पास मेरी मान्यताओं के बजाय आपके एजेंट के वास्तविक आँकड़े होंगे। CheapTokens की ओर इंगित OpenAI Python SDK के साथ एक रूपरेखा (messages और tools आपके एजेंट के अपने हैं):

from openai import OpenAI

client = OpenAI(base_url="https://api.cheaptokens.dev/v1", api_key="YOUR_API_KEY")

total_in = total_out = 0
for step in range(20):  # your agent loop
    resp = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash-0731",
        messages=messages,
        tools=tools,
    )
    total_in += resp.usage.prompt_tokens
    total_out += resp.usage.completion_tokens
    # ...run the tool, append the result to messages

print(total_in, total_out)

दोनों कुल सीधे ऊपर की लागत तालिका में लगते हैं। इस तरह के लंबे इतिहास के लिए, DeepSeek-V4-Flash आपको 380K संदर्भ विंडो और प्रति उत्तर अधिकतम 32,768 आउटपुट टोकन देता है, किसी भी घंटे एक ही कीमत पर; GLM-5.3-Flash में 390K संदर्भ और अधिकतम 8,192 आउटपुट टोकन हैं। सेटअप दस्तावेज़ों में है, हर मॉडल की वर्तमान कीमत मूल्य निर्धारण पृष्ठ पर है, और मॉडल का अपना पृष्ठ है, सस्ता DeepSeek।