Blog · 2026-08-24 · By Dhrumil Barot, Founder

Autolith's 601.1K-token agent run reprices to $1.23 on GPT-5.6 Terra

Three public Autolith traces reprice to $0.13-$1.23 on GPT-5.6 Terra. Reproducible API-rate math, not the author's subscription bill.

Three public Autolith coding-agent runs reprice to $0.13, $0.61, and $1.23 at GPT-5.6 Terra Standard API rates. The 601.1K-token run is 9.6x the cost of the 59.6K-token run. These are API-rate counterfactuals, not the author's ChatGPT Codex subscription bill. Prices verified 2026-08-24.

TL;DR

• Autolith publishes three real v0.35.0 recordings with 59.6K, 289.0K, and 601.1K total tokens. The displayed components are 58.7K input plus 915 output, 286.1K plus 3.0K, and 598.5K plus 2.6K.
• At $2 per 1M input tokens and $12 per 1M output tokens, those displayed components reprice to $0.1284, $0.6082, and $1.2282 on GPT-5.6 Terra.
• Input supplies 98.5% to 99.6% of the tokens. Output supplies only 2.5% to 8.6% of the uncached Terra bill. Context retention, not answer length, drives this workload.
• The public recordings used a ChatGPT Codex subscription. They do not expose an API invoice, cache-read split, or per-request token series. Treat every dollar here as a reproducible comparison layer.

Verdict table

The top-line result is not that $1.23 is expensive. It is that three useful agent outcomes carry a 9.6x spread on one model's live sticker. A monthly forecast built from the shortest demo would miss the longest one badly.

What we computed and why

Autolith's public recordings show exact prompts, artifacts, wall times, and displayed token fields. All three ran on gpt-5.6-terra at high reasoning effort through a ChatGPT Codex subscription.

The runs are materially different:

This is not a controlled same-task benchmark. The outcomes, prompts, and agent paths differ. We therefore do not claim that persistence costs 4.8x more than repository analysis or that a crash causes a fixed token tax. We use the traces for a narrower question: what would these public token shapes cost at today's API rates?

That distinction matters. Our earlier 30x coding-agent token study measures variation across repeated benchmark work. This article prices three observed product demonstrations. One explains variance; the other gives concrete bill shapes.

Editable assumptions

The formula is ordinary cost per token math:

run cost = (input tokens / 1,000,000 × input rate)
         + (output tokens / 1,000,000 × output rate)

For the 601.1K run on Terra:

(598,500 / 1,000,000 × $2) + (2,600 / 1,000,000 × $12)
= $1.1970 + $0.0312
= $1.2282

The script preserves four decimal places so readers can recompute it. The source does not justify four-decimal invoice precision because several token fields are rounded.

API-rate results

Use the LLM cost calculator when your own run resembles the 598.5K-input, 2.6K-output shape. Replace both fields with measured counts before multiplying by task volume.

The longest run spends 9.6x the shortest on Terra and 9.7x on GPT-5.6 Sol. Model choice changes the level, not the ranking. Sol costs about 2x Terra on all three traces because these runs are almost entirely input.

The important denominator is retained context

The token mix sharpens the engineering decision:

Shorter answers will barely move these bills. The longest run emits only 2.6K output tokens. Its 598.5K input tokens cost $1.1970, or 97.5% of the $1.2282 total.

That points to three controls before model routing:

1. Meter accumulated input by turn, not only output at completion.
2. Put a budget on replayed tool results and recovered history.
3. Compact stable state before the context window becomes the workload.

Our agent workflow forecasting guide models the same mechanism before a system exists: repeated history makes input grow faster than call count. Autolith gives the mechanism a public, inspectable trace after execution.

Cache sensitivity: a floor, not a promise

OpenAI lists cached input at $0.20 per 1M tokens for Terra and $0.40 for Sol. If every displayed input token qualified for prompt caching, the Terra totals would fall to $0.0227, $0.0932, and $0.1509.

That is a mathematical floor for this token split, not an observed cache result. The recordings expose no cache-read tokens. Subscription accounting also need not mirror API cache billing. Use the uncached row for a conservative API forecast until your logs prove reuse.

The >272K surcharge cannot be inferred from a total

OpenAI says prompts above 272K input tokens cost 2x the input rate and 1.5x the output rate for the full request. Both larger conversations report more than 272K aggregate input. That does not prove any individual request crossed the threshold.

Agent conversations usually make several requests. A 598.5K conversation could comprise many prompts below 272K, one prompt above it, or several above it. The public page gives only the conversation total.

If all 598.5K input and 2.6K output tokens had landed in surcharge-eligible requests, the Terra counterfactual would reach $2.4408. Standard pricing gives $1.2282. The defensible published answer is therefore $1.2282 under the stated Standard assumption, with $2.4408 as a deliberately conservative sensitivity ceiling.

See our long-context surcharge guide before mapping aggregate traces to an API invoice. The per-request cost series is the missing receipt.

What this means for routing

Route after measuring outcome quality and context growth. The public runs do not compare Terra and Sol quality, so the cost table cannot tell us whether Sol would finish with fewer calls or tokens.

If both models preserve the same success rate and token shape, Terra is the cost choice: $1.2282 versus $2.4460 on the longest trace. If Sol cuts retries, avoids a recovery loop, or compresses the run enough, its higher sticker can still win per completed outcome. That break-even needs a controlled rerun, not a pricing-page opinion.

The immediate operational threshold is simpler. At 1,000 copies of the longest uncached shape, Terra reaches $1,228.20. At 10,000 copies, it reaches $12,282. One retained-history decision can therefore matter more than shaving a few hundred output tokens.

Honest tradeoff: when not to optimize this

Do not add aggressive compaction to a low-volume, human-supervised agent solely to save $1.08 between the shortest and longest Terra rows. You may destroy recovery evidence, agenda state, or the exact context that makes the run successful.

Do add metering before running thousands of unattended sessions. Preserve durable facts and artifacts, but stop replaying raw history once it stops improving the outcome. Cost optimization is useful only when it does not erase the state the agent was built to retain.

Caveats

• The three runs are different tasks. Their cost ratio is descriptive, not causal.
• Several source fields use K-rounded values. Component sums can differ slightly from the displayed total.
• The recordings used a subscription. No claim here describes Lambda Symbolics' invoice.
• Cache reads, cache writes, reasoning-token treatment, and tool fees are not published in the recordings.
• API behavior could change the number of tokens. Repricing holds the observed shape fixed.
• The Sol row is a counterfactual model substitution with no quality claim.

Sources

• Lambda Symbolics: Autolith public recordings, captured 2026-08-24. Source for prompts, outcomes, wall times, model, subscription route, and token fields.
• OpenAI: GPT-5.6 Terra model, captured 2026-08-24. Source for model name, $2 input, $0.20 cached input, $12 output, and the >272K rule.
• OpenAI: GPT-5.6 Sol model, captured 2026-08-24. Source for model name, $4 input, $0.40 cached input, $20 output, and the >272K rule.

The calculator script and CSV are generated from the displayed public components. No Vynaris traffic, customers, telemetry, or routing logic appears in this analysis.