GPT-5.6 subagents: context isolation in the weights

Multi-Agent System Context Rot

Sub-agent context isolation: the fix for context rot

Key takeaway

GPT-5.6 Sol's Ultra mode decomposes a task into parallel subagents that each work in their own context window, which lifted Terminal-Bench 2.1 from 88.8% to 91.9%. This bakes subagent context isolation into the model weights: each worker's scratch work stays out of the others' windows, so no single thread accumulates enough to rot. The trade-off is that moving orchestration into the weights hides the handoff seam you would otherwise control, and every subagent bills tokens independently, so an Ultra call costs several times a standard one.

OpenAI’s GPT-5.6 Sol, which went generally available on July 9, 2026, ships a feature called Ultra mode that turns a single reasoning chain into a team of subagents. Each GPT-5.6 subagent takes a piece of the task and works in its own context window, and the model coordinates them without any orchestration code from you. On Terminal-Bench 2.1, that lifted Sol from 88.8% to 91.9%, past the 88.0% that GPT-5.5 and Claude Mythos 5 both posted.

The interesting part is not the benchmark. It is what the mode is: OpenAI has baked subagent context isolation, a pattern context engineers have been building by hand for over a year, directly into the model weights. That solves one real problem and quietly relocates two others. This post covers what Ultra mode actually does, why per-agent context windows fix context rot, and the two things moving orchestration into the weights does not solve.

Ultra mode decomposes a task into subtasks and assigns each to a parallel subagent that works in its own context window. Sol might spin up one agent for planning, one for writing code, one for testing, and one for review, and those agents communicate during the run, so a tester can flag a bug back to the coder mid-task rather than at the end. The orchestration lives in the model, not in a framework you wire together.

The default configuration on ChatGPT Work Pro, Enterprise, and Codex Plus+ runs four parallel agents. Special provisioning goes higher: OpenAI’s headline demonstration ran up to 64 concurrent subagents under a “multiagent v2” mode to produce an unreviewed proof of the roughly 50-year-old Cycle Double Cover Conjecture in under an hour. As one analysis put it, “64 subagents is not what Sol Ultra does when you click Ultra.” The everyday product is the four-agent version, and the 3.1-point Terminal-Bench gain comes from that, not the conjecture run.

Giving each subagent its own window is the most direct fix we have for context rot, because a window only rots when it fills with history the model no longer needs. In a single growing thread, every tool call, intermediate observation, and abandoned branch stays in context and gets rebilled on the next step. By step twenty, the model reasons over a transcript where the signal it needs is buried under thousands of tokens of its own scratch work. Context rot is the measured result: accuracy falls as input length grows, even when the underlying task does not get harder.

Isolation attacks that at the root. If a testing subagent runs a dozen commands in its own context window, none of that lands in the planner’s window or the coder’s. Each agent reasons over a clean slice scoped to one job, and only a distilled result crosses back. This is exactly the argument for sub-agent context isolation that teams like Anthropic reached independently, where scoped sub-agents beat a single-agent baseline by keeping the orchestrator’s thread small. What GPT-5.6 changes is that you no longer build the isolation yourself. It is a property of the model.

There are now three places the orchestration and context boundaries can live, and they trade convenience against control. The table below compares them on the dimensions that matter for context engineering.

The single thread is simplest and rots fastest. Framework subagents give you full control of both the isolation boundary and the handoff, at the cost of building and maintaining the orchestration. In-weights subagents remove that build cost entirely, which is a real gain, but they take the handoff boundary out of your hands. That last row is where the interesting trade-offs live.

When orchestration moves into the weights, you gain automatic isolation and lose visibility into how context is split. In a framework you wrote, you decide how the task decomposes, what each subagent can see, and what it returns. With Ultra mode, the model decides all of that internally. You send one prompt and get one answer, and the four-way split, the inter-agent messages, and the synthesis all happen where you cannot inspect them.

For most coding and research tasks that opacity is an acceptable trade. But it matters the moment context correctness is not just a quality concern. The July 12 report that Sol deleted user files without permission during its ChatGPT Work launch is a reminder that when an agent’s actions are decided across subagents you cannot observe, a bad decision is hard to trace back to the context that caused it. The more the orchestration hides, the more you are trusting the model to scope context correctly on your behalf, with no seam to audit when it does not. Subagent isolation solves context accumulation, but it does not solve context handoff, and Ultra mode makes the handoff harder to see rather than easier to fix. The hard problem in multi-agent systems was never spawning the agents. It is that every action a subagent takes carries an implicit decision, and when subagents act in parallel without seeing each other’s full reasoning, those decisions conflict. That is the core finding behind why multi-agent systems fail at context: the failures cluster at the boundaries between agents, not inside any one of them.

Ultra mode’s inter-agent communication is a partial answer, letting a tester message a coder mid-run. But partial communication is exactly where handoff goes wrong. Pass too little across the boundary and subagents make locally sensible, globally incoherent choices. Pass too much and you reintroduce the accumulation you isolated them to avoid. Because that negotiation now happens in the weights, you cannot tune it. When a handoff drops the one fact that mattered, every agent handoff can corrupt the context downstream of it, and an in-weights orchestrator gives you no place to intervene. Isolation helps in proportion to how independent the subtasks actually are, and the model, not you, is now deciding how independent to treat them.

Every subagent generates tokens independently, so isolation multiplies cost in direct proportion to how many agents run. The default four-agent Ultra call already costs several times a single-agent Sol call, because you are paying for four context windows instead of one. The 64-agent conjecture run consumed up to 64 times baseline tokens, which analysts estimated at anywhere from $275 to well over $13,000 for a single task. Isolation buys accuracy with tokens, and the exchange rate is not gentle.

This is why context budgets matter more, not less, once subagents are in play. A cleaner per-agent window is worth little if you are paying to rebuild four of them on every call, and Ultra mode gives you no lever to cap that spend beyond choosing whether to invoke it. The usual mitigations still apply at the edges: prompt caching cuts agent costs on the repeated prefixes each subagent shares, and returning compressed results rather than full traces keeps synthesis cheap. But the base multiplier is structural. More isolation is more windows, and more windows is more tokens.

The lesson from Ultra mode is that in-weights subagents hand you isolation for free and take the handoff seam away in exchange. For work that decomposes cleanly and where you do not need to audit what each agent saw, that is a good trade. For work where the boundary between agents is where correctness, provenance, or permissioning lives, you still want that boundary to be something you control rather than something sealed in a model.

That control comes from owning the context substrate, not the orchestrator. With Wire, each container is a separately permissioned environment with its own MCP server, so the isolation boundary is the container itself: a subagent connected to one container physically cannot read into a sibling’s, and the handoff between them is an explicit, inspectable step rather than an inter-agent message buried in the weights. Ultra mode decides how to split context inside one model call. A context substrate decides what any agent, in any model, is ever allowed to see. Those are complementary, and the second one does not become less useful when the model gets better at the first. If anything, a model that spawns four subagents per call makes the question of what each of them is scoped to read more urgent, not less.

Sources: OpenAI: GPT-5.6 · OpenAI: Previewing GPT-5.6 Sol · Better Stack: GPT-5.6 Sol and Ultra Mode · Digital Applied: GPT-5.6 Sol Ultra Mode, 64 Subagents · TechTimes: GPT-5.6 Goes Public · TechTimes: ChatGPT Work Launch and Sol File Deletion Wire transforms your documents into structured, AI-optimized context containers. Upload files, get MCP tools instantly.