BroadRouter

Magkano ang isang run ng AI coding agent: hakbang, context, caching

Ng BroadNet Inference team · 7 minutong basa · Nailathala

Ipinapadala ulit ng agent ang buong context nito sa bawat hakbang, kaya lumalaki ang input ayon sa square ng bilang ng hakbang: mga 3.5 beses ng input ng 30 hakbang ang 60 hakbang. Caching ang nagdedesisyon sa karamihan ng bill; sa append-only na history, higit 90% ng input ang puwedeng masingil sa cached rate. I-multiply ang gastos kada run sa buwanang bilang ng run at ikumpara sa flat session.

Hindi nagbabayad kada task ang coding agent. Kada hakbang ito nagbabayad, at ipinapadala ulit ng bawat hakbang ang buong usapan hanggang ngayon. Dahil diyan, mas nakadepende ang gastos ng isang run sa kung ilang hakbang ang kinailangan nito, at sa kung gaano kalaki ng context ang naka-cache, kaysa sa presyo kada token. Binubuo ng post na ito ang gastos ng isang run mula sa mga bahaging iyon, may mga numero, at ipinapakita kung kailan mas sulit ang flat session kaysa magbayad kada token.

Para sa pinanggagalingan ng mga token sa loob ng bawat tawag (tool schema, pagbasa ng file, history), tingnan ang saan napupunta ang token ng agent loop. Ang post na ito ay tungkol sa aritmetika ng buong run.

Paano lumalaki ang context habang tumatakbo ang agent?

Bawat tawag ay naglalaman ng:

  • base context na ipinapadala sa bawat tawag: system prompt, tool definition, mga rules file, repo map;
  • lahat ng idinagdag ng mga naunang hakbang: mga sagot at tool call ng model, laman ng file at output ng command;
  • ang bagong instruction o resulta ng tool.

Tawagin nating B ang base context at g ang mga token na idinadagdag ng bawat hakbang. B ang ipinapadala ng hakbang 1. B + g ang hakbang 2. B + (n − 1) × g ang hakbang n. Pagsamahin ang lahat, at ang run na may n hakbang ay nagpapadala ng:

Kabuuang input = n × B + g × n × (n − 1) ÷ 2

Lumalaki ang ikalawang termino ayon sa square ng bilang ng hakbang. Kaya nagugulat ang mga tao sa mahahabang run: mas malaki nang husto ang huling hakbang ng 60-hakbang na run kaysa sa una, at bawat hakbang sa pagitan ay nagbabayad ulit para sa lahat ng nauna.

Ano ang itsura ng isang halimbawang run?

Halimbawa, agent na may 15,000-token na base context (system prompt, isang dosenang tools at repo map). Bawat hakbang ay nagdadagdag ng 3,000 token: isang file o test log at ang sariling sagot ng model. Bawat hakbang ay nagsusulat ng 800 output token, kasama ang reasoning.

Hakbang Kabuuang input Output Pinakamalaking tawag
10 285,000 8,000 42,000
30 1,755,000 24,000 102,000
60 6,210,000 48,000 192,000

Mula 30 hanggang 60 hakbang, doble ang trabaho pero mga 3.5 beses ang input. Doble lang ang output. Sa mga run na ito, 36 hanggang 130 beses ng output ang input, kaya ang presyo ng input, at ang presyo ng cached input, ang pinakamahalaga para sa mga agent.

Kailangan ding magkasya ang pinakamalaking tawag sa context window. Kasya ang 192,000 token sa DeepSeek V4.1 Flash at GLM 5.3 (1,048,576 token bawat isa) at sa Qwen3.8 27B (262,144). Hindi ito kasya sa Gemma 4 VL 26B (32,768): sa halimbawang ito, masyado nang malaki ang ikapitong tawag.

Gaano kalaki ang binabago ng caching sa bill?

Sinisingil ng mga provider ang paulit-ulit na prefix ng prompt sa mas mababang rate ng cached input. Ang agent na nag-a-append lang sa history nito ay nagpapadala ng parehong prefix bawat beses at kaunting dagdag, kaya sa best case, ang mga token lang na idinagdag mula sa huling tawag ang bago:

Bagong input (best case) = B + (n − 1) × g

Cache hit ang lahat ng iba. Tumataas ang bahagi ng cached input habang humahaba ang run:

Hakbang Bagong input, best case Bahaging naka-cache
10 42,000 85%
30 102,000 94%
60 192,000 97%

Bihirang maabot ng totoong agent ang best case, kaya makakatulong na presyuhan ang tatlong kaso. Sa presyo ng DeepSeek V4.1 Flash sa BroadNet ($0.175 input, $0.0055 cached, $0.52 output kada 1M token, inilathala noong 2026-11-14), ito ang gastos ng bawat run kumpara sa 30-hakbang na best case:

Hakbang Best-case na cache 80% naka-cache Walang cache
10 0.33× 0.39× 1.37×
30 1× 2.07× 8.11×
60 2.33× 6.84× 28.2×

Dalawang bagay ang kapansin-pansin. Kapag walang cache, 28 beses ng maayos na naka-cache na 30-hakbang na run ang gastos ng 60-hakbang na run. At mas mahalaga ang caching habang humahaba ang run. Sa 30-hakbang na best case, mga isang-katlo ng gastos ang output, wala pang kalahati ang bagong input at wala pang isang-kapat ang cached input, kaya pagkatapos ng caching, nasa output ang susunod na matitipid.

Hindi basta ino-on ang caching. Nakadepende ito sa provider na nagtatago ng prefix at sa agent mo na hindi ito binabago. Inilalarawan ng gabay ng OpenAI ang eksaktong prefix matching na may minimum na haba na puwedeng i-cache. Nagtatago ang sariling API ng DeepSeek ng mga cache unit sa dulo ng input at output ng bawat request, kaya puwedeng mag-hit ang kasunod na request na nagpapahaba sa nauna. Sabi ng pricing page ng BroadNet, walang kailangang setup ang cached input, at iniuulat ng docs nito ang mga hit sa usage.prompt_tokens_details.cached_tokens kapag ibinibigay ito ng model. Nakalista ang DeepSeek V4.1 Flash sa model catalogue ng BroadNet sa ilalim ng “models we never ran on our hardware” (salin: mga model na hindi namin kailanman pinatakbo sa aming hardware), at sakop ng Terms nito (§7.3) ang model “when partner-hosted” (salin: kapag naka-host sa partner), kaya sa BroadNet, sine-serve ito sa pamamagitan ng partner. Sukatin ang hit rate mo sa halip na ipagpalagay ang sariling numero ng DeepSeek. Isulat ang prefix para ma-cache ito: prompt structure para sa caching.

Paano tantiyahin ang sarili mong run?

Binabasa ng script na ito ang kasalukuyang presyo mula sa pampublikong pricing.json ng BroadNet, kaya hindi ito naluluma, at ipinapakita ang kabuuang token at gastos kada run para sa bawat kaso ng cache:

import json, urllib.request

PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]

def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
    total_in = steps * base + growth * steps * (steps - 1) // 2
    if cache_rate is None:                      # best case: only new tokens miss
        new_in = base + (steps - 1) * growth
    else:
        new_in = round(total_in * (1 - cache_rate))
    return total_in, new_in, steps * out_per_step

def run_cost(total_in, new_in, out):
    return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6

for steps in (10, 30, 60):
    for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
        t, n, o = run_tokens(steps, cache_rate=rate)
        print(f"{steps:>3} steps  cache {label:>4}  input {t:>9,}  new {n:>9,}  "
              f"output {o:>6,}  cost/run {run_cost(t, n, o):.4f} USD")

Palitan ang mga default ng sarili mong numero. Huwag hulaan; basahin ang mga ito mula sa isang totoong run:

  1. I-log ang prompt_tokens, prompt_tokens_details.cached_tokens at completion_tokens para sa bawat tawag, gaya ng nasa post tungkol sa token budget ng agent.
  2. Ang B ay ang prompt_tokens ng unang tawag. Ang g ay ang karaniwang pagtaas ng prompt_tokens mula sa isang tawag papunta sa susunod.
  3. Ang output kada hakbang ay ang karaniwang completion_tokens. Kasama rito ang reasoning token, na sinisingil bilang output.
  4. Ang totoong cache rate mo ay ang kabuuang cached_tokens na hinati sa kabuuang prompt_tokens.

Ginagawa ng libreng agent run cost estimator ang parehong kalkulasyon sa browser mo, kaya masusubukan mo ang ibang bilang ng hakbang, rate ng paglaki at cache rate nang walang code.

Ano ang nagpapamahal sa run nang lampas sa tantiya?

  • Retry. Ang pumalyang tool call o 429 retry ay isa na namang tawag na may buong context. Bilangin ang mga ito bilang hakbang.
  • Pagbabago sa prefix. Ang timestamp sa system prompt, tools na iba ang pagkakasunod, o rules file na na-edit sa gitna ng run ay ginagawang bagong input ulit ang cached input mula sa pagbabago pasulong.
  • Compaction. Pinapaliit ng pag-summarise ng history ang context, na nagbabawas sa input pagkatapos, pero hindi pa kailanman na-cache ang bagong history, kaya buong presyo ng input ang babayaran ng susunod na tawag. Mag-compact nang bihira at sa malalaking hakbang; tinatalakay ng context management para sa matagal na tumatakbong agent kung kailan.
  • Malaking tool output. Ang 20,000-linyang test log na idinagdag sa hakbang 5 ay sumasakay sa bawat susunod na hakbang. Sa formula, nagdadagdag ito ng 20,000 × (natitirang hakbang) na input token.
  • Reasoning effort. Puwedeng paramihin ng mataas na effort ang output kada hakbang. I-set ang reasoning_effort sa low para sa mga karaniwang edit.
  • Paliguy-ligoy. Ang agent na 60 hakbang ang ginamit para sa 30-hakbang na task ay nagbabayad ng square, hindi ng doble. Ang step cap ay cost cap. Tinatalakay ng sampung paraan para bawasan ang gastos ng coding agent ang mga pingga.

Kailan mas sulit ang flat session kaysa per-token na billing?

Gawing buwanang numero ang gastos kada run: buwanang gastos = gastos kada run × run kada buwan. Saka ikumpara sa flat plan. Sa BroadNet, sakop ng mga plan ang DeepSeek V4.1 Flash nang walang token meter: $60 kada buwan ang Full Moon, $15 kada linggo ang Orbit at $1 kada oras ang Meteor, bawat isa kada session.

Bilang ng run kada buwan para mag-break even = presyo ng plan ÷ gastos kada run.

Dalawang bagay ang nagpapakomplikado sa paghahambing na ito:

  1. Ang cache rate mo ang nagtatakda ng per-token na panig. Kapag mataas ang cache rate, mura ang per-token na billing sa Flash at kailangan mo ng maraming run para lumampas sa $60. Kapag mababa, mabilis kang lalampas. Ipinapakita ng post tungkol sa flat rate ang break-even bilang buwanang volume: mga 917 milyon input at 46 milyon output token sa 80% naka-cache (ang math ng break-even).
  2. Ang oras ang nagtatakda ng kisame ng flat na panig. Isang request sa isang pagkakataon ang tinatakbo ng session. Kung 20 segundo ang karaniwang tagal ng isang tawag (prefill, mga 800 output token sa mga 100 token bawat segundo, at oras ng tool), mga 10 minuto ang 30-hakbang na run. Kaya hanggang mga anim na run kada oras lang ang kasya sa isang session. Mas maraming sabay-sabay na agent, mas maraming session ang kailangan.

Para sa maiikling dagsa, ganoon din ang Meteor sa mas maliit na sukat: kung anim na run ang kasya sa isang oras, $1 ÷ 6 ang bawat isa. Ikumpara iyan sa per-token na gastos ng isang run ayon sa script. Para subukan ang sarili mong volume, gamitin ang flat-rate vs per-token calculator.

Pattern mo Kadalasang mas mura
Ilang maiikling run kada araw Per token
Mahahabang run na mahina ang caching Flat session
Mga agent na tumatakbo sa halos buong araw ng trabaho Flat session
Ilang agent nang sabay, buong araw Isang flat session kada agent
Kailangan ng native tool calling sa BroadNet Per token sa GLM 5.3 o Qwen3.8 27B

Saan pumapasok ang BroadNet Inference

Iniuulat ng BroadNet ang cached at reasoning token sa usage block, kaya masusukat mo ang bawat numero sa itaas mula sa sarili mong mga run. Mababa ang presyo ng cached input ng DeepSeek V4.1 Flash, may 1,048,576-token na context ito, at inaalis ng mga unlimited plan ang token meter nito; paano gumagana ang mga session.

Tingnan muna ang isang limitasyon. Para lang sa GLM 5.3 at Qwen3.8 27B nakalista ang tool calling sa docs ng BroadNet, at wala sa dalawa ang nasa flat plan. Hindi kailangan ng native tool call ng mga agent na nag-e-edit gamit ang text, gaya ng Aider. Kung kailangan ito ng agent mo, subukan ang DeepSeek V4.1 Flash sa agent mo bago bumili ng plan, o mag-budget para sa GLM o Qwen kada token. At kung paminsan-minsan lang tumatakbo ang agent mo, kadalasang mas mura ang magbayad kada token kaysa sa kahit anong flat plan.

Mga tanong

Magkano ang isang run ng AI coding agent?

Bilangin ang mga token, saka presyuhan. Sa halimbawa ng post na ito, ang 30-hakbang na run na may 15,000-token na base context at 3,000 token na idinadagdag kada hakbang ay nagpapadala ng 1,755,000 input token at 24,000 output token. Ang gastos niyan ay pangunahing nakadepende sa kung gaano kalaki ng input ang nasisingil sa cached rate.

Bakit sobrang mas mahal ang mas mahabang run ng agent?

Ipinapadala ulit ng bawat hakbang ang lahat ng nauna rito. Pantay na tumataas ang input kada hakbang, kaya lumalaki ang total ng isang run ayon sa square ng bilang ng hakbang. Sa halimbawa, kapag dinoble ang run mula 30 hanggang 60 hakbang, mga 3.5 beses ang itinataas ng input nito.

Anong cache hit rate ang dapat kong asahan sa coding agent?

Depende sa agent at sa provider. Sa mahigpit na append-only na history, ang pinakabagong token lang ang nagmi-miss, na nagbigay ng 85% hanggang 97% sa mga halimbawa namin. Pinapababa ito ng na-edit na history, timestamp sa system prompt at mahahabang pahinga. Sukatin ito mula sa prompt_tokens_details.cached_tokens.

Kailan mas mura ang flat session kaysa per-token na billing para sa agent?

Kapag mas malaki ang gastos kada run × run kada buwan kaysa sa presyo ng plan. Sa BroadNet, $60 kada buwan kada session ang Full Moon para sa DeepSeek V4.1 Flash. Kadalasang mas mura kada token ang magaan o paminsan-minsang paggamit.

Binabago ba ng reasoning token ang tantiya?

Oo. Sinisingil ang mga ito bilang output, at mas mahal kada token ang output kaysa sa input. Isama sa output kada hakbang ang reasoning na nasusukat mo. Sa BroadNet, iniuulat ito ng completion_tokens_details.reasoning_tokens kapag ibinibigay ito ng model.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity