The first dial: a lower effort level beats last gen's highest

Since GPT-5, each generation has chased the same goal: accomplish more with fewer tokens. GPT-5.6 continues this trend—the Harness (the orchestration layer around the model: how requests are sent, tools are called, and loops are run) is unchanged, yet performance climbs and costs fall.

The guide's most direct example: with the Harness completely fixed, GPT-5.6 Sol at 'Low' reasoning effort outscores GPT-5.5 at 'High' on the Agents' Last Exam benchmark. Since effort is the main cost lever, winning this matchup means the same task just got a whole price tier cheaper. The guide doesn't publish specific scores for this particular comparison.

For a direct comparison you can verify yourself, here are three matchups, all drawn from real data points on the benchmark charts. Old model on the left, new model on the right:

The cost scales on the two charts are very different: the search benchmark costs a few dollars to run completely, while the coding index costs hundreds or thousands—the topics and task complexity aren't comparable. Don't compare dollar amounts across the two charts. Each comparison above is within the same chart.

So what are you actually saving on? It's the wasted effort. Hex, a data analytics company, dropped the model into their existing Harness and found the lowest effort setting gave them the best results they'd ever seen:

We put GPT-5.6 into our existing Harness, and the low reasoning setting gave us the best results we've had. It knows when the data just isn't there, doesn't chase dead ends, and gets to the right answer with fewer tokens.

Izzy Miller, Head of AI Research at Hex

That phrase—"knows when the data isn't there"—is the key. Older models would rephrase a search query and keep digging when they couldn't find something, paying for every tool result that came back as input tokens. A model that knows when to stop saves exactly those wasted cycles.

Lowering Effort Works, But Turning It Off Completely Costs More

Lowering the effort level saves money. So wouldn't turning it off entirely save even more? Looking at the actual data points on OpenAI's charts, the answer is no.

The dial below lets you explore this: pick a reasoning level, and watch the cost and score for all four models change. The cost bars are scaled so GPT-5.5 at Xhigh equals the full length of the track ($33.27 on the Search benchmark).

Now move the dial all the way to the left. You'll see something counterintuitive: turning reasoning off does not save money. There's evidence for this on both official charts:

• Sol on the Search benchmark: With reasoning off, it costs $1.97 for a score of 69.67. At the lowest effort setting, it costs just $0.50 for a score of 65.32. So turning reasoning off didn't save money—it cost 3.9x more for only 4.3 extra points.
• Luna on the Coding Index: With reasoning off, it costs $123.66 for a score of 37.30. At the lowest effort setting, it costs $74.84 for a score of 42.40. This one is both more expensive and worse—65% more money for 5.1 fewer points.

There's a similar inflection point at the other end. On Search, Luna going from "Xhigh" to "Max" sees its bill rise from $1.33 to $1.42, but its score drops from 84.04 to 83.25. Maxing out the dial doesn't necessarily help either.

The second dial: smaller models can save 25x

Once you've adjusted the effort dial, the next one is model choice. GPT-5.6 comes in three sizes: Sol (flagship), Terra (mid-size), and Luna (small).

In the past, the smaller models were only good for edge cases—they couldn't handle long contexts or heavy tool use, and they'd fall apart once the task chain got long. That's changed with this generation, thanks to test-time compute.

The result is that Luna and Terra can often match GPT-5.4 or GPT-5.5 performance at a tiny fraction of the cost. The guide's headline comparison comes from BrowseComp, a benchmark that tests the ability to unearth obscure facts:

Hypha, a document agent company, reported a different angle:

Luna retains 98% of GPT-5.5's extraction accuracy at 1/18th of the cost. This makes high-quality document understanding affordable for our agents, and at this price, it becomes viable in far more scenarios.

Serhii Shchoholiev, Head of Agent Engineering at Hypha

Where Do Smaller Models Fit in a Workflow?

There are three types of tasks they're best suited for: high-volume tasks, latency-sensitive interactions (where users are waiting), and steps that repeat frequently in an agent flow.

The guide's example is a legal tech company. Before its agent can analyze documents, it has to parse handwritten memos into text. This parsing step doesn't require judgment, but previously it used the flagship model along with the rest of the flow. By isolating it and switching to Terra or Luna, they saved real money, while the step that actually requires judgment continued to use Sol.

These two charts were run by OpenAI. They include competitor models like Claude Fable 5, Claude Opus 4.8, Claude Mythos Preview, and Gemini 3.1 Pro Preview. On the BrowseComp chart, competitors appear only as horizontal reference lines, showing their scores (Claude Mythos Preview 87.9%, Gemini 3.1 Pro Preview 85.8%, Claude Opus 4.8 84.4%) without corresponding costs, so you can't directly compare their prices to the ones above. Our charts here only show the relationships between GPT-5.6 models, their effort levels, and their costs.

Three architectural switches: two of them nearly triple performance

Once you've maxed out the model and effort dials, there's not much more to squeeze there. The remaining savings come from architecture—specifically, what your agent stuffs into its context on each turn.

The guide organizes its efficiency methods into three categories, and stresses that GPT-5.6 was trained end-to-end with these three things in mind. The model understands how to work with them natively; you don't need to build external tricks to coax it into behaving:

The guide provides a concrete example of how much these three together can help. On the ARC-AGI-3 benchmark, GPT-5.6 Sol scores 13.3% with a standard Harness. Simply turning on "Persistent Reasoning" and "Compaction" jumps the score to 38.3%, while also producing about 6x fewer output tokens:

The score nearly tripled, yet the token count dropped by five-sixths. Both happening at once shows exactly what you're saving: the wasted cycles of "rethinking" and "reorganizing" the context.

Switch 1: Stop the Model from Rethinking Everything

The first switch addresses the most expensive waste in long tasks: the model redoing work it's already done.

Persistent Reasoning: Bringing Last Turn's Thinking into This Turn

Previously, a model's chain-of-thought was discarded after each response. The next turn, it could only see the conversation history—not what it was thinking a moment ago—so it would reason from scratch again. GPT-5.6 supports carrying reasoning entries from previous turns into the next context. The parameter is reasoning.context:

Two things to watch out for. First, all_turns only works if this request can access the previous responses—either by chaining with previous_response_id or by replaying the full response history. On your very first request, there's no difference between the two settings, since there's no prior reasoning to carry over. Second, it only provides continuity: those reasoning entries remain encrypted and unreadable. The API doesn't return reasoning text; you can't see what the model was thinking.

Native Compaction: Automatic Packing at a Threshold

Conversations only get longer. Native compaction works by setting a line: include context_management in your request, with a compact_threshold (say, 200,000 tokens). When the rendered context exceeds this line, the server automatically compacts, emitting a "compaction entry" in the same response stream, then truncating the earlier context and continuing to reason. No extra API call is required from you.

The easiest thing to misunderstand here is the nature of the compaction entry. It's opaque and unreadable—the official docs describe it as "opaque and not intended to be human-interpretable." This is not the same as "have the model write a summary of the conversation." A summary is natural language; what gets written and what gets dropped is up to the model's discretion in the moment. A compaction entry is a structure the model learned to encode and decode during training, carrying the previous state and reasoning along in fewer tokens without losing anything.

while keep_going:
    response = client.responses.create(
        model="gpt-5.6",
        input=conversation,
        store=False,
        context_management=[{"type": "compaction", "compact_threshold": 200000}],
    )
    conversation.extend(response.output)
    conversation.append({"type": "message", "role": "user",
                         "content": get_next_user_input()})

There's also a standalone /responses/compact endpoint for when you want full control over timing. You send in an entire context window, and it returns a compacted window, fully stateless. There's a hard rule for using it: pass the returned window verbatim to your next call—don't trim it yourself, because besides the compaction entry, that window also contains entries from the last turn that need to be retained.

Conversely, if you're using server-side compaction chained with previous_response_id, don't manually trim entries either. Only in the stateless input-array mode can you drop everything before the most recent compaction entry, making the request body smaller and reducing tail latency.

Switch 2: Let the Model Write Code to Filter Data

Long tasks are no longer redoing work, but there's another, more common waste: the context window getting bloated with intermediate results.

Agent work actually comes in two flavors. One requires judgment—is this contract problematic, should I keep digging? The other is pure data handling—filtering, merging, sorting, deduplicating, summing. The problem is, in the past, both had to happen inside the model's context.

Here's the guide's example: Your agent pulls back 100 files, needs to filter them by date, and then find the relevant transactions among them. The old way, all 100 files go into the context, and the model reads through them one by one. Three bad things happen simultaneously: it's slow, it's expensive, and the more cluttered the context gets, the more confused the model becomes (this phenomenon is called "context rot").

Programmatic Tool Calling takes a different approach: the model writes a bit of JavaScript to orchestrate those tools directly. This code can make independent calls concurrently, write loops and conditionals, and keep all intermediate results inside OpenAI's managed runtime. Only the final, filtered result is handed back to the model.

Where Does That Code Run?

It runs in a brand-new, isolated V8 runtime, completely clean on every execution. The environment's boundaries are strictly defined:

• What's there: JavaScript with top-level await; access to the tools you've opened up in this request; the ability to output results with text(...) or image(...).
• What's not there: Node.js, package installation, network access, a general file system, subprocesses, console, and any state between executions.
• Your functions still run on your own server: When the program hits your tool, it pauses, sends the call out to you, and only continues after you've run it and returned the result with the original caller field intact. A single run can pause many times.

You decide which tools the code is allowed to call. Each tool gets an allowed_callers annotation:

Tool types that can be called from code: regular functions and custom tools, MCP tools, apply_patch, local and hosted shells, and the code interpreter. MCP approval policies still apply; if your setup requires approval, the program will pause and wait for you to approve.

{
  "type": "function",
  "name": "get_inventory",
  "parameters": {
    "type": "object",
    "properties": { "sku": { "type": "string" } },
    "required": ["sku"],
    "additionalProperties": false
  },
  "output_schema": {
    "type": "object",
    "properties": {
      "sku": { "type": "string" },
      "available_units": { "type": "number" }
    },
    "required": ["sku", "available_units"],
    "additionalProperties": false
  },
  "allowed_callers": ["programmatic"]
}

When Not to Use It

This switch isn't always a win. The official docs include a helpful decision table, based on whether the control flow for this segment is predictable and whether code can actually shrink the result:

When both modes are enabled, you also need to tell the model which segment uses which path. Telling it to "use Programmatic Tool Calling efficiently" doesn't establish a boundary. The official docs offer a copy-paste template:

<tool_orchestration>
Use Programmatic Tool Calling for [bounded stage] using only [eligible tools].
Run independent calls concurrently when safe. Use only documented tool input
and output fields.
Process and reduce the intermediate results, then emit exactly [program result shape],
including the evidence needed for the final answer.
Stop when [condition] is met. Retry transient failures at most [R] times.
Do not repeat completed calls or perform side-effecting actions. If a required
result is still missing, return a clear structured failure.
Use direct tool calls for [semantic judgment, approval, or final validation].
</tool_orchestration>

Rogo, a financial research company, applied this to the chain of pulling financial reports, coordinating tools, and calculating numbers:

In financial research, the difficulty lies in reliably pulling documents, coordinating tools, and getting the numbers right. In our benchmarks, GPT-5.6 with Programmatic Tool Calling achieved the same scoring standard as before, while using 21% fewer input tokens. That's the difference between "an agent that can talk about financial research" and "an agent that can actually complete financial research."

Alex Wang, Applied AI Team at Rogo

Switch 3: Main Agent Delegates Parallel Work

While deterministic work can be moved out, splittable work should also happen simultaneously.

If a task can be divided into independent chunks, a single agent has to do them sequentially. Multiple agents can work at the same time. GPT-5.6 builds this orchestration into the API: The main agent (called /root) handles task decomposition, delegation, waiting for results, and synthesizing a final answer. Your application doesn't need to write any orchestration logic.

Qualia fed a pile of open-ended research questions to a team of agents, and GPT-5.6 Sol got it right on the first try. It's a clear step up from GPT-5.5 and faster than almost any model we've tested, which quickly made it our default OpenAI model.

E Chi, Founder of Quadrillion

GPT-5.6 is the best orchestrator we've seen from OpenAI. We gave it six requirements at once (write, build, and explain all six), and it never dropped a thread or lost quality.

Jon Bell, Co-founder & CPO at Obvious

There are three distinct benefits here: Parallel execution saves wall-clock time; separate contexts mean each subagent gets a well-defined task, independent work doesn't interfere in the same context, and accuracy actually goes up; and model-driven coordination means spawning, messaging, and waiting are all handled by the model itself.

How to Enable and Manage It

The model has its own judgment about "how many to spawn and when," but this is something you can control. The official docs offer two ready-made messages, one conservative and one aggressive. Just paste them into your prompt:

Conservative: only spawn when the user explicitly asks

Do not spawn subagents unless the user explicitly asks for subagents,
delegation, or parallel agent work.

Aggressive: proactively delegate when parallelism would clearly help

Proactive Multi-agent delegation is active. Use subagents when parallel
work would materially improve speed or quality.

During execution, you'll see six types of coordination actions in your output. These are managed server-side, so your application doesn't need to execute them or return results for them:

Four Cases Where You Shouldn't Use It

There are four clear anti-patterns for this switch:

• Each step directly depends on the previous one—it's an ordered reasoning chain that can't be broken up.
• The task is small enough to finish in a single run—the overhead of delegation outweighs the work itself.
• Several agents would contend for the same mutable resource—frequently writing to a single shared state means parallelism just causes conflicts.
• You need a fixed, deterministic execution graph—if the model does the scheduling, the execution path isn't fully predictable.

Also, if the whole task is bottlenecked by a single slow external operation, adding more agents won't make it faster.

Enabling Multi-Agent Comes with Side Effects

The official docs list a few limitations, and the first one directly affects what we covered in the previous section:

• Compaction is automatically enabled. Setting multi_agent.enabled to true implicitly turns on server-side compaction, even if you haven't configured a context_management field. Compaction applies independently to the root agent and each subagent, preserving each of their contexts. You can still explicitly set a compact_threshold to override the default.
• The standalone /responses/compact endpoint is unavailable. If you were managing compaction timing yourself, that approach isn't supported in multi-agent mode.
• reasoning.summary is not supported.
• max_tool_calls is not supported. If you were relying on this field to cap tool calls, you'll need another strategy before enabling multi-agent.

The "ultra" tier you see in ChatGPT runs on this exact mechanism. On the BrowseComp chart, it occupies its own point: GPT-5.6 Sol Ultra at Max effort scores 92.18, at a cost of $12.17—1.8 points higher than Sol alone at Max (90.36), for roughly double the bill.

The Last Switch: A Misplaced Cache Breakpoint Costs Money

The first three switches are pure wins. This one is different—it can actively lose you money.

The guide has two good pieces of news about caching: the entire model family now has a cache lifetime of at least 30 minutes, and cache breakpoints can now be set deterministically within the context. Ploy shared their real-world test:

We added a cache breakpoint and a key based on workspace to a shared 29,000-token prompt, and our uncached input dropped by 28%. The 30-minute cache window is also a big unlock: our agents can reuse the same context across multiple runs without loading from scratch every time.

Lorenzo Gentile, AI Engineer at Ploy

But a table in the official docs reveals something the guide leaves out: GPT-5.6 changed how cache matching works.

By default, the system places an implicit breakpoint at the most recent user or tool message and does not automatically search backwards for the longest matching prefix like older models did. The three-tier pricing can be summarized in three lines:

Put those two facts together, and you can see how you'd lose money. Imagine your prompt is "a stable few-thousand-word instruction + a timestamp + the user's question this turn." With nothing configured:

Wherever you mark the breakpoint, that content block plus everything rendered before it becomes the reusable prefix. So the rule is simple: find the part of your prompt that never changes, and draw the breakpoint right after its last character.

{
  "model": "gpt-5.6",
  "prompt_cache_key": "support:knowledge-base-v1",
  "prompt_cache_options": { "mode": "explicit" },
  "input": [
    {
      "type": "message",
      "role": "developer",
      "content": [
        {
          "type": "input_text",
          "text": "Follow the shared support policies and reference material...",
          "prompt_cache_breakpoint": { "mode": "explicit" }
        }
      ]
    }
  ]
}

You can set multiple breakpoints, which is useful when different parts of your prompt change at different frequencies (shared instructions are stable, reference material updates occasionally). This way, each request can reuse the longest unchanged prefix. But there are two limits to keep in mind: you can write a maximum of 4 new caches per request (if you have more than 4 breakpoints, only the last 4 get written; in implicit mode, the breakpoint at the latest message takes one of those slots), and you can look back a maximum of 50 recent breakpoints when reading. When multiple breakpoints match, the server reads from the longest matching prefix.

How to choose among the three modes: Implicit (default) is for conversational patterns where you're appending new content and the history before it is static. Implicit plus explicit breakpoints is for when both a shared prefix and a growing history are worth reusing. Explicit only is for when your prefix is stable, but everything after it changes every time and almost never gets reused.

One more thing related to latency: assigning the same prompt_cache_key to related requests increases the chance they land on the same inference machine, which is more likely to have the prefix already written. That lowers latency too.

Parameter Cheat Sheet for All Six Changes

The whole article boils down to this table.

Limitations Only in the Official Docs

• A cache prefix shorter than 1,024 tokens never enters the cache. This number applies to the entire rendered prefix up to the breakpoint, not just the block you marked.
• Keep traffic per prompt_cache_key to around 15 requests per minute. Higher rates will drop your hit rate. For high traffic, use stable, deterministic keys and shard across them.
• Each reuse refreshes the 30-minute lifetime, and the refresh doesn't incur a write fee. The 30 minutes start from the moment of writing and re-arm each time it's reused.
• Spawning subagents burns extra tokens. For tasks that can't be split, or that frequently write to shared state, enabling it just spends money on coordination.
• The Programmatic Tool Calling sandbox has no network, no file system, no package installation, and leaves no state behind after execution. The code can only interact with the outside world through the tools you've made available in that request.
• You can write at most 4 new caches per request and look back at most 50 recent breakpoints. If you set more breakpoints, only the last 4 get written.
• Enabling multi-agent implicitly turns on server-side compaction, and the /responses/compact endpoint, reasoning.summary, and max_tool_calls are no longer supported. This is the easiest one to miss: you think compaction isn't on, but it is.

Troubleshooting Cache Misses

The guide's closing thought sums up the whole table: the work that used to require a frontier model at every step can now be done with a smaller model, a tuned reasoning effort, and a few architectural choices—achieving the same or better results at a fraction of the cost.

The first instinct to save money might be to turn off "thinking." OpenAI's own charts show the opposite: disabling reasoning never made the bill lower.

The right direction is to start from the lowest effort and go up, watching cost and score together, and stop at the sweet spot.

Beyond effort and model size, GPT-5.6 has three things trained directly into the model: keeping reasoning across turns, moving data-shuffling work into code, and delegating splittable tasks to parallel subagents. All three are configuration changes—no model swap, no Harness rewrite.

The six levers come in two layers: two dials (reasoning effort, model size) and four config switches. All are configuration changes—no model swap, no Harness rewrite.