Does gpt-5.6 use less tokens?

Why Token Bills Keep Growing as AI Agents Scale

Your AI agent bill grows even when nothing changes — because agents scale token consumption, not just usage. Every tool call dumps raw output into context, every retry multiplies it, and costs balloon quietly as workflows multiply across teams.

The hidden drivers are usually not the model itself. They are the bulky tool responses piped back into context, the repeated instructions re-sent with every call, and the ever-growing conversation history that agents carry along. A single agent run can consume thousands of tokens on intermediate data the model never actually needs.

This is why OpenAI's framing of GPT-5.6 is notable. The company states it trained the model to "get more useful work from every token," reporting state-of-the-art results with fewer tokens and lower estimated cost than previous and competing frontier models. On the OSWorld 2.0 computer-use benchmark, Sol surpassed Opus 4.8 while using 85% fewer output tokens, and on coding benchmarks it achieved top scores with less than half the output tokens of competitors.

The mechanism matters as much as the numbers. GPT-5.6's Programmatic Tool Calling lets the model write and run lightweight programs to coordinate tools, filtering intermediate data instead of pushing every tool response through the model. That directly attacks the context-bloat problem: fewer tokens, fewer model round trips, and less guidance for tool-heavy tasks.

But there is a deliberate exception. The ultra mode coordinates four agents in parallel, "trading higher token use for stronger results and faster time-to-result." So the honest answer to whether a model can be trained to do more per token is: yes by default, no when you push it into maximum-effort modes. Meanwhile, internal adoption signals show token consumption still climbing — OpenAI reports daily output tokens per active researcher more than doubled versus GPT-5.5's peak, and internal agentic token usage rose roughly 22-fold over six months.

For teams building agents, the practical takeaway is that model efficiency and workflow design are separate levers. Techniques like semantic compression on tool outputs (70–90% reduction) and externalized state (40–70% savings) address waste the model cannot fix on its own. Choosing which tools and skills an agent actually sees is part of that discipline — SkillzBench is building a free directory of security-scanned, benchmarked agent skills plus a free MCP connector so you can test which skills genuinely reduce workflow overhead before committing them to production.

The question is no longer just which model is smartest, but which one — and which setup — turns each token into completed work.

The Evidence: GPT-5.6's Token Efficiency vs GPT-5.5 and Competitors

The headline numbers are striking: OpenAI reports GPT-5.6 delivers state-of-the-art results while burning a fraction of the tokens its competitors need. But the fine print matters, because the efficiency story has one deliberate exception.

On coding and computer-use benchmarks, the gains are substantial. According to OpenAI's announcement, GPT-5.6 Sol hits a score of 80 on the Artificial Analysis Coding Agent Index — 2.8 points above Claude Fable 5 — while using less than half the output tokens, less than half the time, and roughly one-third less estimated cost. On OSWorld 2.0, Sol surpasses Opus 4.8 while producing 85% fewer output tokens.

Against its predecessor, the model earns more from the same budget. On ExploitBench 2, GPT-5.6 scored 73.5% versus GPT-5.5's 47.9% at a comparable output-token budget, and on SEC-Bench Pro it reached 71.2% versus 45.8% with improved latency. Independent-style testing by MindStudio found Sol produces usable outputs in roughly half the tokens of Fable 5 on common workflow tasks like drafting, summarization, and data extraction — though that vendor's methodology is unverified.

The architectural driver is Programmatic Tool Calling. Instead of pushing every tool response through the model, GPT-5.6 writes and runs lightweight programs to coordinate tools and filter intermediate data, so tool-heavy tasks advance with fewer tokens and fewer model round trips. For agent builders, this targets the real source of context bloat: oversized tool outputs.

• Coding: SOTA results at less than half the output tokens of Fable 5
• Computer use: 62.6% on OSWorld 2.0 with 85% fewer output tokens
• Cybersecurity: 25+ point gains over GPT-5.5 at comparable token budgets
• The exception: `ultra` mode deliberately trades higher token use for stronger results

That last point deserves emphasis. The ultra setting runs four agents in parallel by default, so the honest answer is: fewer tokens by default, more tokens in ultra mode. There's also a ceiling to the savings — third-party analysis places GPT-5.6 Sol at $2.79 per task versus $1.02 for its successor GPT-6.1 Sol, suggesting newer models now undercut it on cost efficiency.

One caveat worth stating plainly: these benchmarks are self-reported, with cost figures OpenAI itself labels "estimated," and no fully independent benchmark directly compares token counts per identical task. The direction of the evidence is consistent, but treat the magnitudes as vendor claims.

For teams running high-volume agent workflows, the practical takeaway is that token waste often comes from tool orchestration and context bloat rather than the model itself. Skills that streamline how agents call tools can compound these savings — SkillzBench is building a free directory of security-scanned, benchmarked agent skills plus a free MCP connector, so you can measure which skills actually reduce workflow overhead before committing to them.

The Catch: Where GPT-5.6 Costs More, Not Less

Here's the uncomfortable part of the token-efficiency story: GPT-5.6's savings come with exceptions that can quietly erase them. Two stand out — a mode designed to burn more tokens, and a pricing cliff that punishes long contexts.

First, ultra mode. OpenAI's announcement is candid about the trade-off: ultra coordinates four agents in parallel by default, deliberately trading higher token use for stronger results and faster time-to-result on demanding tasks. In other words, the "fewer tokens" claim holds by default — but flip on ultra and you're paying more, not less. Aivy's analysis goes further, noting that Sol's ultra mode spawning parallel subagents is likely to increase total token usage. If your workflow runs in ultra by habit, the efficiency thesis doesn't apply to you.

Second, the 272K long-context surcharge. GPT-5.6 offers a 1,050,000-token context window, which sounds like an invitation to stuff everything into one request. But per OpenAI's developer docs, once input exceeds 272,000 tokens, the entire request is billed at 2x input and 1.5x output rates — not just the overflow. That pushes GPT-5.6 Sol's long-context tier to $8 per million input tokens and $30 per million output. For agent workflows that accumulate large tool outputs, this is a genuine cost trap: a request that's 90% context can cost double what it would have a few thousand tokens earlier.

There's also a bigger-picture caveat: fewer tokens than predecessors doesn't mean lowest cost per task. Cost-per-task data on the AA Intelligence Index v4.3 shows GPT-5.6 Sol at $2.79 per task, while its successor GPT-6.1 Sol comes in at $1.02 — and scores roughly five points higher on the same index. Benchlm.ai's pricing analysis reaches a similar conclusion, observing that older tiers no longer save money: GPT-5.6 Sol's promotional $4/$20 pricing costs more per token than GPT-6.1 Sol's $2/$10. Staying on GPT-5.6 Sol, they argue, is now "a choice about behavior you've already validated, not about price."

The practical takeaway is to measure what actually matters:

• Track cost per correct result — (average tokens per call × price per token) ÷ success rate — rather than price per token alone
• Reserve ultra mode for tasks that genuinely demand parallel agents
• Keep requests under the 272K threshold, or split and compress context
• Compare GPT-5.6 against newer, cheaper tiers before defaulting to it

One last lever worth remembering: token waste in agent workflows often comes from tool outputs and context bloat, not the model itself. Semantic compression and streamlined tool orchestration can cut overhead substantially — and SkillzBench is building a free directory of security-scanned, benchmarked agent skills plus a free MCP connector so you can test which skills actually reduce workflow overhead before committing. Join the waitlist to get early access when it launches.

How to Actually Cut Token Costs: A Practical Checklist

Model efficiency gets you part of the way, but the biggest savings come from how you configure and measure your setup. Here's a checklist that compounds GPT-5.6's built-in gains with levers you control.

1. Keep ultra mode off by default. OpenAI is explicit that ultra "trades higher token use for stronger results" by coordinating four agents in parallel, per the official announcement. Reserve it for genuinely demanding tasks, not routine workflows.

2. Layer prompt engineering on top. Testing by MindStudio found prompt compression alone cuts 20–30% of tokens, while comprehensive prompt engineering reduces total usage by 40–60% in common workflow scenarios. GPT-5.6 Sol honors conciseness constraints more reliably than competitors, so explicit output limits actually stick.

3. Use caching and batching aggressively. Cached input runs at $0.40 per million tokens — 10% of the standard $4.00 rate — and the batch API takes 50% off for non-urgent jobs. For high-volume agent pipelines, these two settings alone can halve your bill.

4. Watch the 272K threshold. Per OpenAI's developer docs, requests above 272,000 input tokens are billed at 2x input and 1.5x output rates for the entire request. This is the single biggest cost trap for agent workflows that accumulate large tool outputs in context.

5. Track cost per correct result, not price per token. MindStudio's formula — (average tokens per call × price per token) ÷ success rate — captures what raw pricing misses. A model with a 15% error rate costs more than a cheaper-looking one with 3% errors, because retries and rework eat the savings.

Quick reference for the checklist:

• Default mode: on; ultra: only when the task demands it
• Prompt compression: 20–30% savings; full prompt engineering: 40–60%
• Cached input: 10% of standard rate; batch API: 50% off
• Context discipline: stay under 272K input tokens
• Metric: cost per correct result, never price per token

For agent builders, remember that token waste often comes from tool outputs and context bloat rather than the model itself. Techniques like semantic compression and externalized state target exactly that overhead. Agent skills that streamline tool orchestration can help too — SkillzBench is building a free directory of security-scanned, benchmarked skills plus a free MCP connector, so you can test which ones genuinely reduce workflow cost before committing.

Beyond the Model: Fixing Tool-Output Bloat with Agent Skills

Even the most token-efficient model can't save you from a bloated context window. If your agent is stuffing raw API responses, full file dumps, and verbose tool outputs into every prompt, you're paying for tokens the model never needed in the first place — and GPT-5.6's efficiency gains only go so far against that.

The model itself does help. GPT-5.6's Programmatic Tool Calling lets it write and run lightweight programs to coordinate tools, filtering intermediate data instead of passing every tool response back through the model — which means tool-heavy tasks advance with fewer tokens and fewer model round trips, according to OpenAI's announcement. But that architecture only trims what the model sees; it doesn't fix what your agent pipeline sends it.

That's where the real savings hide. Research on agent token reduction shows that semantic compression of tool outputs alone can cut 70–90% of those tokens, while externalizing agent state to storage outside the context window yields another 40–70% in savings, per token reduction research. The practical moves include:

• Compress or summarize tool outputs before they enter the context window, keeping only the fields the task actually needs.
• Externalize long-running state — conversation history, scratch files, intermediate results — so the agent retrieves only what's relevant.
• Trim agent instructions and skill definitions, since prompt compression alone yields 20–30% token reductions.
• Watch the 272K threshold: above it, GPT-5.6 bills the entire request at 2x input and 1.5x output rates, so a single bloated context can double your costs.

The catch is knowing which skills and tools actually reduce overhead versus which just add more instructions to your prompt. That's the problem SkillzBench is being built to solve: a free directory of agent skills that are security-scanned, version-pinned, and benchmarked in a sandbox with and without each skill, so you can see the measured lift before adopting anything. A free MCP connector will let you toggle skills and tools per agent, so your agent only sees what you've chosen — nothing more padding the context.

Model efficiency and context discipline compound. Pick a token-lean model, then make sure every token it does consume is doing useful work.