GPT-5.6 Released: Coding Benchmarks Surpass Rivals, Inference Speed 10x Faster

OpenAI's Extreme Counterattack: A New Model in Just 12 Days

When Claude's coding model dominated every major leaderboard with a commanding lead over all competitors, the entire industry held its breath for OpenAI. Yet counting from the rival model's official launch (excluding the dozen or so days it was forced offline), it took a mere 12 days for OpenAI to swiftly respond with GPT-5.6.

This almost "in-your-face" release cadence reflects the white-hot competition among today's top-tier large model vendors. The model iteration cycle has now compressed to a matter of days—whoever pulls ahead on key capabilities first can reclaim the initiative in both public opinion and the market. At a deeper level, this competitive tempo reflects structural shifts in the large model industry: as gaps in foundational capabilities steadily narrow, the power to define products first and to command the narrative becomes increasingly precious. The party that establishes the benchmark first often occupies the position of "industry standard" in users' minds, forcing latecomers to perpetually operate within a "catching up" rather than "leading" narrative framework.

Benchmark Reversal: Dual Breakthroughs in Coding and Security

On the highly representative agentic coding leaderboard Terminal-Bench 2.1, GPT-5.6 (Ultra configuration) scored 91.9%, while competing models generally hovered in the 83%–84% range. This means OpenAI not only successfully caught up but achieved a clear reversal.

What is Terminal-Bench 2.1? It is an evaluation benchmark designed specifically for agentic coding capabilities, with its core testing focused on a model's ability to autonomously complete complex programming tasks in a real terminal environment—including understanding and modifying multi-file codebases, debugging loops, dependency management, and command-line operations. Unlike traditional code-completion benchmarks (such as HumanEval), Terminal-Bench emphasizes "end-to-end task completion rate" rather than the quality of a single function's generation, and is therefore regarded by the industry as a key barometer for measuring the real-world capabilities of AI Coding Agents.

Notably, the design philosophy of Terminal-Bench 2.1 itself represents an important evolution in evaluation paradigms. Early benchmarks like HumanEval (introduced by OpenAI in 2021) primarily assessed a model's ability to "write correct functions," with relatively isolated problems. Terminal-Bench, by contrast, simulates the complete workflow of a real engineer in a command-line environment—the model must independently complete the full loop of "understanding requirements → locating code → modifying → testing → debugging," and any misstep in the intermediate stages leads to overall failure. This "outcome-oriented" test design makes it one of the coding evaluations closest to real-world development scenarios, and consequently it carries greater weight as a reference for enterprise-grade users.

Cybersecurity Becomes a Core Differentiator

Another notable point of differentiation in this release lies in its security strategy. The industry has widely criticized certain competing models for being "hypocritical"—once a query touches on sensitive domains like cybersecurity or biochemistry, they switch to a low-capability mode or outright block the request.

GPT-5.6 takes the opposite approach, with OpenAI explicitly listing cybersecurity as one of its core capabilities. According to the announcement, it can achieve near-top-tier performance on relevant benchmarks while using roughly one-third of the output Tokens. This "don't avoid, and be more efficient" positioning could become an important draw for professional security researchers.

Behind this strategy lies a core tension in the field of large model safety governance: the balance between over-refusal and security risk. Academics call this phenomenon the "capability-safety alignment tax"—after undergoing safety fine-tuning, models often misjudge sensitive but legitimate professional scenarios, indiscriminately refusing compliant requests such as vulnerability analysis, penetration testing, and CTF (Capture The Flag) challenges. By explicitly listing cybersecurity as a core capability this time, supplemented with an efficiency promise of "reaching top-tier levels using fewer Tokens," OpenAI is essentially signaling to the professional security community that the platform is willing to take on greater flexibility for compliant professional needs, rather than dodging regulatory pressure through crude blanket refusals.

Productizing Multi-Agent Collaboration: This Is the Real Highlight

The benchmark reversal is only surface-level; the series of new technologies released alongside GPT-5.6 reveal the more noteworthy strategic intent.

Ultra Mode (Berserk Mode) Natively Supports Multi-Agents

GPT-5.6 adds an "Ultra Mode." In this mode, the model not only enables the highest reasoning budget but also automatically activates parallel sub-agents: it breaks a complex problem into multiple sub-problems and rationally distributes them among sub-agents to collaboratively complete the task.

Multi-Agent Collaboration Architecture Background: The Multi-Agent framework has been an important development direction for large model applications in recent years. Traditional single models face bottlenecks when handling ultra-long context or complex tasks requiring parallel reasoning, whereas the multi-agent framework decomposes tasks into several subtasks, executes them in parallel via multiple independent Agents, and then aggregates the results—significantly improving task completion efficiency and the ceiling on quality. Previously, developers typically had to rely on open-source frameworks like LangGraph or AutoGen to manually orchestrate Agent collaboration logic, with a fairly high development barrier. By internalizing this capability as a native product feature, GPT-5.6 marks a paradigm shift of multi-agent collaboration from "engineering practice" to "native model capability."

The core value of this design is that OpenAI has directly internalized the "multi-agent collaboration" framework—which developers previously had to build manually—as a native capability of the model product. This lowers the barrier to developing complex tasks while further raising the ceiling on the model's problem-solving capabilities.

From a more macro perspective on technological evolution, the "nativization" of the multi-agent framework is a product milestone of historic significance. As early as 2023, the AutoGen framework released by the Microsoft Research team validated the enormous potential of multi-Agent collaboration on tasks such as code generation and scientific reasoning, but the barrier to use back then was extremely high—developers had to manually define Agent roles, design communication protocols, and handle error-rollback logic, with a complete multi-Agent project often requiring hundreds of lines of orchestration code. GPT-5.6 encapsulates this complexity behind the single toggle of "Ultra Mode," essentially democratizing a capability that once belonged to top-tier AI engineering teams and pushing it directly to a much broader developer community—this is where its true productization value lies.

Cheaper and Faster: Dual Optimization of Caching and Inference Speed

Capability improvements are often accompanied by rising costs, but this time the situation may be the opposite.

Manual Cache Points Significantly Reduce Invocation Costs

GPT-5.6 adds a manual cache point specification feature, allowing users to mark the content they need cached themselves, with the cache lifecycle extended to 30 minutes. This substantially improves the cache hit rate, effectively driving down actual usage costs.

Prompt Caching Principle: When processing each request, large language models must compute attention weights for every input Token one by one (i.e., generate the KV Cache). When the input prefixes are identical, this repeated computation wastes substantial compute. The caching mechanism allows the system to retain the KV Cache of identical prefixes for a period of time, so subsequent requests that hit the cache can skip this portion of computation, greatly reducing latency and Token costs. "Manual cache point specification" further grants developers fine-grained control, which is especially suited to scenarios requiring fixed long contexts such as RAG (Retrieval-Augmented Generation) and codebase Q&A, where actual cost savings can often reach several-fold.

Understanding the value of this feature requires a basic grasp of how the KV Cache works. In the Transformer architecture, each input Token generates a corresponding Key and Value matrix (i.e., the KV Cache) as it passes through the attention layer, and these computed results determine how the model "remembers" the context. When two requests share the same prefix (for example, the same system prompt or the same segment of a codebase), it is theoretically possible to fully reuse the already-computed KV Cache without recomputation. However, automatic caching mechanisms often suffer from poor hit rates due to overly strict prefix-matching rules or overly short cache windows. "Manual cache point specification" allows developers to explicitly mark "this is the boundary of a stable prefix," enabling the system to manage the cache lifecycle in a more deterministic way—for RAG applications (which frequently pose questions over the same batch of knowledge documents) or long-running code-assistance tools (which always carry the full codebase context), actual cost savings could reach as high as 60%–80%.

For scenarios that repeatedly invoke the same context (such as long documents or codebases), the practical benefits of this optimization may be more direct than benchmark improvements.

750 Tokens Per Second: Inference Speed Boosted by About 10x

OpenAI has also promised to roll out a high-speed version soon, with inference speed reaching 750 tokens per second—roughly 10 times the speed of current mainstream competitors.

Why Is Speed So Critical? The inference speed of large language models is typically measured in TPS (Tokens Per Second). The output speed of current mainstream large model APIs generally falls in the 50–100 TPS range, and some models with high reasoning budgets are even slower due to the introduction of multi-step chains of thought. If 750 TPS can be achieved, it would make model output visually approach "instantaneous completion," not only greatly improving the user experience but potentially giving rise to entirely new application forms that were previously untenable due to excessive latency—such as millisecond-level code completion, real-time voice dialogue middleware, and automated workflows requiring high-frequency Agent invocations.

The reason the number 750 TPS holds milestone significance requires understanding the evolutionary context of inference infrastructure. The inference-speed bottlenecks of today's top models stem mainly from two levels: first, the memory bandwidth pressure caused by model parameter scale (every Token generated requires reading the full set of parameters), and second, the serial nature of Autoregressive Decoding—each Token's generation depends on the previous Token, making it inherently difficult to parallelize. Currently mainstream acceleration approaches include Speculative Decoding (using a small model to draft and a large model to verify), Continuous Batching, and custom inference chips (such as Groq's LPU). If OpenAI can achieve 750 TPS on its own infrastructure, it means its engineering accumulation on the inference side has reached a considerably high level—and this kind of infrastructure barrier is often harder to quickly replicate than algorithmic innovation.

For latency-sensitive applications such as real-time interaction and code completion, an order-of-magnitude leap in speed often brings about a qualitative transformation in experience.

About the Naming: Sun, Earth, Moon

Faced with GPT-5.6's somewhat peculiar version code names, OpenAI also offered clarification: the so-called "Sun, Earth, Moon" essentially still correspond to the high, medium, and low tiers of configuration—just under a new naming system, and there's no need to over-interpret it.

Productization Capability Is the Deciding Factor in This Race

All things considered, GPT-5.6's counterattack this time treats the benchmark reversal as merely an entry ticket; the true strategic layout lies in packaging and internalizing three major capabilities—multi-agent collaboration, cost control, and inference speed—into the product itself.

At a time when foundational model capabilities are gradually converging, whoever can more thoroughly "productize" cutting-edge technology—letting developers and users enjoy the strongest capabilities with the lowest barrier—may well be the key variable determining the ultimate winner of this large model race.

This judgment is supported by deeper industry logic. From the PC era to the mobile internet era, the history of technology has repeatedly proven that the ultimate winner is often not the platform with the strongest technical capabilities, but the one that optimally integrates technical capability with the developer ecosystem, user experience, and cost structure. Microsoft dominated the PC era with the Office ecosystem, and Apple reshaped the mobile era with the App Store—both are cases in point. The large model industry is undergoing the same paradigm shift—the "hard gap" in foundational model capabilities is narrowing, and whoever can build a product ecosystem with lower barriers, higher efficiency, and stronger stickiness will determine the competitive landscape of the next stage. GPT-5.6's release this time may well be an important step OpenAI has taken along this path of productization.

Key Takeaways

Key Takeaways