For months, the dream of truly autonomous AI agents has been throttled by a brutal economic reality known as the reasoning tax. Developers building complex workflows found themselves trapped in a paradox: to achieve the reliability required for production, they had to use high-reasoning settings that cost an exorbitant amount per task. A single deep-research agent might burn through thirty dollars just to find one obscure fact, making the unit economics of AI agents unsustainable for everything but the most expensive enterprise contracts. The industry has been waiting for a breakthrough that decouples frontier-level intelligence from the crushing cost of test-time compute.

The Economics of the GPT-5.6 Family

OpenAI has addressed this bottleneck with the release of the GPT-5.6 model family, specifically the Luna and Terra variants. The most striking evidence of this shift appears in the BrowseComp benchmark, a search-based evaluation designed to measure a model's ability to uncover rare facts. In this environment, GPT-5.6 Luna achieved a performance score of 84.04% while spending only 1.33 dollars. To put this in perspective, GPT-5.5 required 33.27 dollars to reach a nearly identical score of 84.36% just three months ago. This represents a 25-fold reduction in cost for the same functional outcome, fundamentally altering the financial baseline for agentic deployment.

This efficiency is not limited to search. The GPT-5.6 Sol model demonstrates a significant leap in reasoning efficiency on the Agents’ Last Exam benchmark. In a surprising reversal of traditional scaling laws, the low reasoning setting of GPT-5.6 Sol actually outperformed the high reasoning setting of GPT-5.5. This indicates that the model's internal reasoning pathways have been optimized to reach correct conclusions with fewer computational steps. For startups moving from initial testing to full product integration, this means that lowering the reasoning effort no longer necessitates a sacrifice in accuracy. In many cases, the newer, leaner settings are simply smarter.

Architectural Shifts in Reasoning and Execution

The real breakthrough in GPT-5.6 is not just a cheaper price tag, but a fundamental change in how the model handles logic and data. The most significant evidence of this is found in the ARC-AGI-3 tests. Using standard settings, the GPT-5.6 Sol model recorded a 13.3% accuracy rate. However, by applying two new primitives via the Responses API—Retained reasoning and Compaction—the accuracy jumped to 38.3%. This nearly threefold increase in performance was achieved without changing the model's underlying weights, and it came with a 6x reduction in output token usage.

Retained reasoning solves the chronic problem of logical drift. In previous iterations, as a reasoning chain grew longer, models often lost track of their initial premises or suffered from a decay in logical consistency. Retained reasoning explicitly preserves the core insights derived in earlier steps, ensuring the model maintains a stable logical anchor throughout the process. Compaction complements this by stripping away redundant or meaningless tokens from the reasoning trace. While Retained reasoning ensures the essential logic stays, Compaction ensures the fluff is removed, resulting in a high-density reasoning stream that is both more accurate and cheaper to generate.

Beyond internal logic, GPT-5.6 introduces Programmatic Tool Calling. Traditionally, when a model used a tool, it would pull all the resulting data back into its context window to analyze it. If an agent searched 100 financial documents, the model had to read every single line of those documents, consuming massive amounts of tokens and risking context overflow. GPT-5.6 changes this by writing and executing JavaScript code in an external runtime. Instead of reading 100 documents, the model writes a script to filter those documents for specific dates and transactions externally. The model only receives the refined, final result. By moving data processing out of the context window and into a code execution layer, OpenAI has shifted the model's role from a data processor to a high-level controller.

This architectural evolution extends to native multi-agent orchestration within the Responses API. The system now supports a native Orchestrator and Subagent structure. The Orchestrator breaks down a complex goal into smaller, specialized tasks and delegates them to Subagents. These Subagents operate independently and return their findings to the Orchestrator, which then synthesizes the final answer. This structure, which also powers the ultra capability settings in ChatGPT, removes the need for developers to manually build complex communication loops and state management systems in their own application code.

Optimizing Latency and Infrastructure

To further reduce the friction of agentic workflows, OpenAI has overhauled the prompt caching system. The Prompt Cache TTL (Time To Live) has been extended to a minimum of 30 minutes. For services that repeatedly reference massive documents or complex system prompts, this significantly increases the cache hit rate, eliminating the need to re-calculate the same prefix for every single turn in a conversation. This is particularly critical for interactive agents where the user might pause for several minutes between prompts.

Developers now have deterministic control over cache breakpoints. Rather than relying on the system to decide where to cache, developers can specify exactly where the cache should be split. This is a game-changer for few-shot prompting, where a large block of static examples is followed by a small, variable user input. By fixing the breakpoint after the examples, the system only calculates the new user input, drastically increasing response speed.

Furthermore, the introduction of the `prompt_cache_key` allows for engine affinity. In a distributed cloud environment, requests are typically routed to any available hardware engine. However, by using a specific key, a request can be routed back to the same engine that previously processed the same prefix. Since that engine already has the data loaded in its local memory, the latency associated with reloading the context is eliminated. This reduces the time-to-first-token, making agents feel more responsive and real-time.

The New Blueprint for Agent Deployment

The release of Luna and Terra marks the end of the era where developers had to choose between a cheap, incompetent model and an expensive, capable one. The current state of the art allows for a tiered deployment strategy. In a high-volume pipeline, the most efficient architecture is no longer a single flagship model, but a hybrid chain. For example, a legal tech application can use Terra or Luna to handle the initial parsing of thousands of handwritten notes—a repetitive, low-complexity task—and only escalate the final, high-stakes strategic synthesis to a flagship model.

By utilizing the steerable reasoning effort settings, developers can now find the exact equilibrium between cost and performance for every single step of their workflow. The ability to control the number of subagents and the depth of their reasoning means that token spend is no longer a fixed cost of intelligence, but a tunable parameter. The economic barrier to entry for frontier-grade agents has effectively collapsed, shifting the challenge from managing costs to designing more ambitious, multi-step autonomous systems.