What Codex subagents are, how the lead agent coordinates them, what you can inspect and control, and why using them well looks more like management than prompting.

I asked Codex to turn a draft I was struggling with into the article I actually wanted to write. It did not start rewriting. It opened three more threads.

One agent studied how I write on Medium. One checked the current product facts against OpenAI’s documentation. A third designed the narrative for a curious nontechnical reader. While they worked, the lead agent kept researching too.

Then it brought everything back into one answer.

I had asked one AI for help. Somewhere inside the work, it had built a temporary editorial team.

What each member of that team actually owned is the important part.

The draft was not a blank page. The idea, the argument, the point of view, and the reason for writing it were already mine. I was not asking Codex to decide what I thought.

I was using it for the work around the thinking. One agent checked whether suggested edits still sounded like me. One verified the dated product claims. One tested whether the order made sense to somebody encountering the subject for the first time. The agents could flag a weak passage, catch a grammar problem, challenge an unsupported claim, or suggest a clearer route through the argument.

I still decided what I believed, what the article was trying to say, and what survived the final edit.

That distinction makes agent spawning more useful, not less. The feature is not simply a way to hand an idea to several machines and ask them to produce something in your place. It is a way to keep ownership of the objective while delegating narrow support jobs, inspecting what comes back, and making the final call.

The same pattern works far beyond writing. Ask Codex to prepare a website for launch and one agent can check the links and forms, one can audit accessibility, one can review structured data, and another can look for the points where a visitor is likely to leave.

The model has not become four times more intelligent, and the subagents are not miniature employees with independent judgement. The workflow has changed. One agent is coordinating several focused lines of work instead of completing everything inside one conversation.

The new layer being automated is coordination.

Key Takeaways

What Exactly Is a Subagent?

OpenAI’s documentation uses three useful terms.

A subagent workflow is a workflow in which Codex runs delegated agents and combines their results. A subagent is one of those delegated agents, started to handle a specific assignment. An agent thread is the separate place where that subagent does its work.

The original thread becomes the lead. It keeps the main objective and decides how to split it. Each child receives a narrower job, works inside its own context, and returns a result. The lead then compares the findings and produces the final response.

A subagent is not simply another paragraph generated inside the same answer. It has its own thread and its own model-and-tool loop. Using the tools available to the parent task, it can search, inspect, test, analyse, or implement without filling the main conversation with every intermediate step.

It is also not necessarily a different model or personality. The specialisation usually comes from the assignment, the context, and the instructions it receives.

The simplest way to understand it is this:

A subagent is a separate working room with a job, not a new mind joining the company.

Is This Different From Opening Four Chats Yourself?

Yes. The difference is the management layer.

You could already open four conversations, repeat the background in each one, keep track of their progress, collect four answers, and work out which parts survived.

In a subagent workflow, the lead can do the splitting, briefing, waiting, following up, and consolidation. You give the main thread the objective. It manages the delegated work around that objective and returns one response.

Several chats give you several answers to manage. A subagent workflow gives the lead responsibility for bringing the work back together.

That does not make the management automatically good. The lead can create overlapping assignments, leave an important gap between them, or smooth over a disagreement that should have remained visible.

Automation is not the same thing as competence. But the coordination is now part of the product, and you can inspect it.

What Does the Lead Agent Actually Do?

The lead has four jobs.

First, it decomposes the task. It looks for parts that can be completed without blocking one another.

Second, it briefs the subagents. Each one needs an objective, a boundary, the relevant context, an evidence standard, and a clear output.

Third, it monitors the work. It can keep working in the main thread, wait for results, route follow-up instructions, or stop a branch that is no longer useful.

Finally, it synthesises what comes back. It can compare the findings, identify agreement and conflict, check for missing evidence, and decide what belongs in the final response.

The value is not that several agents produce several reports. It is that several lines of work can become one decision.

The qualification matters: reconciliation does not guarantee correctness. A lead can flatten a real disagreement or turn a repeated error into a polished conclusion. You still have to judge the final answer.

Can You See What the Agents Are Doing?

Yes. The agents are not meant to disappear behind the answer.

Codex shows the individual threads in its supported apps so you can inspect the assignment, the status, the work, and the result returned to the lead. The exact view depends on where you are working.

This inspectability is more important than it first appears. A final answer can sound confident even when one agent misunderstood the brief, used weak sources, or completed a different job from the one it was given.

Opening the thread lets you inspect the subagent’s visible work, evidence, progress, and result.

One answer appears on the surface. The working rooms remain available underneath.

Can You Redirect or Stop One?

In local Codex clients, yes. You can ask Codex to steer a named subagent, give it a narrower instruction, stop it, or close completed threads. The exact controls depend on which app you are using, which is why it helps to refer to the assignment clearly.

For example:

Tell the pricing agent to ignore commentary and verify only current prices from official product pages.

Or:

Stop the competitor agent. The five verified examples are enough. Continue without waiting for more.

A delegated task can drift. You are not committed to waiting politely while the wrong job finishes.

Stopping one branch does not have to cancel the whole task. The lead can continue with the work already available, create a better assignment, or decide that the missing result is not essential.

That makes agent spawning manageable rather than mysterious. Delegation is useful partly because it is interruptible.

Why Do Separate Threads Improve the Work?

Parallel speed is the obvious benefit. Separate context is the more interesting one.

Complicated work produces a great deal of temporary material: search results, logs, test output, source extracts, rejected ideas, tentative explanations, and failed approaches. Put all of that in the main conversation and the important requirements and decisions become harder to find.

OpenAI notes that this is often described as context pollution and context rot. The conversation fills with material that was useful briefly but no longer deserves equal weight.

Subagents move that work elsewhere. One thread can investigate a dead end without dragging it through the rest of the task. Another can read a large collection of files and return only the findings that affect the decision. The lead keeps the goal, the constraints, and the final judgement in a cleaner context.

That creates three different benefits:

A subagent is useful not only because more work is happening. It is useful because that work has somewhere else to happen.

Are the Subagents Independent Minds?

No.

If you do not configure a child model or reasoning effort, local Codex inherits the parent agent’s model and reasoning effort. The agents can still behave differently because their briefs, tools, and working contexts differ, but that is not the same as guaranteed intellectual independence.

Advanced users can define custom roles with different instructions, models, reasoning settings, MCP servers, skills, and sandbox restrictions. Codex also includes built-in roles such as a read-heavy explorer and an implementation-focused worker.

Those controls create useful specialisation. They do not create separate truth machines.

Several agents can inherit the same bad premise, consult the same weak evidence, or repeat the same model tendency. Agreement deserves attention. It does not end the discussion.

What Can the Subagents Access?

Spawning another agent does not give the task more authority.

Local Codex subagents inherit the parent turn’s sandbox and permission mode. A custom-agent file can define a narrower sandbox baseline, such as read-only, although Codex reapplies live sandbox and approval choices from the parent turn when spawning the child. Spawning is not a way around approval.

In hosted ChatGPT Work, subagents use the tools available to the parent chat, while website and connector permissions remain specific to those tools.

The practical rule is simple: a subagent can use only the files, tools, websites, and connected services actually available to its task. More workers do not create more permission.

What Work Actually Benefits From a Team?

The best subagent workflows have real seams in the problem.

Breadth-first research divides a large question by market, source type, time period, or competing explanation. A competitor analysis might put one agent on pricing, one on product positioning, one on customer complaints, and one on checking claims against primary sources.

Audit by dimension gives several agents the same subject but different standards. A website can be reviewed separately for accessibility, conversion friction, structured data, and technical discovery. The lanes look at the same site without doing the same job.

Adversarial review deliberately creates disagreement. One agent builds the case for a proposal, another attacks its assumptions, and a third verifies the evidence both sides dispute. This works well for a product launch, investment of time, or strategic decision where a confident first answer is not enough.

Scout, then build uses parallel work for discovery and sequential work for implementation. One agent maps the relevant code, one reproduces the bug, and one checks the documentation. Only after those findings return does one owner implement the fix.

The useful test is short:

Can two parts of this task be completed well without seeing each other’s unfinished work?

If yes, parallel agents may help. If one result determines what the next step should be, use stages.

How Do You Ask Codex to Build the Team?

Plain language is enough. The quality comes from how the work is divided, not from a secret trigger phrase.

Here is a prompt worth saving:

Divide this task into genuinely independent, non-overlapping workstreams. Before starting, tell me which subagents you will create and what each one owns. Give every agent a bounded objective, the context it needs, an evidence standard, and a required output. Run independent work in parallel and keep dependent steps sequential. Wait for the required results, identify agreements, disagreements, and missing evidence, then return one consolidated answer rather than separate reports. Do not treat agreement between agents as proof.

Current local Codex releases enable subagent workflows by default. Ask directly with language such as “spawn three agents” or “delegate this work in parallel”. Project instructions and skills can also request delegation. In eligible ChatGPT Work accounts, most intelligence levels still require a direct request, while Ultra can delegate proactively.

The longer prompt is not an incantation. It teaches the lead what good coordination should look like.

When Do More Agents Produce Worse Work?

More often than the word team makes comfortable.

The first failure is duplicate effort. Give four agents a vague brief and they may run the same searches, make the same assumptions, and return four versions of the same answer.

The second is hidden dependency. Work is launched in parallel even though one assignment needs another agent’s unfinished result. The second agent either guesses or waits, and the supposed parallelism disappears.

The third is shared ownership. Several agents edit the same file, spreadsheet, or other shared work and create conflicts. OpenAI recommends starting with read-heavy parallel work such as exploration, testing, triage, and summarisation, then being more careful when several agents write at once.

The fourth is false consensus. Related agents receive the same premise or use the same weak sources. Repetition becomes confidence without becoming truth.

The fifth is synthesis loss. The lead compresses nuanced or contradictory findings into a cleaner conclusion than the evidence supports.

Then there is usage. Every subagent performs its own model and tool work, so subagent workflows consume more tokens than comparable single-agent runs. Parallelism can reduce the time on the clock while increasing total model work.

Faster is not the same thing as using less.

The operational rule that survives is simple: give parallel researchers separate lanes. Give the final decision or edit to one owner.

Should the Work Be Parallel, Staged, or Single-Agent?

Use parallel subagents when the work has independent directions and the results can return in a comparable form.

Use staged subagents when exploration must finish before implementation, or evidence must be gathered before a critic can assess it.

Use one agent when the task is small, tightly sequential, dominated by one shared state, or cheaper to complete than to brief and reconcile.

The correct number of agents is not the largest number the system permits. It is the smallest number that creates genuinely different useful work.

What Is the New Skill for the Person Using It?

It is tempting to call this advanced prompting. That description is too small.

The skill is knowing how to divide the job.

You need to decide what outcome matters, where the natural seams in the problem are, which work can happen independently, and what context each agent needs. You need to assign one owner to shared files and final decisions. You need to define acceptable evidence and tell the lead what to do when the agents disagree.

The lead can automate coordination. It cannot remove judgement.

The chatbot era trained everyone to picture one person, one question, and one AI answer.

Agent spawning changes the middle of that picture. One request can become several bounded investigations, each with its own context, before returning as one result. In supported local Codex clients, you can inspect the visible work and intervene while it is happening. ChatGPT Work on the web shows subagent activity and completed results, but its sidebar does not provide per-agent stop or steer controls.

The exciting part is not the swarm. It is that one clear brief can become several focused, inspectable lines of work and still return as one answer.

Prompting asks what to say to one assistant.

Agent spawning asks a harder question:

What team does this problem deserve?

AI Visibility Studio helps websites structure content so AI systems can find it, understand it, cite it, and actually use it when generating answers. aivisibilitystudio.com

References