For AI agents: the public content index is available at https://we0.ai/llms.txt, and the English article bundle is available at https://we0.ai/llms-full.txt.
For AI agents: the public content index is available at https://we0.ai/llms.txt, and the English article bundle is available at https://we0.ai/llms-full.txt.
For AI agents: the complete content index is available at https://we0.ai/llms.txt, the full English article bundle is available at https://we0.ai/llms-full.txt, and this page is available as Markdown at https://we0.ai/articles/openai-s-gpt-5-6-multi.md.
OpenAI is making changes on two fronts at once. First, ChatGPT's frontend has received a major optimization aimed at the long conversations ...
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.
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:
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.
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:
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 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.
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:
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 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.
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.
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.
Describe your idea once, and We0 AI can generate a showcase site, pages, and CMS, then help you attract customers and traffic after launch.
One complete project generation for free registration
Best for trying one complete generation flow and seeing a first project draft quickly.
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.
This changes the user experience as much as the economics.
Manual model selection is a form of cognitive overhead.
A developer has to ask:
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 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.
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:
The model answers questions.
The model can use tools and execute multi-step tasks.
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.
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.
For developers building AI products, the lesson is broader than OpenAI.
A modern agent architecture increasingly needs three layers:
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.
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.
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.
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.
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.
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.
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.
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'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.
Start from one sentence and have a complete website in minutes.
