Bakit gumagamit ng napakaraming token ang mga AI agent (isang 20-hakbang na halimbawa)

Magtatanong ka sa isang agent ng isang tanong, gagana ito nang ilang minuto, at ang usage page ay magpapakita ng daan-daang libong token. Walang sira. Ang agent ay isang loop, at sa bawat pag-ikot nito ay ipinapadala muli ang lahat ng nasabi na (ang listahan ng tool, ang history, anuman ang ibinalik ng mga tool) bilang input tokens. Ang isinulat nitong sagot ay maliit. Ang binabasa nito nang paulit-ulit ay hindi.

Ano ang agent, sa isang larawan#

Ang chat model ay sumasagot nang isang beses. Ang agent ay ang parehong modelo sa loob ng isang loop na may mga tool: magbasa ng file, maghanap sa web, magpatakbo ng command. At ang modelo ay walang natatandaan sa pagitan ng mga tawag. Isipin ang isang assistant na nakakalimot sa lahat ng bagay sa tuwing ibinababa nila ang tawag: sa tuwing tumatawag silang muli, binabasa mo ang mga tala mula sa simula, pagkatapos ay magdadagdag ng isang linya. Ganyan gumagana ang API.

Ang tool-use docs ng Anthropic (sinuri noong 26 Oktubre 2026) ay inilalarawan ang loop nang ganito:

1. Ipinapadala ng iyong app ang mensahe ng user at ang listahan ng mga tool.
2. Sumasagot ang modelo ng stop_reason: "tool_use" at isang tool_use block: aling tool, at anong mga argumento.
3. Pinapatakbo ng iyong app ang tool at nagpapadala ng pangalawang request. Naglalaman ito ng mga naunang mensahe, ang tool call ng modelo, isang tool_result block at ang parehong listahan ng tool.
4. Sumasagot ang modelo, o humihingi ng isa pang tool, at umiikot muli ang loop.

Sinasabi rin ng parehong pahina na ang mga tool-use request ay sinisingil batay sa kabuuang input na ipinadala, kasama ang tools parameter, at ang output. Kaya ang hakbang 3 ay hindi kailanman "ang bagong bahagi lang": ito ang buong usapan muli.

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
...

Ito ang parehong mekanismo tulad ng sa bakit mas mahal ang mahabang chat, mas mabilis lang. Ang chat ay lumalaki ng isang mensahe kapag nagta-type ka. Ang agent ay lumalaki ng dalawang block sa bawat hakbang, at walang nagta-type ng kahit ano.

Tatlong bagay ang sumasama sa bawat hakbang#

Ang listahan ng tool. Mga pangalan, paglalarawan at parameter schema ng bawat tool ay pumapasok sa bawat request, kahit na wala sa mga ito ang gamitin ng modelo sa turn na ito. Nagdadagdag ang docs ng maliit na dagdag: kapag naka-on ang mga tool, nagdadagdag ang API ng sarili nitong tool-use prompt, 286 token sa Claude Sonnet 5.5, Opus 5.5 at Haiku 5.5, at ang ibang mga modelo ay may ibang bilang.

Ang history. Ang iyong gawain, ang mga naunang tool call ng modelo, ang mga tala nito.

Output ng tool. Ito ang palihim. Isang file na binasa ng agent, isang pahina ng resulta ng paghahanap, isang test log: kapag napunta na ito sa history, binabayaran itong muli sa bawat susunod na hakbang.

Ang token ay isang maliit na piraso ng teksto, humigit-kumulang isang maikling salita o bahagi nito, at ang bawat isa sa tatlong ito ay binibilang dito.

Isang 20-hakbang na run, binilang#

Sabihin nating nagpapatakbo ka ng maliit na coding agent na may tatlong tool (magbasa ng file, maghanap, magpatakbo ng tests) at bibigyan mo ito ng gawaing tumatagal ng 20 hakbang. Kunin ang mga assumption na ito:

• mga depinisyon ng tool: 1,500 token, system prompt: 500, ang iyong gawain: 200, kaya bawat request ay nagsisimula sa 2,200 token;
• sa bawat hakbang, ang modelo ay nagsusulat ng tool call na 150 token, at ang tool ay nagbabalik ng 800 token;
• pareho silang sumasama sa history, kaya bawat hakbang ay nagdadagdag ng 950 token sa susunod na request.

Para makuha ang kabuuan ng run, pagsamahin ang lahat ng 20 request. Ang base na 2,200 ay ipinapadala ng 20 beses, at ang mga round ay dinadala ng mga susunod na hakbang: ang hakbang 1 ay walang dinadala, ang hakbang 2 ay isa, at iba pa hanggang 19, na 190 round sa kabuuan.

20 × 2,200 = 44,000

950 × 190 = 180,500

44,000 + 180,500 = 224,500 input token, at 20 × 150 = 3,000 output token.

Ang agent ay nagsulat ng 3,000 token at nagbasa ng 224,500. Ang output token ay mas mahal bawat isa kaysa sa input token (tingnan ang input vs output tokens), ngunit napakakaunti nila kaya ang input side pa rin ang nagtatakda ng bayarin. Narito ang run na iyon sa kasalukuyang mga presyo:

Sa DeepSeek-V4-Flash, ang isang ganoong run ay nagkakahalaga ng $0.0037, sa GLM-5.3-Flash ay $0.0046. Ang isang daang run ay 22,450,000 input at 300,000 output token: $0.367 sa DeepSeek-V4-Flash. Ang talahanayan sa itaas ay binibilang ang input at output nang magkasama, at sa kabuuan ang mga modelo doon ay mas mura kaysa sa OpenRouter.

Mas mahalaga ang bilang ng hakbang kaysa sa itsura nito. Isang 5-hakbang na run na may parehong mga assumption:

5 × 2,200 = 11,000

950 × 10 = 9,500

11,000 + 9,500 = 20,500 input token. Apat na beses ang mga hakbang ay nagbigay ng mga labing-isang beses na input, dahil ang bawat bagong hakbang ay nagbabasa muli ng lahat ng luma.

Saan magbawas: apat na ugali#

Ang isang resulta ng tool ay ang pinakamadaling lugar para makatipid. Sabihin nating ang isang test run sa hakbang 3 ay nagbabalik ng 4,000-token na log. Ito ay ipapadala muli ng 17 request na sumusunod:

• bago: 4,000 × 17 = 68,000 input token na dinadala ng isang log na iyon;
• pagkatapos, kung ang tool ay nagbabalik lamang ng 40 kaugnay na linya (mga 400 token): 400 × 17 = 6,800.

Parehong gawain, parehong sagot, isang ikasampu ng input mula sa isang resultang iyon. Nagbibigay ito ng apat na ugali:

• Magbalik ng mas kaunti mula sa mga tool. Mga linyang nakapalibot sa error, hindi ang buong log; ang function, hindi ang buong file. May mas mahabang talakayan sa pag-iingat ng output ng tool sa labas ng context.
• Bigyan ang agent ng mas kaunting tool. Bawat depinisyon ay sumasama sa bawat request.
• Takdaan ang mga hakbang at magsimula ng bagong gawain kapag hindi na mahalaga ang lumang history.
• Pagsamahin ang usage ng bawat hakbang, at itigil ang run sa budget na pinili mo nang maaga. Para sa estimating side, tingnan ang paano tantiyahin ang gastos ng isang AI agent.

Bilangin ang sarili mong run#

Bawat response ay nag-uulat kung gaano karaming token ang ipinasok at inilabas nito, sa field nitong usage. Pagsamahin ang mga ito sa lahat ng hakbang at mayroon ka nang tunay na numero para sa iyong agent sa halip na mga assumption ko. Isang sketch gamit ang OpenAI Python SDK na nakaturo sa CheapTokens (messages at tools ay sarili ng iyong agent):

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)

Ang dalawang kabuuan ay direktang naipapasok sa talahanayan ng gastos sa itaas. Para sa mahahabang history na tulad nito, ang DeepSeek-V4-Flash ay nagbibigay sa iyo ng 380K context window at hanggang 32,768 output token bawat sagot, sa isang presyo sa anumang oras; ang GLM-5.3-Flash ay may 390K context at hanggang 8,192 output token. Ang setup ay nasa docs, ang kasalukuyang presyo ng bawat modelo ay nasa pricing page, at ang modelo ay may sariling pahina, cheap DeepSeek.