Open any model provider's pricing page and there is a detail that is easy to skim past: output tokens cost several times more than input tokens. Not a little more. For the major frontier models the ratio is roughly five to one. You are billed one rate for the tokens you send and a much steeper rate for the tokens the model writes back.

Most people building on LLMs internalize the total price and never look at the split. That is a mistake, because the split is where the surprises live. Once an agent is doing real work, the LLM output token cost is usually the line item that decides whether a feature is cheap or alarming, and it is the one you have the most direct control over.

The five-to-one rule

As of mid-2026, the pattern holds across the well-known models (always verify current rates before you quote them, they move):

  • A top-tier model priced around 5 dollars per million input tokens tends to charge around 25 per million output.
  • A mid-tier model near 3 dollars input sits around 15 output.
  • A small, fast model near 1 dollar input is around 5 output.

Different absolute numbers, same shape: output is about 5x input. The exact multiple varies, but the direction never does. Writing is the expensive half.

The reason is mechanical, not arbitrary. Input tokens are processed in parallel in a single forward pass over the prompt. Output tokens are generated one at a time, each one requiring its own pass that attends to everything before it. Generation is the serial, compute-heavy part, and the price reflects that. You do not need the internals to use the fact: every token the model emits costs you more than every token you feed it.

Verbose agents are expensive agents

This asymmetry is why two agents solving the same task can have wildly different bills. The one that answers in a tight diff is cheap. The one that restates the problem, narrates its reasoning, reprints the entire file it just edited, and closes with a friendly summary can cost several times more for an identical result.

It compounds in a loop. An agent that pads every turn with narration pays the output premium on that padding at every step, and coding agents run many steps. The token math of a single task already skews toward output once real work is involved, and agent loops make it worse by repeating the pattern turn after turn. The cost of a chatty agent is not a rounding error. It is a multiplier.

How to spend less on output

The good news is that output is the lever you control most directly. The cheapest output token is the one the model never generates. A few habits move the number a lot:

Ask for less. Tell the model to return only what you will use. If you need a decision, ask for the decision, not a paragraph justifying it. Prompts that invite the model to "explain your reasoning in detail" in the final answer are prompts that ask you to pay the output premium on that reasoning.

Return diffs, not whole files. Having an agent reprint an entire 400-line file to change three lines is one of the most common and most expensive anti-patterns. A patch or a diff conveys the same change for a fraction of the output.

Use structured output. When you constrain a model to emit a specific schema, it stops wrapping the answer in prose. You pay for the fields you need and nothing else. Structured output is usually discussed as a correctness tool, but it is also a cost tool.

Separate the scratchpad from the answer. Reasoning is valuable, but if the model does its thinking inside the billed final response, you pay output rates for the thinking. Keep exploratory reasoning in a cheaper channel or a smaller model, and reserve the expensive output for the result.

Cap the ceiling. Set a maximum output length. It will not shrink a well-behaved response, but it turns a pathological runaway (the model looping or dumping a giant blob) from an open-ended bill into a bounded one.

None of these hurt quality when applied with judgment. They remove the tokens that were never earning their price.

The honest limitation

Trimming output is a lever, not a law. Some tasks genuinely require long output: writing a new file, drafting real documentation, producing a substantial migration. You cannot compress your way out of work that legitimately needs to be written, and squeezing output on those tasks just produces truncated, broken results. Austerity for its own sake is its own kind of waste.

Output is also not the only lever. When a task carries a huge context (a large codebase slice, long transcripts), input can dominate even at a fifth of the rate, and the fix there is caching and context discipline, not brevity. Knowing which half of the bill you are fighting is the actual skill. Look at the split for your real workload before you optimize; do not assume.

The point is awareness. Most teams never look at the input-versus-output breakdown of their spend, so they optimize the cheap half and leave the expensive half untouched. Reverse that.

This is a distinction we take seriously at Loopsfinity, where the shape of what an agent emits is treated as a cost decision as much as a quality one, so an agent is nudged toward tight, structured output rather than paying the premium to think out loud. How we do that is our own work. The pricing asymmetry behind it is public, and it is worth building around whatever you use. If you want the full picture, start with what an AI coding agent actually costs per feature and the economics of AI coding agents.