Article Overview
Most coverage of GPT-5.6 focuses on the headline model — Sol's benchmark scores, the government-coordinated rollout, the general availability announcement. This article is about the part that matters more for the people actually building with it: how to use it efficiently.
OpenAI published a builder's guide assembled from real startup experiences with GPT-5.6 in production. The findings are specific and in several cases counterintuitive. GPT-5.6 Sol at low reasoning effort outperforms GPT-5.5 at high reasoning effort on a key benchmark, which means the instinct to set maximum reasoning and use the flagship model — the rational default from the previous generation — now costs more without delivering more. GPT-5.6 Luna scored 84.04% on BrowseComp, essentially matching GPT-5.5's 84.36%, but at $1.33 rather than $33.27 — a 25-fold cost reduction for the same performance. A startup running the same GPT-5.6 Sol model with retained reasoning and compaction enabled saw ARC-AGI-3 scores jump from 13.3% to 38.3% using six times fewer output tokens.
This article explains the four architectural patterns that produced these results — model selection, programmatic tool calling, multi-agent orchestration, and prompt caching — with the specific benchmark data and startup experiences behind each one.
Introduction
There is a version of building with AI that most startups eventually outgrow. In that version, every task goes to the most capable model at the highest reasoning setting, every intermediate result passes through the model's context window, and cost is treated as a problem to solve later once the application is proven.
GPT-5.6 breaks the assumptions that made that approach defensible. The relationship between model size, reasoning effort, and output quality has shifted significantly with this generation, and the startups that figured this out early are reporting cost reductions that change the economics of entire product categories.
This is OpenAI's own account of what those startups found, assembled from production testing across eight companies and four benchmark evaluations.
Quick Summary
| Pattern | Result |
|---|---|
| GPT-5.6 Sol low effort vs GPT-5.5 high effort | Sol low wins on Agents' Last Exam |
| GPT-5.6 Luna vs GPT-5.5 on BrowseComp | 84.04% vs 84.36% at $1.33 vs $33.27 |
| Retained reasoning + compaction on ARC-AGI-3 | 13.3% → 38.3%, 6x fewer tokens |
| Programmatic Tool Calling at Rogo | Same quality, 21% fewer input tokens |
| Prompt cache breakpoints at Ploy | 28% reduction in uncached input |
Part One: The Counter-Intuitive Reasoning Effort Finding
The clearest signal in the guide is the one that is most likely to change developer behavior immediately: lower reasoning effort frequently delivers better results than higher reasoning effort with GPT-5.6.
On Agents' Last Exam — a benchmark measuring performance on long-horizon tasks — GPT-5.6 Sol at the low reasoning setting outperformed GPT-5.5 at the high reasoning setting when the task harness was held constant. This inverts the previous generation's logic, where squeezing more performance out of a model meant pushing reasoning effort higher and accepting the token cost.
Hex's AI Research Lead Izzy Miller describes what this looks like in practice: "We dropped GPT-5.6 into our harness, and low reasoning effort gave us our best results. It knew when the data just wasn't there, didn't chase bad leads, and got to the right answer with fewer tokens."
The underlying reason is that GPT-5.6's improvements in accuracy mean the model needs less extended reasoning to reach the right answer on tasks where GPT-5.5 needed maximum effort to compensate for weaker base judgment. More reasoning tokens do not improve an answer that the model can already reach confidently — they add cost and occasionally introduce overthinking on tasks that should be straightforward.
The practical implication is direct: start at lower reasoning effort and evaluate before assuming maximum effort is necessary. The default settings that were appropriate for GPT-5.5 are likely over-engineered for GPT-5.6.
Part Two: Model Selection Has Changed
The standard pre-GPT-5.6 advice for long-horizon agentic applications was to use the flagship model at the highest available reasoning. Smaller, cheaper models could not reliably handle extended tool calling chains, long contexts, or complex reasoning over multiple turns.
That has changed. With additional test-time compute, Luna and Terra can now perform comparably to GPT-5.4 and GPT-5.5 on a range of tasks while costing significantly less. The BrowseComp benchmark provides the most striking quantification of this shift.
BrowseComp tests a model's ability to find obscure facts through multi-step search — the kind of extended research task that previously required frontier models to handle reliably. Three months before the guide's publication, GPT-5.5 at Extra High reasoning scored 84.36% at a cost of $33.27 per task. GPT-5.6 Luna at Extra High reasoning now scores 84.04% — essentially the same result — at a cost of $1.33 per task. That is 25 times cheaper for the same performance, and OpenAI notes prices have been reduced further since that measurement.
Hypha's engineering lead for agents, Serhii Shchoholiev, quantifies a similar finding in document processing: "Luna keeps 98% of GPT-5.5's extraction accuracy at one-eighteenth the cost. That gives our agents high-quality document understanding at a price that makes it practical across many more workflows."
The pattern that emerges from multiple startup experiences is the same: use smaller models — Luna and Terra — for steps that are high-volume, latency-sensitive, or repeated within a larger workflow. Reserve Sol for the judgment-intensive steps where the quality differential actually justifies the cost. A legal-tech application parsing handwritten memos before agentic analysis is a concrete example: the parsing step uses Terra or Luna, the analysis step uses Sol. The overall cost of the workflow drops substantially without any sacrifice in quality on the parts that matter.
Part Three: Responses API Architectural Improvements
Beyond model selection and reasoning effort, OpenAI trained GPT-5.6 end-to-end with three specific architectural interventions in the Responses API that unlock further performance gains.
Reasoning Persistence and Compaction
Agentic tasks that unfold over many turns have a fundamental problem: context windows fill up, models lose track of earlier reasoning, and either performance degrades or the model has to spend tokens reconstructing what it already worked through. Reasoning persistence addresses this directly by allowing the model's reasoning state to be retained and carried across turns rather than rebuilt from scratch.
Native compaction works alongside this — compressing the accumulated context of a long-running conversation into a more efficient representation without losing the substance of what was established in earlier turns.
The ARC-AGI-3 result demonstrates how significant this is in practice. Running the same GPT-5.6 Sol model on the same benchmark: with the standard harness, it scores 13.3%. With retained reasoning and compaction enabled, it scores 38.3% — nearly three times better — while using approximately six times fewer output tokens. No changes to the model itself. Different architecture, dramatically different outcomes.
This finding has implications beyond ARC-AGI-3. Any agent application where multiple turns build toward a complex outcome stands to benefit from reasoning persistence and compaction. The cost reduction from fewer output tokens plus the quality improvement from better context maintenance compound together.
Multi-Agent Orchestration
Complex tasks that have parallelizable components can be handled more efficiently by distributing work across multiple agent workstreams than by forcing a single agent to work through everything sequentially. GPT-5.6's multi-agent capability in the Responses API implements this pattern natively: a primary agent orchestrates the workflow and delegates specific tasks to subagents, the subagents pursue their objectives in parallel, and their outputs return to the primary agent for synthesis.
This is also, OpenAI confirms, how Ultra mode in ChatGPT works — the consumer-facing "ultra" capability setting is the same multi-agent architecture available to developers through the API.
GPT-5.6 has its own judgment about when to spawn subagents, but this behavior is steerable. Developers can instruct the model on when subagent invocation is appropriate, which allows tuning to spawn agents only in situations where the additional token expenditure genuinely improves the result.
The startup experiences with multi-agent GPT-5.6 are consistent across different application types. Quadrillion founder E Chi, working on open-ended research problems: "GPT-5.6 Sol just clicked. It showed a marked improvement over GPT-5.5, finished faster than almost every other model we tested, and quickly became our go-to OpenAI model."
Obvious co-founder Jon Bell, who tested the orchestration behavior by giving GPT-5.6 six concurrent specifications across writing, building, and discussion: "GPT-5.6 is the best orchestrator we've seen from OpenAI. We threw six specs at it at once and it kept track of everything without the quality falling apart."
Part Four: Programmatic Tool Calling
Most agentic workflows contain two fundamentally different categories of work. One category requires genuine model intelligence — judgment, interpretation, synthesis, reasoning about ambiguous situations. The other category is mechanical — retrieving a file, filtering a list by date, joining two data sources, reformatting an output. Both categories currently pass through the model's context window, which means the model is spending reasoning tokens on work that a straightforward program could do deterministically and cheaply.
Programmatic Tool Calling addresses this by allowing GPT-5.6 to write JavaScript that orchestrates tool calls, runs them in parallel, and processes their outputs entirely outside the context window. The model's attention and token budget are reserved for the judgment-intensive work that actually requires model intelligence.
The financial research use case from Rogo illustrates the practical difference. An agent researching a company might retrieve a hundred SEC filings, filter them by date range, identify relevant transactions across them, and then synthesize the findings into an analysis. The retrieval, filtering, and data organization steps are not matters of judgment — they are matters of execution. Programmatic Tool Calling lets GPT-5.6 write the code that handles those steps outside the context window, then reason over the filtered, organized results rather than every intermediate output.
Rogo's Alex Wang: "In our evaluations, GPT-5.6 using Programmatic Tool Calling matched our rubric quality while using 21% fewer input tokens. That's the difference between an agent that can discuss financial research and one that can actually carry it out."
The 21% input token reduction compounds with volume. For applications processing thousands of research tasks, the savings are material. For applications where context window size was the limiting factor preventing certain workflows from being viable, moving deterministic work out of the context window may make previously impossible applications practical.
Part Five: Prompt Caching Improvements
Two changes to prompt caching in GPT-5.6 have meaningfully improved the practical cache hit rates that startups report.
The minimum cache TTL has been extended to 30 minutes, compared to shorter windows in previous generations. For agents that run the same base prompt repeatedly across multiple requests — a common pattern in applications with shared system prompts or workspace context — this means the cached prompt can be reused across runs without expiration between them.
Explicit cache breakpoints can now be set deterministically within the context window. Rather than relying on the API to decide where to cache, developers can specify exactly where caching should occur, which allows predictable, reliable cache utilization rather than probabilistic.
Ploy's AI engineer Lorenzo Gentile describes the combined effect on a production application: "We added cache breakpoints and workspace-specific keys to a shared 29,000-token prompt and cut uncached input by 28%. The 30-minute cache window was a big unlock too: our agents could reuse the same context across runs instead of starting from scratch."
For applications with substantial shared context — a large system prompt, workspace state, shared tools definitions — the 28% reduction in uncached input represents both direct cost savings and latency improvement from cache hits versus fresh processing.
Using a consistent prompt_cache_key reinforces this: it increases the probability that requests land on the same inference engine instance that previously served the same prompt prefix, which reduces latency beyond what caching alone provides.
Putting It Together: The New Economics
The guide's conclusion identifies the overarching change that all four patterns point toward: the economics of building agents have shifted fundamentally with GPT-5.6.
Under the previous generation's model, the sensible default was a single frontier model at maximum capability processing every step of every workflow. There was no meaningful alternative — smaller models were not reliable enough for long-horizon tasks, and the cost of using them incorrectly outweighed the savings from trying.
GPT-5.6 changes both sides of that calculation. The smaller models are now reliable enough for many high-volume steps, reducing the cost of those steps by an order of magnitude or more. The architectural primitives — reasoning persistence, compaction, programmatic tool calling, explicit caching — reduce the cost of the steps that do require the frontier model. And lower reasoning effort on GPT-5.6 Sol outperforms higher reasoning effort on GPT-5.5, meaning even the most demanding steps no longer require maximum settings to achieve maximum results.
The BrowseComp data captures the overall shift most crisply: the same benchmark performance that cost $33.27 three months ago now costs $1.33. That is not a marginal improvement — it is a change in what categories of applications are economically viable to build.
Final Takeaway
The four patterns in OpenAI's builder guide — choosing the right model tier for each step, using reasoning persistence and compaction for long-horizon tasks, moving deterministic work outside the context window with programmatic tool calling, and setting explicit cache breakpoints — work together to produce results that were previously achievable only at much higher cost.
For developers currently running GPT-5.5 workloads at maximum reasoning settings, the path to cost reduction is clear: benchmark at lower reasoning effort first, then evaluate whether Luna or Terra can handle the high-volume steps, then enable the Responses API architectural features that maintain coherence over extended tasks.
The economics of AI agent applications have changed more in this generation than in any previous one. The developers who build accordingly will find that applications that were not viable at GPT-5.5 pricing now are.
