OpenAI's GPT-5.6 Multi-Agent V2 and a 16× Faster ChatGPT Experience
OpenAI is making changes on two fronts at once. First, ChatGPT's frontend has received a major optimization aimed at the long conversations that become difficult to open and naviga
OpenAI's GPT-5.6 Multi-Agent V2 and a 16× Faster ChatGPT Experience
Introduction
OpenAI is making changes on two fronts at once.
First, ChatGPT's frontend has received a major optimization aimed at the long conversations that become difficult to open and navigate after hundreds of tool calls. The source article reports that a test conversation with 741 turns and 231 MB of data went from 27.62 seconds to 1.66 seconds to open.
Second, Codex has moved toward a more automated multi-agent workflow with GPT-5.6 Multi-agent V2. Instead of asking users to manually select the best model for every subtask, a main agent can delegate different pieces of work to different models and set reasoning effort independently.
OpenAI's official GPT-5.6 documentation confirms the broader architecture: GPT-5.6 includes Sol, Terra, and Luna, and its Codex/API experience supports parallel subagents and synthesis for complex work.
The result is a simple idea with fairly large implications:
the system is trying to remove both the waiting and the model-selection work that users normally have to manage themselves.
ChatGPT Gets Much Faster at Opening Giant Conversations
Long conversations are becoming a very different problem in the agent era.
A normal chatbot conversation might contain a few dozen turns. An agent session can easily grow much larger because the model may read code, call tools, inspect results, run tests, make changes, and repeat the process hundreds of times.
The source article says OpenAI tested a 741-turn conversation weighing 231 MB to measure the new frontend behavior.
The results were dramatic:
| Metric | Before | After |
|---|---|---|
| Conversation open time | 27.62 s | 1.66 s |
| Memory growth | 1030.7 MiB | 606 MiB |
| Network requests | 894 | 16 |
| Conversation entries loaded | 15,529 | 64 |
According to the source article, the headline performance changes were:
- 94% faster application loading
- 87.8% lower heap growth
- 41.2% lower overall memory usage
- 98.2% fewer network requests
- 99.6% fewer conversation items loaded
The important change is architectural rather than cosmetic.
ChatGPT no longer needs to load and render the entire historical conversation every time a user opens it.
Instead, most of the history can remain stored while only the part that is currently needed is loaded into the interface.
Why This Matters More in the Agent Era
For a traditional chatbot, a very long conversation is mostly a storage problem.
For an agent, it becomes a workflow problem.
A coding session can involve:
- Reading a large repository.
- Running a command.
- Inspecting the output.
- Editing files.
- Running tests.
- Fixing failures.
- Repeating the cycle.
One task can easily produce hundreds of interaction records.
That means the conversation UI itself becomes part of the agent's infrastructure.
The source article describes the new rendering strategy as effectively loading only the portion of the history that the user needs to see instead of rebuilding the entire session.
This is why a frontend optimization that would have seemed minor a year ago can make a big difference now.
The Result: Long Sessions Feel Much Lighter
The most obvious benefit is simple.
A conversation that has been running for weeks or months should open without feeling like the application is rebuilding an entire database in the browser.
The source article says the changes are especially visible for heavy Codex users who regularly perform hundreds of tool calls.
Instead of waiting for a huge session to become interactive, the user can return to the conversation quickly and continue working.
This is the sort of infrastructure improvement that users may barely notice when it works well.
That is also the point.
The best frontend optimization is often the one that disappears into the product experience.
GPT-5.6 Multi-Agent V2 Moves Toward Automatic Model Selection
At roughly the same time, OpenAI also expanded its multi-agent workflow.
The source article reports that GPT-5.6 Multi-agent V2 became fully available and lets a main agent delegate subtasks to different supported models.
Each sub-agent can have its own reasoning intensity.
OpenAI's official GPT-5.6 documentation independently confirms that the family includes three capability tiers:
- GPT-5.6 Sol — the flagship model for the hardest tasks.
- GPT-5.6 Terra — a balanced model for everyday work.
- GPT-5.6 Luna — the fastest and most cost-efficient model.
OpenAI also documents Multi-agent as a beta capability in the Responses API, where one GPT-5.6 instance can coordinate multiple subagents in parallel and synthesize their results.
That is the core idea behind the new workflow.
The user should not necessarily have to know which model is best for each small part of a large task.
The agent can decide.
The Model Lineup Is Designed for Different Jobs
The source article presents the model lineup roughly like this:
| Model | Typical role |
|---|---|
| GPT-5.6 Sol | Complex agentic coding and hardest reasoning |
| GPT-5.6 Terra | Everyday programming and balanced workloads |
| GPT-5.6 Luna | Fast, low-cost subtasks |
| Daybreak | Cybersecurity-focused work |
| GPT-5.5 | Complex coding, research, and general tasks |
OpenAI's official public documentation confirms the first three GPT-5.6 tiers and emphasizes their different capability and cost profiles.
For example, OpenAI currently describes Luna as its model optimized for cost-sensitive, high-volume workloads, with a public API price of 1 per million input tokens and 6 per million output tokens on the current model page.
That creates a natural division of labor.
A difficult architectural decision can go to a stronger model.
Routine code transformation can go to a cheaper one.
Small classification or lookup steps can use the fastest option.
From Manual Model Picking to Automatic Routing
The source article describes this as a transition away from manual model selection.
Today, users often think like this:
"This part is difficult, so I should use the strongest model."
Then they repeat the decision for the next part of the task.
A multi-agent system can instead treat models as internal compute resources.
The main agent breaks the job into smaller units, decides which model should handle each unit, and combines the results afterward.
A simplified workflow looks like this:
User task
↓
Main Agent
├── Complex planning → GPT-5.6 Sol
├── Routine coding → GPT-5.6 Terra
├── Fast subtasks → GPT-5.6 Luna
└── Specialist task → Dedicated model
↓
Result synthesis
↓
Final response
OpenAI's official documentation describes this parallel-subagent pattern explicitly: a GPT-5.6 instance can coordinate multiple agents working in parallel and synthesize the outputs into a single result.
Why This Can Lower Inference Cost
The source article makes a simple economic observation.
A complex task does not need the strongest model for every step.
Maybe only the planning, architecture, or difficult debugging stage requires the most capable model.
Other steps can be handled by cheaper models.
In the source article's example, only around 20% of the workflow might need the strongest model, with the rest delegated to lower-cost models.
That exact 20% should be treated as a rule-of-thumb illustration rather than an OpenAI guarantee.
The underlying idea is still important.
If agents can automatically route work according to difficulty, the average cost of completing a complex task can fall without forcing users to manually micromanage the routing.
A Developer No Longer Needs to Think About Every Model
This changes the user experience as much as the economics.
Manual model selection is a form of cognitive overhead.
A developer has to ask:
- Which model should I use?
- Is this task worth the expensive model?
- Should I switch models halfway through?
- Did the cheaper model lose too much quality?
- Is the time saved worth the extra cost?
In a good multi-agent system, most of these questions move into the system itself.
The user provides the objective.
The agent decides how to allocate the work.
That is a meaningful shift from model selection to resource orchestration.
The Combination Is Bigger Than Either Feature Alone
The source article's strongest argument is that these two changes reinforce each other.
The frontend has been optimized to handle enormous agent histories more efficiently.
At the same time, the backend agent system is becoming more capable of splitting work across models.
That gives OpenAI two ways to reduce friction:
Fewer seconds waiting for the interface.
Fewer decisions about which model to use.
The first is a performance improvement.
The second is a workflow improvement.
Together, they move ChatGPT and Codex further away from being simple chat interfaces.
ChatGPT Is Moving Toward a Workflow Platform
OpenAI's official GPT-5.6 announcement already describes the family as capable of coordinating tools, processing intermediate results, and supporting multi-agent workflows. It also introduces ultra in Codex, which uses subagents across parallel workstreams to accelerate complex tasks.
That means the evolution can be summarized in three stages:
Stage 1: Chat
The model answers questions.
Stage 2: Agent
The model can use tools and execute multi-step tasks.
Stage 3: Multi-Agent System
The model can delegate work to other models, run tasks in parallel, and synthesize the results.
The user increasingly becomes the person who defines the objective and checks the outcome.
The internal orchestration happens behind the scenes.
The "No Model Selection" Idea Is the Real Product Change
It is easy to focus on the benchmark numbers.
But the more important product decision may be the attempt to hide model complexity from the user.
As the number of models grows, exposing every choice directly can make the system harder to use.
If OpenAI has five or ten specialized models, users should not have to learn all of them just to complete one project.
A mature agent platform should ideally understand that:
The task is the interface, not the model.
The user says what needs to be done.
The system decides how much reasoning to use, which model should do which part, and how to combine the results.
What This Means for Developers
For developers building AI products, the lesson is broader than OpenAI.
A modern agent architecture increasingly needs three layers:
- Task decomposition — break a large job into meaningful subtasks.
- Model routing — choose the cheapest capable model for each subtask.
- Result synthesis — combine partial outputs into one coherent result.
On top of that, the frontend needs to handle much larger session histories than traditional chat products were designed for.
If you are building an agent product, conversation rendering is no longer just UI polish.
It is infrastructure.
常见问题
What is GPT-5.6 Multi-agent?
GPT-5.6 Multi-agent is an agent orchestration capability in which a GPT-5.6 instance can coordinate multiple subagents in parallel and synthesize their work. OpenAI currently documents the capability as a beta feature in the Responses API.
What is Multi-agent V2 in Codex?
The source article describes Multi-agent V2 as a Codex workflow in which a main agent can delegate different subtasks to supported models and control the reasoning effort of each sub-agent. The exact rollout and model availability can change, so current OpenAI Codex documentation should be checked for the latest configuration.
What are GPT-5.6 Sol, Terra, and Luna?
They are three capability tiers in the GPT-5.6 family. OpenAI describes Sol as the flagship, Terra as the balanced option, and Luna as the fastest and most cost-efficient model.
What is GPT-5.6 Luna used for?
OpenAI positions GPT-5.6 Luna for cost-sensitive, high-volume workloads. Its current API page lists $1 per million input tokens and $6 per million output tokens.
Why was ChatGPT's long-conversation performance improved?
Agent sessions can become much larger than ordinary chats because they may contain hundreds of tool calls, execution results, and intermediate steps. The source article reports that OpenAI changed how large histories are loaded and rendered so the application does not need to process the entire conversation every time.
Does ChatGPT now automatically choose the best model for every task?
The broader direction is toward automatic model routing and delegation, but availability depends on the product and feature. OpenAI's GPT-5.6 documentation confirms multi-agent orchestration and different GPT-5.6 capability tiers; it does not mean every standard ChatGPT conversation exposes full automatic routing controls.
Does multi-agent execution reduce AI costs?
It can. If difficult subtasks use stronger models while routine work is delegated to cheaper models, the average cost of a complete workflow can be lower than using the strongest model for every step. The actual savings depend on the routing strategy and workload.
相关工具
- OpenAI Codex: OpenAI's coding agent for multi-step software development and agentic workflows.
- OpenAI API: Official API platform for GPT-5.6 and multi-agent application development.
- GPT-5.6 Models: Official model documentation for Sol, Terra, Luna, and related capabilities.
- Responses API: OpenAI's API surface for tool use, programmatic calling, and multi-agent workflows.
- ChatGPT: OpenAI's consumer and business AI workspace.
Related Links
- GPT-5.6 Official Announcement: OpenAI's primary release page for GPT-5.6, including multi-agent and ultra capabilities.
- GPT-5.6 Model Guidance: Official developer documentation for model capabilities and multi-agent use.
- GPT-5.6 Luna: Current API pricing and technical details for the low-cost GPT-5.6 tier.
- GPT-5.6 in ChatGPT: Current ChatGPT availability and plan information.
- OpenAI Codex: Official product information about Codex and agentic coding.
- OpenAI API Documentation: Main documentation hub for building with OpenAI models.
Summary
OpenAI's latest changes target two different forms of friction that become increasingly important as AI agents get more powerful. The first is waiting: giant conversations should open quickly even when they contain hundreds of turns and tool calls. The second is decision overhead: users should not have to manually choose a model for every subtask.
GPT-5.6's multi-agent architecture points toward a model-routing system in which a stronger model can plan and delegate while cheaper models handle routine work. At the same time, frontend optimizations make those longer agent sessions easier to use.
The direction is clear: ChatGPT and Codex are evolving from places where users talk to a model into systems that decide how the work should be executed.