Blog · 2026-08-24 · Vynaris Team

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

Public run                     Reported input / output  Terra $/1M in / out  Terra API-rate cost  Sol API-rate cost                                       Decision
-----------------------------  -----------------------  -------------------  -------------------  ------------------------------------------------------  ------------------------------------------------
Recursive repository analysis  58.7K / 915              $2 / $12             $0.1284              $0.2531                                                 Token-cheap enough to run interactively
Crash and recovery             286.1K / 3.0K            $2 / $12             $0.6082              $1.2044                                                 Diagnose why history grew before changing models
Persist, resume, continue      598.5K / 2.6K            $2 / $12             $1.2282              Set a context budget before scaling copies of this run

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:

Run                            Public outcome                                                                   Whole-session time  Published total
-----------------------------  -------------------------------------------------------------------------------  ------------------  ---------------
Recursive repository analysis  Found 83 condition classes across 14 subsystems in a 3.1 MB, 121-file corpus     4m 36s              59.6K
Crash and recovery             Changed a live formatter, forced a crash, then recovered the committed mutation  About 6m            289.0K
Persist, resume, continue      Persisted code and an agenda item across two processes, then finished the task   10m 11s             601.1K

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

Assumption                   Value used                                              Why you may change it
---------------------------  ------------------------------------------------------  -------------------------------------------------------------------------------------------
Token counts                 Public displayed input and output components            The source rounds several fields to K units
Provider used in recordings  ChatGPT Codex subscription                              The actual execution was not API-billed
Terra Standard rates         $2 input, $0.20 cached input, $12 output per 1M tokens  Live [OpenAI Terra model page](https://developers.openai.com/api/docs/models/gpt-5.6-terra)
Sol Standard rates           $4 input, $0.40 cached input, $20 output per 1M tokens  Live [OpenAI Sol model page](https://developers.openai.com/api/docs/models/gpt-5.6-sol)
Headline cache assumption    All reported input billed uncached                      The recordings publish no cache-read count
Tool-call fees               $0 added                                                The public trace does not itemize separately billed API tools
Long-context surcharge       Excluded from headline                                  The threshold applies per request, not to a conversation total
Dollar unit                  USD per completed public run                            A run is the nearest visible outcome denominator

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

Public run                     Terra input cost  Terra output cost  Terra $/run  Terra $/1,000 runs  Sol $/run
-----------------------------  ----------------  -----------------  -----------  ------------------  ---------
Recursive repository analysis  $0.1174           $0.0110            $0.1284      $128.38             $0.2531
Crash and recovery             $0.5722           $0.0360            $0.6082      $608.20             $1.2044
Persist, resume, continue      $1.1970           $0.0312            $1.2282      $1,228.20           $2.4460

Horizontal bars showing GPT-5.6 Terra Standard uncached API-rate costs of $0.1284, $0.6082, and $1.2282 for Autolith's three public traces. — Autolith public token traces repriced on GPT-5.6 Terra Standard. Source: Lambda Symbolics and OpenAI; prices verified 2026-08-24.

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:

Public run                     Input share of tokens  Output share of Terra cost
-----------------------------  ---------------------  --------------------------
Recursive repository analysis  98.5%                  8.6%
Crash and recovery             99.0%                  5.9%
Persist, resume, continue      99.6%                  2.5%

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:

Meter accumulated input by turn, not only output at completion.
Put a budget on replayed tool results and recovered history.
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.

Public run                     Terra all-uncached  Terra all-input-cached floor  Sol all-uncached  Sol all-input-cached floor
-----------------------------  ------------------  ----------------------------  ----------------  --------------------------
Recursive repository analysis  $0.1284             $0.0227                       $0.2531           $0.0418
Crash and recovery             $0.6082             $0.0932                       $1.2044           $0.1744
Persist, resume, continue      $1.2282             $0.1509                       $2.4460           $0.2914

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.