Buying inference for an agent fleet: coding plans vs. APIs

Once coding workers can keep themselves busy, inference becomes a purchasing decision. A subscription buys an allowance that expires. An API bills for the work requested. Both can be economical, and both can be wasted.

In The unit economics of running cattle, I argued for measuring cost per completed outcome. This artifact applies that discipline to buying inference: which offers deserve a trial, what their advertised units mean, and where the apparent savings disappear.

Analysis date: September 7, 2026.

This is a maintained research artifact. Prices are in USD before tax; individual source checks and usage captures retain their own dates in the dataset. The calculations model billing; they do not establish model quality, sustained throughput, or the cost of a shipped application. The changelog records substantive revisions. Publication dates, editorial updates, and source-verification dates serve different purposes.

Measure the workload first#

The baseline now comes from an actual local usage scan captured September 7, 2026 at 14:55 UTC, using Tokscale 4.15.1. It covers the locally discovered Claude Code, Codex and ZCode histories in one scan, across 871,701 recorded messages. This is an accumulated history snapshot, not one month of usage or a deduplicated total across every machine. The aggregate measurement contains the exact counters and derivation; no prompts or session records are included.

82.06B measured tokens; 213.2:1 total input/output; 96.53% of input served from cache. All input includes fresh input, cache reads and cache writes.

Tokscale’s model report keeps separately reported reasoning outside its output field. I add that bucket once to obtain billable output; reasoning already included by a client stays inside output. Cache reads and writes are separate from fresh input. This normalization follows the versioned scanner implementation.

These are measured usage proportions, transferred into hypothetical purchases below. Another model, tokenizer, provider cache or session pattern can change them. In particular, the high cache-hit rate is not guaranteed on another service. Most processed tokens here are repeated context; maximizing that total alone would reward repetition rather than useful applications.

What I would trial first#

My shortlist from the published economics is OpenCode Go for routine coding, Z.ai for sustained GLM-5.3 work, and Synthetic when its model selection or additional concurrency justifies a pack. Keep a capped API balance available for overflow and difficult tasks. These are candidates to measure in the actual harness, not a ranking of coding quality.

The key eligibility question is whether the allowance covers the workload. A developer running a supported coding tool, an unattended coding worker, and a finished application serving customers can fall under different rules. An API-shaped endpoint does not establish permission for all three.

Each expanded plan reports total processed tokens, with output in parentheses, at the measured mix above. Each example spends the entire allowance on its named model; examples within one plan are alternatives. Weekly quotas are prorated to 30 days and assume full utilization within shorter limits. B means billion and M means million tokens. This is quota capacity, not a measured throughput promise or a model’s per-request context window.

Several qualifications matter more than another decimal place in the price:

• Z.ai supports specific coding tools and uses dynamic concurrency limits. Its published examples include automated development tasks, but that does not establish unrestricted custom-backend access. Usage policy
• camelStream’s standard terms permit retention and training on prompts and outputs, without an opt-out. Model choice, queue time and throughput are not guaranteed. It merits a small experiment with suitable non-sensitive work. Terms
• Kimi Code’s personal benefits differ from production API access. The membership page alone does not establish a fixed Code token allowance or identical context limits across products. Code benefits
• NanoGPT’s new subscription terms explicitly exclude building commercial products. They apply to new users now and existing users from September 14. PAYG permits commercial use. Terms, quota accounting
• The DeepSeek reseller needs further clarification. Its pricing cards and DeepSeek integration page give different allowances. Its separate Agent Plan documentation describes an upstream Volcengine product. I have not treated either as an official DeepSeek subscription or assigned it a reliable savings multiplier.
• Chutes’ old unlimited-value anecdotes are obsolete. Its published revision caps monthly subscription benefit at five times its own PAYG value and permits shorter rolling limits.

The capacity CSV includes additional models, peak/off-peak variants and all four token buckets. The catalog snapshot preserves the large public model lists. Model availability, subscription inclusion and a selectable API alias are distinct; unresolved tier or alias details are marked in the comparison.

Normalize the subscription costs#

The same measured mix makes every quantifiable allowance comparable in token units: 1M billable output tokens requires approximately 213.167M input tokens, for 214.167M total processed tokens. The input is divided among the fresh, cache-read and cache-write buckets above before applying each provider’s prices or credit weights. Dividing a subscription’s fee by its advertised credit count would skip that conversion.

output_M = allowance_for_period / deductions_per_1M_output_and_its_input
processed_M = output_M × (1 + measured_input_output_ratio)
cost_per_1M_processed = fee_for_period / processed_M
cost_per_1M_output_with_input = fee_for_period / output_M

These are fully utilized, steady-state 30-day estimates from the dated September 7 price snapshot. Output costs include the associated input and cache processing; they are not the provider’s output-only API rate. Processed-token costs include cache reads, which dominate this workload. Both measures describe the same workload and produce the same cost ordering. Differences in model quality still need an accepted-work benchmark.

The comparison covers the quantifiable examples from the plan overview. Other model allocations and time windows use the same calculation:

“Saving vs direct API” compares the same named model against the direct API row below, using ordinary list prices for GLM Flash and off-peak prices for DeepSeek. Serving configurations and cache behavior can differ. “Not established” means this dataset lacks a defensible same-model baseline; it does not mean zero savings. Chutes estimates remain conditional on its published ceiling and model eligibility. Kilo examples assume annual billing with the full monthly bonus consumed before expiry. Alternative model allocations within a subscription cannot be added together.

The capacity CSV contains all four token buckets, both normalized costs, direct API savings and break-even utilization. It also separates a discount against the serving provider’s own PAYG rates from a discount against the original model API. Missing or conflicting quotas remain blank; camelStream’s unmetered service has no defensible fixed token capacity or normalized cost here. MiniMax, Kimi and the DeepSeek reseller need quota clarification; Alibaba needs tokens per billable request.

At 50% utilization, each subscription’s effective cost per token doubles. Break-even utilization is the fraction of modeled allowance that must replace direct API spending to recover the fee. A figure above 100% means even full utilization is more expensive than that API baseline. Real concurrency, request and reset limits can prevent reaching the modeled allowance.

Start with the API baseline#

The priced workload is 1M billable output tokens plus the measured proportions of fresh input, cache reads and cache writes shown above. Tokenizers differ, so equal token counts do not mean identical amounts of source code. These are estimates at current prices, not the historical cash cost of the measured sessions.

For prices stated per million tokens:

cost = fresh_input_M × input_price
     + cache_read_M × cache_read_price
     + cache_write_M × cache_creation_price
     + output_M × output_price
     + additional_charges

The comparison excludes paid tools, search, additional retries, infrastructure and long-context premiums. Cache creation uses the ordinary input price unless the serving provider specifies a separate full creation rate. Free cache storage or a waived write surcharge does not make the initial input processing free. Kilo’s Sonnet 5 example, for instance, uses its explicit cache-creation rate in the capacity calculator.

Without cache hits, the same workload costs $30.12 on MiMo V2.5, $47.56 on off-peak DeepSeek Flash, and $654.50 on Kimi K3. A plan that counts cached input at full token weight can lose much of its advantage against an API with inexpensive cache reads. Repeated context also inflates token totals without representing newly generated work.

DeepSeek’s listed prices apply outside weekday peak windows of 01:00–04:00 and 06:00–10:00 UTC; peak rates double. MiniMax M3’s listed rate applies through 512K input per request. These timing and context conditions belong in the comparison, not in a footnote to the invoice. DeepSeek pricing, MiniMax pricing

Compare with OpenRouter too#

OpenRouter narrows some subscription discounts because its alternative providers can undercut the model author’s API. The result depends heavily on cached-input pricing. The following snapshot was captured on September 7, 2026, through 16:11 UTC from OpenRouter’s public model-endpoint API. Each quote keeps one provider’s input, cache and output rates together.

The comparison is grouped by subscription, then model, then tier or time window. All twelve researched coding subscriptions appear, including those with unknown costs. Models from the saved catalogs remain visible in the index; large unpriced catalogs expand underneath their subscription. Catalog presence, subscription eligibility and model pinning are separate questions, so each group retains those conditions. Native workflow subscriptions are discussed separately below.

The unit-cost fields report cash cost per 1M output tokens plus 213.167M associated input tokens, using the measured cache mix. Subscription summaries show the monthly fee, and capacity details show total processed tokens with output in parentheses. Each calculated scenario spends the full allowance on its named model; scenarios within one subscription are alternative allocations. “Not established” means the snapshot lacks a defensible entitlement or calculation; “Not quoted” means no matching OpenRouter route was priced.

OpenRouter figures include its standard card-purchase fee: 5.5%, with a $0.80 minimum. The reference purchase is $100 of inference credits plus $5.50 in fees, so quoted inference cost is multiplied by 1.055 once. A $10 credit purchase instead incurs an 8% effective fee. Taxes and special billing arrangements are excluded. OpenRouter fee policy

The selected route is the lowest modeled cost in the captured endpoints with status 0, advertised tool support and explicit cache-read pricing. Nonzero-status routes are excluded from selection; the Xiaomi Pro author quote is retained only in the dataset and quote CSV for comparison. MiniMax M3’s lower GMICloud quote is excluded because its endpoint metadata does not advertise tool support. These are dated quotes, not a promise of availability or default routing. The snapshot records provider tags, context limits, quantization, rate overrides and source URLs in the price dataset. Reported discounts are already reflected in endpoint prices and are not applied again. Endpoint API

Headline input prices can pick the wrong provider. MiMo V2.5’s DeepInfra route quotes $0.13/M fresh input, below Xiaomi’s $0.14/M. But its cache-read price is $0.026/M versus Xiaomi’s $0.0028/M. Including their output rates and the purchase fee, this measured workload costs $7.34 through DeepInfra versus $1.99 through Xiaomi. The API quote, provider tag and context limits for that example are retained in the dataset. MiMo provider quotes

Reproducing the measured 96.53% input cache-hit rate is an assumption. OpenRouter uses sticky routing to help preserve caches, but fallback can move requests to a different provider. Verify actual billed cache reads in the coding harness. Pinning a provider or quantization changes the available routes; an FP4 quote is not evidence of equal application quality to an FP8 or author-hosted route. Each request must also fit that endpoint’s context and pricing tier. Caching, provider routing

GLM Flash’s current OpenRouter quotes include promotional pricing; the author’s offer ends September 9 at 16:00 UTC. Standing subscription estimates above exclude temporary quota boosts. DeepSeek comparisons pin OpenRouter’s Flash 0731 and Pro 0813 versions; a subscription’s generic alias may not guarantee the same checkpoint. The author-route DeepSeek quotes are off-peak. Sonnet uses standard service and five-minute cache creation. Recheck these conditions before extending the estimates beyond this snapshot.

At full modeled utilization, OpenCode Go’s MiMo allocation buys about 6.33× the tokens per dollar of the selected OpenRouter route, and Z.ai Max’s off-peak GLM-5.3 allocation buys about 7.73×. The advantage is smaller for Synthetic GLM Flash against current promotional OpenRouter quotes. Chutes Pro’s conditional DeepSeek Flash ceiling is actually more expensive than the selected StreamLake quote. These are different serving configurations, so accepted-work testing still decides whether the cheaper tokens help.

OpenRouter is therefore a useful baseline and overflow source. A subscription only beats it when enough relevant allowance is consumed: Go’s MiMo allocation breaks even at 15.8% utilization, while Synthetic’s Flash example needs about 73.6% against the current selected quote. The OpenRouter comparison CSV includes cash-budget token capacity; the subscription comparison CSV includes savings and break-even utilization for every mapped, quantifiable offer.

Convert the allowance before comparing it#

Z.ai illustrates why a flat subscription cannot be reduced to one universal token price. Credits depend on the selected model, uncached input, cached input, output and time of day. Off-peak model usage consumes half the normal credits.

Applying its credit formula to the example workload gives these fully utilized, off-peak, steady-state 30-day equivalents:

The weekly allowance is prorated for comparison; it is not a guaranteed calendar-month entitlement. Five-hour limits, concurrency, tool consumption and uneven demand can reduce realized value. All-peak operation halves the token allowances. The same subscriptions produce approximately 2.6–4.0× ordinary GLM Flash API value in this scenario, because Flash’s direct API is already much cheaper.

OpenCode Go has a different mechanism. Some models receive six times the subscription fee in API allowance; others receive three or one-and-a-half times. Allocating its entire qualifying allowance to MiMo V2.5 supports approximately 31.7M output plus 6.76B input tokens for $10 in this scenario. Allocating it to MiniMax M3 supports approximately 3.8M output plus 811M input. Those are alternative uses of one pool, still subject to shorter limits. Allowance rules

MiMo’s own plan shows the danger of reading credits as tokens. Each uncached V2.5 input token costs 100 credits; each output token costs 200. Its 4.1B-credit Lite plan therefore represents approximately $5.74 of daytime direct API usage for a $6 fee, or $7.18 with the off-peak credit discount. Large numbers need units. Conversion rules, API prices

Synthetic’s $24 weekly allowance represents about $103 per 30 days at Synthetic’s rates. Always compare the serving provider’s cache prices and model configuration with the original API before calling that a direct-provider discount. Limits, model metadata and prices

NanoGPT illustrates the effect of counting cache hits at full input weight. At the measured ratio, its 60M weekly input-unit allowance yields approximately 258M total processed tokens, including 1.21M output, per 30 days on a 1× model. A 2× model halves those estimates. A request-count plan needs another measurement—tokens per billable request—before it can be converted. The local message count is not assumed to equal provider API calls. NanoGPT quota definitions

Utilization is the other half of the arithmetic. A $10 plan containing $60 of relevant API usage breaks even once it replaces more than $10 of API spending. The unused $50 has no value. More packs can buy parallelism, but idle parallelism is still a bill.

Native coding subscriptions belong in the trial too#

Codex through ChatGPT, Claude Code, Cursor and Copilot can be economical when their native workflows produce useful results. Their included allowances are not interchangeable general API credits, and published limits do not establish a universal cost per token.

• Codex through ChatGPT: $20/$100/$200 options, with model-dependent five-hour and weekly allowances. API billing is separate. Pricing
• Claude Code: Pro $20, Max from $100. Personal native use and product integrations have different access rules. Pricing, usage rules
• Cursor: $20/$60/$200, with distinct usage pools for Cursor models and other models. Pricing documentation
• Copilot: $10/$39/$100 plans advertise $15/$70/$200 total feature credits, including variable flex credits. Plans
• Gemini CLI: the free Google-account tier advertises up to 1,000 requests daily, subject to model availability and shared limits. It is a useful free baseline. Quotas

Temporary offers, kept separate#

As checked September 7, Z.ai’s GLM-5.3-Flash direct API is half price until September 9 at 16:00 UTC. That promotional row is explicitly separated from ordinary pricing above. API offer

Through September 20, Z.ai also advertises zero-quota Flash use through ZCode daily 15:00–01:00 UTC, and doubled quota through other supported agents during that window. OpenCode separately advertises a temporary Flash allowance increase. These offers can improve a trial; the standing subscription calculations exclude them. After expiry, treat this paragraph as a dated observation until it is revised. Z.ai campaign, OpenCode campaign

The next analysis should measure accepted work#

Run 20–50 representative tasks through the same harness, tests and retry budget. Record input, cache hits, billed output, subscription consumption, cash spend, retries, queue time, review time and whether the change was accepted. Include abandoned attempts in the bill.

The metric is total inference and retry cost divided by changes that pass tests and review. Report elapsed time alongside it: a cheap queue can become expensive when it delays everything else. Allocate the full subscription fee across the measured period, including unused quota, rather than claiming the theoretical maximum discount.

That experiment may favor a cheap default with occasional stronger calls. It may favor one reliable model that finishes sooner. This initial research does not establish which outcome the fleet will produce.

Reproduce and update the comparison#

Download the dated price dataset, measured usage profile, model catalogs, calculator, API comparison CSV, plan capacity CSV, Z.ai comparison CSV, OpenRouter quote CSV, and OpenRouter versus subscriptions CSV. The dataset records source URLs and check dates; the artifact’s comparisons and CSVs are generated from it.

Put calculate.mjs and prices.json in the same directory. With Node 22 or newer:

node calculate.mjs --format api > api.csv
node calculate.mjs --format plans > capacity.csv
node calculate.mjs --format zai > zai.csv
node calculate.mjs --format openrouter > openrouter.csv
node calculate.mjs --format openrouter-plans > openrouter-plans.csv
# Sensitivity scenario; defaults above use the measured profile.
node calculate.mjs --ratio 50 --cache-hit 0.95 --cache-write-share 0.2 --format plans

--cache-write-share is the fraction of non-cache-read input spent creating caches. It preserves separate write pricing while --cache-hit controls reads as a fraction of all input. The calculator does not convert a message count into requests.

For OpenRouter, --topup-credits 10 models the fee on a $10 inference-credit purchase; --budget remains a cash budget. The default amortizes a $100 credit purchase. Ratio overrides reprice the captured provider routes; they do not select a new cheapest provider. Use the recorded endpoint API URLs to refresh route selection for a different workload.

Future revisions can add measured task outcomes, new providers, different cache-hit scenarios and throughput observations without moving this artifact. The page-level verification date advances only after the comparison has been checked as a whole; partial refreshes retain individual source dates. Corrections and changed recommendations belong in the changelog, newest first.

Changelog#

2026-09-07 — Published as a data artifact#

• Retired the private Notes draft and published the maintained comparison at /data/inference-plans/.
• Kept the report, Markdown twin, calculator, source data and generated CSVs together under one public artifact path.
• This changes the publication surface only; the analysis, measurement and source-verification dates are unchanged.

2026-09-07 — Display the analysis date#

• Added a prominent analysis date near the top of the artifact, separate from publication, measurement and source-verification dates.

2026-09-07 — Index by subscription and model#

• Reorganized the OpenRouter comparison into all twelve researched coding subscriptions, then their models, with tier and time-window rows underneath.
• Included the saved model catalogs; large unpriced catalogs expand within the relevant subscription instead of disappearing from the comparison.
• Added token capacity beside each calculated model/tier cost and retained explicit unknowns for missing allowances, rates and model multipliers.
• Preserved the existing measured mix and dated prices; this is a coverage and presentation update, not a source refresh.

2026-09-07 — OpenRouter route comparison#

• Added nine model comparisons using coherent provider quotes, measured cache composition and the standard credit-purchase fee.
• Added selected provider, quantization, context and status metadata; separated flagged author quotes and current promotional rates.
• Added OpenRouter cash-budget capacity and subscription savings/break-even CSVs, plus a configurable top-up size.
• Found that provider cache pricing can reverse headline-price rankings, and that the selected DeepSeek Flash route undercuts Chutes Pro’s modeled ceiling.
• Retained the earlier usage measurement and subscription snapshot; this revision refreshes OpenRouter quotes only.

2026-09-07 — Normalize subscription costs#

• Converted the measured mix into effective costs per million processed tokens and per million output tokens including associated input for every quantifiable offer.
• Added a main normalization table, expandable model/time-window calculations and matching CSV fields.
• Added explicit same-model direct API savings and break-even utilization, preserving negative savings and unknown comparisons.
• Kept the existing measurement and dated price snapshot; this revision adds arithmetic rather than claiming a new measurement or source refresh.

2026-09-07 — Measured usage, supported models and capacity#

• Replaced the illustrative 20:1 input/output ratio and 80% cache-hit assumption with a fresh local measurement: 213.2:1 and 96.53% of input from cache.
• Normalized separately reported reasoning into billable output and retained distinct cache-read and cache-write buckets.
• Added model coverage for every plan in the main table, dated catalog snapshots and reproducible token-capacity estimates using serving-provider rates.
• Kept unknown quotas, unmetered service and conditional ceilings explicit; added downloadable usage and capacity data.
• Recalculated API examples. The shortlist remains a set of trial candidates; no accepted-work benchmark has yet been run.

2026-09-07 — Initial research draft#

• Compared twelve subscription offerings with direct API costs and native coding alternatives.
• Added reproducible API and Z.ai calculations, source-check dates, and explicit workload assumptions.
• Recorded automation restrictions, conflicting reseller documentation and expiring promotions.
• Established the cost-per-accepted-change experiment as the next analysis; no paid performance benchmark has been run for this note.