GPT-5.6 Released: Codex Takes Over ChatGPT, Ushering in the Era of AI Agents

OpenAI Strikes Hard: GPT-5.6 Officially Launched

Waking up to another shake-up in the AI world. In its latest round of updates, OpenAI released the GPT-5.6 series of models and carried out a substantial reorganization of its entire product architecture. According to hands-on analysis by Bilibili creator Tang Zhan ("Master AI Programming with You"), this update is not merely a routine iteration of model capabilities—it represents a fundamental shift in product logic. The ChatGPT and Codex apps have officially merged, and the signals of the Agent era are becoming increasingly clear.

Based on the officially released benchmark data, the flagship model of the GPT-5.6 series achieved scores no lower than its main competitors (benchmarked against the Claude series) across several mainstream large model benchmark tests. It's worth understanding the background of the large model benchmarking system here: mainstream evaluation frameworks include MMLU (Massive Multitask Language Understanding), HumanEval (code generation capability), MATH (mathematical reasoning), GSM8K (elementary math), and LMSYS Chatbot Arena (real user preference comparison), covering core dimensions such as logical reasoning, knowledge Q&A, code generation, and multi-step reasoning. One thing to be wary of is that benchmark tests carry an "overfitting" risk—some models may be specifically optimized for the test set, resulting in impressive scores but mediocre real-world performance. Therefore, human hands-on testing combined with real-world scenarios often carries more reference value than raw scores alone.

But what truly stands out is GPT-5.6's significant advantages in cost and response latency. This means OpenAI is pursuing a strategy of "strong enough capability + maximum cost-effectiveness," directly targeting Claude's dominant position in programming and Agent scenarios.

Cost-Effectiveness Becomes the New Competitive Focus

Over the past year, competition among large models has gradually shifted from "who is smarter" to "who is more cost-effective." As model capabilities become increasingly homogeneous, cost and latency have become the core factors developers weigh when making choices. In the commercialization competition of large models, API call costs (typically priced per million tokens) and response latency (Time to First Token, TTFT) are key metrics for enterprise customers when selecting a model. Take the price war between GPT-4 Turbo and Claude 3 Opus as an example: in 2024, OpenAI proactively cut prices multiple times, driving input token prices down to less than one-tenth of early versions. For Agent application scenarios, the cost issue is particularly acute: a complex Agent task may require dozens of model calls, and the total token consumption of a single task can be dozens of times that of an ordinary conversation. Latency is equally critical—Agent tasks are typically executed in multi-step sequences, and the response latency at each step accumulates, directly affecting user experience and the overall efficiency of automated workflows. By lowering call costs while maintaining top-tier capabilities, GPT-5.6 is essentially competing for the trust of developers and enterprise users—especially those with Agent application scenarios that require large-scale, high-frequency model calls. In essence, OpenAI's move is about seizing the economic viability threshold for the large-scale deployment of Agents.

Codex "Takes Over" ChatGPT: A Deep Restructuring of Product Logic

The most intriguing aspect of this update is the deep integration of ChatGPT and Codex. Before understanding this change, it's worth revisiting Codex's technical history: Codex is a code-specialized AI model released by OpenAI in 2021, initially fine-tuned on code data based on the GPT-3 architecture, and it was once the underlying engine of GitHub Copilot. Its core capability lies in understanding natural language descriptions and generating corresponding code, supporting dozens of programming languages including Python, JavaScript, and Go. Unlike general-purpose conversational models, Codex was designed from the outset to emphasize "task execution" rather than "conversational exchange"—it excels at breaking down vague requirements into executable code steps. As the general capabilities of the GPT-4 series improved dramatically, Codex's standalone API service was announced to be discontinued in 2023, and it was instead merged into the ChatGPT ecosystem. Its return to the product core in the form of an "Agent engine" marks OpenAI's renewed repositioning of Codex.

On the surface, it appears that ChatGPT has "absorbed" Codex's coding capabilities. But according to Tang Zhan's hands-on observations, the truth is quite the opposite—whether using Work mode or coding mode, what's actually running underneath is Codex.

In other words, rather than ChatGPT integrating Codex, it's more accurate to say Codex has "taken over" ChatGPT. This architectural choice reveals an important trend: OpenAI is making the Agent-centric execution engine the underlying driving force of its products. The traditional "conversational AI" shell remains, but the core has been replaced with an Agent system that is better at task execution, tool calling, and multi-step reasoning.

Why Is This a Turning Point for the Agent Era?

Chat and Agent represent two fundamental paradigms of AI applications, and understanding this distinction is crucial to grasping the deeper significance of this update. Conversational AI centers on "single-turn or multi-turn Q&A" as its core interaction unit—the model receives input and generates text output, and the entire process is passively responsive. Agent AI, on the other hand, introduces a "perceive-plan-act" closed-loop mechanism: the model can not only generate text but also call external tools (such as browsers, code executors, and file systems), decompose complex goals into multiple subtasks, and dynamically adjust its execution path based on intermediate results. From a technical architecture perspective, an Agent system typically includes a task planner (Planner), a tool-use layer (Tool Use), and a memory management module (Memory). OpenAI's Function Calling, Tool Use API, and Codex's code execution capabilities are precisely the key infrastructure for building Agent systems. When Codex takes over the underlying layer of ChatGPT, it means that behind every "conversation" lies a complete Agent execution capability—the core competitiveness of AI products has shifted from "what it can talk about" to "what it can do."

This also explains why OpenAI is "tightening its product line, cutting redundancy, and concentrating resources" in this round. According to Tang Zhan's analysis, OpenAI has trimmed some peripheral products and concentrated resources on building Agent capabilities centered on Codex. This kind of strategic contraction usually signals that the direction has already been decided.

Hands-On Comparison: A Capability Leap Within a Single Day

To verify the actual performance of the new model, Tang Zhan conducted an intuitive side-by-side comparison experiment: he first built a Mac app using OpenCode plus the OMO tool, and after GPT-5.6 was released, he reimplemented the same application using the tech stack of "Codex + GPT-5.6 + Go." The Go language (Golang), released by Google in 2009, is renowned for its high-concurrency processing capability, fast compilation speed, and simple binary deployment. In the context of AI toolchains, Go's advantages lie in building high-performance backend services, CLI tools, and system-level applications—complementing Python's dominance in model training and scripting. Choosing Go as the verification language is quite meaningful: it not only tests GPT-5.6's code generation capabilities for non-Python mainstream languages but also reflects a trend—as AI coding assistants become more capable, developers can more freely choose the language best suited to a specific scenario, without being constrained by the AI tool's language preference.

Comparison Results

The two builds were only a day apart, yet a clear improvement in output quality was evident. The Mac app generated by the new approach was superior in both completeness and attention to detail. This kind of "same task, different toolchain" comparison is far more convincing than raw benchmark scores—it directly reflects the new model's usability in real-world development workflows.

It should be noted that this type of demonstration is a single-source personal hands-on test, and results vary depending on project complexity, prompt quality, and tool configuration. But in terms of trends, the pace of iteration for AI programming tools is indeed continuously accelerating, and "a new look every day" is no longer an exaggeration.

What Does This Mean for Developers?

For AI programming practitioners, the fusion of GPT-5.6 and Codex brings several changes worth paying close attention to:

Toolchains are converging. When the official product itself already integrates powerful Agent coding capabilities, the survival space for third-party tools may shrink accordingly. Developers should reassess their tech stack choices.

Cost advantages may reshape the competitive landscape. If GPT-5.6 can significantly reduce call costs while maintaining capabilities, teams that previously switched to other solutions for pricing reasons may reevaluate whether to return to the OpenAI ecosystem. For teams building Agent applications, cost differences are especially sensitive—multi-step Agent tasks amplify the per-call price gap several times over.

Agent capabilities are becoming standard. Whether for conversation or coding, the underlying layer is uniformly driven by the Agent engine, meaning "multi-step task automation" will shift from an advanced feature to a default experience, and developers' ways of working will change accordingly.

Conclusion: Competition Enters Deep Waters

In this round of updates, OpenAI has launched a direct challenge against competitors like Claude with a combination punch of "benchmarked capability, leading cost, and architectural restructuring." Meanwhile, the product logic of Codex taking over the underlying layer of ChatGPT clearly marks the industry's historic transition from the "conversation era" to the "Agent era"—this is not just an upgrade in product features, but a fundamental shift in the AI interaction paradigm from passive response to proactive execution.

For ordinary users and developers alike, the best way to verify all this remains getting hands-on experience yourself. As the pace of technological evolution accelerates, only by staying engaged in hands-on practice can you truly judge just how much value these "blockbuster releases" actually hold.

Key Takeaways