Token Economy
Software cost does not disappear. It shifts toward inference, orchestration, verification and human steering. Agent Studio makes that spend visible next to accepted work.
Token Economy turns a market thesis into product language: tokens become a production factor, and efficient use of tokens becomes part of software strategy.
Tokens as Production Cost
The cost of software does not disappear when agents become cheaper. It moves into inference, orchestration, verification and human steering.
Large software systems can be understood partly by the amount of inference required to create, migrate, understand and verify them. The cost is lower than classical software production, but it is still a strategic factor.
If a project has a given size and complexity, reproducing or migrating it requires a certain amount of token spend plus human steering. The number may become dramatically cheaper than traditional software development, but it is not zero.
Tokens become a production factor. Companies will not only ask how many developers they need. They will also ask how much verified software value they can create from a token budget and how efficiently their structure turns tokens into accepted work.
The new question is not whether software is cheap. It is how much accepted software you get per token.
- A project of a given size and complexity has an approximate token budget to reproduce.
- Replication pressure increases when competitors can reach the same outcome with fewer tokens and less human steering.
- Efficient token use becomes part of defending product advantage.
Outcome-based Token Reporting
Raw usage is accounting. Product value appears when token spend is connected to tasks, review and accepted change.
Raw usage numbers are not enough. The useful view connects tokens to tasks, modes, agents, reissues, review results and accepted software changes.
A developer sees which agents consumed tokens, which modes produced accepted work and where reissues created waste.
The product angle is practical: token reporting steers subscriptions and workflows. It shows whether Codex, Claude Code or Gemini produced the right outcome for a certain class of task, and whether the task shape was small enough to be efficient.
Cost sits next to usage. Token counts come from the CLI, and cost is derived from a shared pricing library at run-time prices, with unknown shown honestly when a model has no published rate. See Cost at Run-Time Prices below.
Token spend becomes meaningful when it is evaluated against accepted work.
- Token spend is visible per project, task, agent and mode.
- Reissued work reveals waste and weak task shaping.
- Accepted work gives token spend a business interpretation.
Token and cost reporting: seven days of workspace token usage broken down by project, agent mode, and theoretical cost.
Cost at Run-Time Prices
Cost is not guessed at display time. It is computed from a shared pricing library using the price that was valid when the run happened.
Token counts alone do not answer what a run cost. Agent Studio derives cost from reported usage and a central pricing library, so the number stays consistent across tasks, agents and reports.
Cost calculation is centralized. Agent Studio reads model prices from the coding-agent-runner pricing library instead of scattering rate tables across the product, so every task, report and comparison uses the same source. (Cross-project dependency: the pricing library and the cost audit are tracked in the coding-agent-runner and Agent Studio projects; this page describes the target state and follows the library once it is the live source.)
Prices have history. Providers change model rates over time, and the library keeps a dated price history. A run is costed with the price that was valid at its run timestamp, so re-reading an old task does not silently reprice it against today’s rates.
Unknown stays unknown. When a model has no known price - a new model, a private endpoint or a provider that does not publish a rate - Agent Studio shows the cost as unknown instead of inventing a number. An honest unknown is more useful than a confident wrong total.
A run is costed at the price that was valid when it ran, and unknown prices are shown as unknown.
- Cost comes from a shared pricing library, not per-surface rate tables.
- Price history lets a run keep the cost that was valid at its run time.
- Models without a known price are reported as unknown, never guessed.
Cheap Software, Better Software
When software becomes easier to copy, the defense shifts toward structure, speed, quality and operating knowledge.
If software becomes much cheaper to build, markets will contain more software and more copies. The answer is not hiding the source. It is building a structure that turns tokens into a better, more inspectable product faster.
A competitor may be able to recreate features faster than before. That does not mean economic differentiation disappears. It means the durable advantage moves toward the system that can use tokens well: clean context, narrow tasks, strong review, trusted evidence and repeated improvement.
Agent Studio treats the token economy as both a product feature and a strategy lens. The tool is valuable because it helps a developer spend agent capacity deliberately instead of treating every prompt as an isolated experiment.
In a cheaper software market, the winning product may be the one that spends tokens with the least waste and the most reviewable output.
- Product quality, operating knowledge and review discipline become harder to copy than individual features.
- A well-structured project can spend tokens more efficiently over many iterations.
- The economic question becomes how much verified software value returns from a given token budget.