Subagents become the default in coding agents: Antigravity, OpenCode and Copilot CLI
On 13 November 2026, Google, OpenCode and GitHub each shipped changes that make one agent directing many others the normal way to code. Here is how orchestrator-worker systems split context, run in parallel, inherit budgets and permissions, and fail.
- Reading time
- 16 min
- Sections
- 8
- Code examples
- 1
- Tables
- 2
- Sources
- 8
- Published
- 16 Nov 2026
For a long time, a typical coding agent was one model in one loop. It read files, ran commands and edited code inside a single, growing conversation. That is changing. On 13 November 2026, three separate projects shipped changes that treat a team of agents, directed by one coordinator, as the normal way to work.
Google Research described the /teamwork feature in Antigravity, a multi-agent system it says has helped solve open problems in mathematics and systems software. OpenCode, the open-source terminal agent, released version 2.3.0, in which subagents always run in the background. GitHub's Copilot CLI shipped two releases that add guard rails around subagents: permission prompts shown inside the subagent view, a block on workflows that start copies of themselves, and a rule that subagents respect the session's AI credit cap.
The shift matters because it changes how much work one request can do, how much it costs and what can go wrong. This article explains the architecture, using the three releases as worked examples. It complements our earlier piece on always-on AI agents, which covered agents that run for long periods. This one is about agents that split themselves into many.
What happened
Google Research describes Antigravity's /teamwork feature (13 November 2026)
In a post by Vahab Mirrokni, a Google Fellow and VP at Google Research, Google describes /teamwork as a multi-agent system for "human-AI collaborations to solve open problems". Researchers set the question and the constraints. Long-running agents then write solvers, search large spaces, test candidates and check reasoning.
Three design choices stand out. First, Google says /teamwork "partitions context by construction", so each specialised agent sees only the files and tools it needs for one step. Second, coordinators hand work to fresh successor agents, and critics or auditors check results from clean contexts, without the producer's reasoning. Third, parallel exploration is paired with what the post calls "falsifiers": hard checks such as the Lean 4 proof checker, unmodified test suites and simulators.
The headline results are company claims and have not been independently reviewed. Google says its formal-verification setup "fully autonomously produced an end-to-end, machine-checked formalization" of the Weil conjectures, spanning about 1.8 million lines of Lean across 28,800 subagent invocations. It also reports a rewrite of the Zircon kernel that added about 800,000 lines of safe Rust over a two-week campaign. The post says most experiments used the Gemini 4 Argon model. It also includes a useful caveat: tightly coupled code worked better with sequential stages than with parallel splits. Google says external developers can use /teamwork in Antigravity now, and it has opened applications for 10,000 academic researchers to get six months of free access to its highest usage tier.
OpenCode 2.3.0 makes background subagents the default (13 November 2026)
OpenCode's changelog dates version 2.3.0 to 13 November 2026. The headline change reads: "Subagents now return immediately, continue in the background, and report back whenever they become idle." The release notes say you can keep working in the parent session while several subagents run at the same time.
A second fix shows how subtle background work can be. If a subagent goes idle while some of its own background work is still running, its report to the parent "now says it is still running, so the parent waits for the final report."
GitHub Copilot CLI 1.0.111 and 1.0.112 add subagent guard rails (13 November 2026)
Both Copilot CLI releases are dated 13 November 2026. Version 1.0.111 shows "permission prompts, questions, and confirmations directly in the sub-agent view so you can respond without leaving it." It also closes a loop in the experimental dynamic workflows feature: "a workflow's own agent can no longer start or resume workflow runs, so a workflow can no longer start copies of itself without limit when all tools are allowed."
Version 1.0.112 adds a budget rule: "Subagents now respect the session-wide AI credit limit set with --max-ai-credits."
How orchestrator-worker agents work
Anthropic's December 2024 guide to building agents gives a compact definition of the orchestrator-workers pattern: "a central LLM dynamically breaks down tasks, delegates them to worker LLMs," then combines their results. The guide says the pattern suits complex tasks "where you can't predict the subtasks needed", and it names coding changes across many files as an example.
Think of a head chef during a busy service. The head chef does not cook every dish. They read the order, call out tasks to stations, and check each plate before it leaves the kitchen.
In a coding agent, the loop looks like this:
- Plan. The orchestrator (also called the lead or parent agent) reads the request and decides whether to split it. Splitting is not free, so a good orchestrator only splits when the parts are truly independent.
- Delegate. For each subtask it writes a brief and starts a worker, usually through a tool call. In Claude Code and OpenCode this is a task-style tool; in Copilot's dynamic workflows, code decides when agents launch.
- Work. Each subagent runs its own loop: reading files, running commands, maybe editing code.
- Report. The worker returns a summary, not its full transcript.
- Integrate and verify. The orchestrator merges results, resolves conflicts and checks the outcome, ideally against something hard like a test suite.
Writing a good brief
The brief is the only thing a fresh worker knows. Anthropic's engineering team, writing about its multi-agent research system in June 2025, says: "Each subagent needs an objective, an output format, guidance on the tools and sources to use, and clear task boundaries." It reports that vague instructions led workers to misread tasks and duplicate each other's searches.
Context isolation: why each worker starts clean
The main reason to use subagents is not speed. It is context. A model's context window is like a desk. Every file read, every command output and every failed attempt lands on it. After a few hours, the desk is covered in paper, and the important notes are buried. This is the core problem of context engineering.
A subagent gets a clean desk. Claude Code's documentation puts it plainly: a new subagent "doesn't see your conversation history, the skills you've already invoked, or the files Claude has already read." It works from the delegation message alone, and only its summary comes back. The parent's context grows by a few paragraphs instead of thousands of lines of logs.
Google's /teamwork pushes the same idea further. Its post says the system partitions context "by construction" and uses critics that review work from a clean context, without the original producer's reasoning. That matters for verification. A reviewer who has read the author's reasoning tends to accept it. A reviewer who sees only the result has to check it on its own terms.
Isolation has a cost. A worker that does not know what the parent knows may repeat work, miss a constraint, or make a choice that conflicts with another worker.
| Approach | What the worker sees | Strength | Weakness |
|---|---|---|---|
| Fresh subagent | Only the brief | Small, focused context; independent review | Needs a complete brief; may duplicate work |
| Forked subagent (Claude Code fork mode) | Parent conversation so far | Knows prior decisions | Inherits clutter and the parent's assumptions |
| Single agent, no split | Everything | No hand-off loss | Context fills up; no independent check |
| Clean-context critic | Only the output to check | Catches errors the author would not | Cannot see why a choice was made |
Parallelism and background execution
Once work is split, the next question is whether workers run at the same time. Until recently, many tools ran a subagent in the foreground: the parent paused and waited. OpenCode 2.3.0 changes that default. A subagent now returns its session ID immediately, keeps running, and reports back when idle. Claude Code's documentation describes the same choice: "Foreground subagents block the main conversation until complete," while "Background subagents run concurrently while you continue working." It says that with nothing configured, a subagent spawned from the main conversation starts in the background.
Parallelism can save a lot of time on the right work. Anthropic reports that having its lead agent start three to five subagents in parallel, with each subagent calling tools in parallel, "cut research time by up to 90% for complex queries." It also reports that its multi-agent setup outperformed a single agent by 90.2% on an internal research evaluation; these are company figures for research, not coding.
Coding is harder to parallelise. The same Anthropic post says coding tasks have fewer parallelisable subtasks than research. Google's post makes a similar point: tightly coupled code worked better with sequential stages than parallel splits. Good candidates for parallel subagents are:
- Read-heavy exploration, such as searching a large codebase for every caller of an API.
- Independent modules, such as porting separate packages or writing tests for unrelated files.
- Alternative attempts, where several workers try different approaches and a verifier picks the best one.
- Review, where one worker writes and another checks.
Background execution also creates a coordination problem that OpenCode's second fix addresses. If a worker says "done" while its own child process is still running, the parent may build on a partial result.
Budgets and permissions: what a subagent inherits
When one agent becomes ten, two questions matter most. Who pays, and who approves? The safe answer to both is that a subagent should never have more freedom than the session that started it.
Permissions. GitHub's dynamic workflows documentation says subagents "use the CLI's permission system and inherit the permission grants of the session that started them." If a subagent needs something not yet allowed, the interactive CLI shows a normal prompt and that subagent waits. Version 1.0.111 makes that prompt visible inside the subagent view, so you can answer it in context. Claude Code works the same way by default: a subagent inherits the main conversation's permission mode, and when the main session runs in a permissive mode, the subagent runs in that same mode. That inheritance is convenient, but it means a broad grant at the top flows down to every worker. Our guide to governing AI agent access covers how to scope those grants, and running workers inside a sandbox limits the damage when a grant is too wide.
There is one sharp edge. GitHub's documentation notes that when you run a workflow with copilot workflow run, the command "does not display permission approval prompts", so you must grant what is needed before you start.
Budgets. Before 1.0.112, a Copilot session cap set with --max-ai-credits did not cover subagents. Now it does. That closes a gap where the visible agent stayed under budget while its workers spent freely. GitHub's documentation is honest about limits: it tracks credits used by a workflow's agents and "stops new work when the total reaches the limit," but usage is reported after it happens, so work in progress can push the total past the cap. The page calls the cap an approximate maximum, not a hard ceiling. For the wider picture of team-level spending limits, see our article on per-employee AI budgets and FinOps and the explainer on cost and latency budgets.
Concurrency and depth. Budgets cap money; concurrency and depth limits cap the shape of the tree. GitHub's documentation describes run-level limits on how many workflow agents are active at once and how many can launch in total, and says the concurrent limit "makes additional subagents wait until others finish." Claude Code documents two environment variables: one caps spawn depth (by default up to three layers below the main conversation) and one caps concurrent subagents (spawning fails at 20 running subagents by default).
| Control | What it limits | Example from the releases and docs |
|---|---|---|
| Permission inheritance | What tools and actions a worker may use | Copilot subagents inherit session grants; prompts appear in the subagent view |
| Credit cap | Total spend across all workers | Copilot --max-ai-credits now covers subagents (1.0.112) |
| Concurrency cap | Workers running at once | Copilot workflow concurrent-subagent limit; Claude Code default of 20 |
| Depth cap | How deep workers can nest | Claude Code: three layers by default |
| Self-start block | Recursive self-launch | Copilot workflows can no longer start or resume their own runs (1.0.111) |
What it means in practice
For developers, the default experience is shifting. When you ask OpenCode or Claude Code for a large change, the agent may now start several workers without asking and keep them running while you type. That feels faster. It also means one request can now cost several times what it used to. Anthropic's data, from its research system rather than coding, puts typical agent use at about 4 times the tokens of a chat, and multi-agent systems at about 15 times. It found that token usage alone explained 80% of the performance variance on the BrowseComp benchmark. More agents often means better results, but you pay for them.
For engineering leads, the review problem changes. A single agent produces one diff. An orchestrated run can produce many partial diffs, merged by a model. The quality of that merge, and of the final check, decides whether the output is trustworthy.
For platform and security teams, subagents multiply every existing risk. A prompt injection that reaches one worker can now act with the session's permissions. A misconfigured permission grant now applies to every worker. And a loop bug, like the self-starting workflow GitHub just fixed, can burn through credits quickly when every tool is pre-approved.
What to do now
- Learn your tool's defaults. Check whether your coding agent now starts subagents in the background by default. OpenCode 2.3.0 does, and Claude Code's documentation says it does when nothing is configured.
- Set a session budget that covers workers. In Copilot CLI, update to 1.0.112 or later so
--max-ai-creditscovers subagents. Leave headroom, because GitHub says the cap is approximate. - Cap concurrency and depth. Use your tool's limits on concurrent subagents and nesting depth. Start low, then raise them once you have measured real usage.
- Never pre-approve everything for headless runs. GitHub's documentation says
copilot workflow runshows no approval prompts. Grant only the specific tools the workflow needs. - Write briefs like tickets. Give each worker an objective, an output format, the tools and sources to use, and clear boundaries, following Anthropic's published guidance.
- Split only independent work. Parallelise searches, separate modules and reviews. Keep tightly coupled edits in sequence, as Google's own post recommends.
- Verify with hard checks. Make tests, type checkers or build steps the final gate, not another model's opinion. Use a clean-context reviewer where you can.
- Run workers in a sandbox. Isolate file system and network access so a misbehaving worker cannot reach production credentials.
- Measure before scaling. Run a small test, record actual credit use per task, and only then raise limits for full runs, as GitHub's documentation suggests.
Risks and open questions
Runaway spawning is a real failure mode, not a theory. Anthropic reports that its early agents made errors "like spawning 50 subagents for simple queries." GitHub's 1.0.111 fix shows a workflow could start copies of itself without limit when all tools were allowed. Depth, concurrency and self-start limits exist because these loops happen.
Costs can rise quietly. Background workers do not interrupt you, so you may not notice how many are running. Credit caps that are reported after the fact can overshoot.
Permission inheritance cuts both ways. Inheriting the parent's grants avoids a flood of prompts. It also means one broad grant spreads to every worker, including ones you did not know were started.
Vendor results need outside checks. Google's claims about Lean formalizations and large rewrites come from its own blog post. Machine-checked proofs are strong evidence once someone else can rerun them, but the scale, cost and human effort involved are not fully described in the post.
Watch next: whether OpenCode adds a setting to turn background subagents off or cap them; whether GitHub moves dynamic workflows out of experimental status and makes credit caps harder; whether Google publishes the formal proof pattern it says is coming soon, and whether outside groups reproduce its Lean results; and whether vendors begin reporting per-subagent cost in their usage dashboards.
Related reading: METR finds AI roughly doubling Anthropic's research pace shows what AI coding help adds up to at the scale of a whole lab, where most of a measured speed-up came from AI assistance.
Frequently asked questions
What is a subagent in a coding agent?
A subagent is a separate agent started by the main agent to handle one part of a task. It runs its own loop with its own context window, then returns a summary. Tools such as Claude Code, OpenCode and Copilot CLI all support them.
Why not just use one agent with a bigger context window?
A single long context collects every file, log and failed attempt, which raises cost per call and can bury important details. Subagents keep each piece of work on a clean desk and return only the result. They also let a clean-context reviewer check work without being swayed by the author's reasoning.
Do subagents make coding faster?
Sometimes. Parallel workers help most on independent tasks such as searching, testing separate modules or trying alternatives. For tightly coupled code, both Google and Anthropic say sequential work or fewer splits often does better.
How much more do multi-agent runs cost?
It depends on the task and tool. Anthropic reported that its multi-agent research system used about 15 times the tokens of a chat interaction. Coding runs will vary, so measure your own usage before raising limits.
How do I stop an agent from spawning too many subagents?
Use your tool's limits on total spend, concurrent subagents and nesting depth. In Copilot CLI, use version 1.0.112 or later so --max-ai-credits covers subagents. Keep permissions narrow, because a pre-approved tool set removes the human checkpoint that would otherwise slow a loop down.
Summary
On 13 November 2026, Google described Antigravity's /teamwork multi-agent system, OpenCode 2.3.0 made background subagents the default, and GitHub Copilot CLI 1.0.111 and 1.0.112 added subagent permission prompts, a block on self-starting workflows, and credit caps that cover subagents. Together they mark the orchestrator-worker pattern becoming the normal mode for coding agents. The pattern works because each worker gets a small, focused context and because clean-context reviewers and hard checks can verify the result. It costs more, it splits poorly on tightly coupled code, and it multiplies the effect of any loose permission or missing budget. Treat subagents as a team you manage: give them clear briefs, narrow permissions, firm limits on spend, depth and concurrency, and a test suite that has the final word. For more background on the general pattern, see our explainer on multi-agent systems.
Sources
- Google Research: Advancing science and engineering with Antigravity's /teamwork feature
- OpenCode: Changelog v2.3.0
- NewReleases: github/copilot-cli v1.0.111 release notes
- GitHub: copilot-cli release v1.0.112
- GitHub Docs: Dynamic workflows
- Anthropic: How we built our multi-agent research system
- Anthropic: Building effective agents
- Claude Code Docs: Subagents
Continue learning
Cite this article
Kelahmet, Ö. C. (2026, November 16). Subagents become the default in coding agents: Antigravity, OpenCode and Copilot CLI. Özer Cem KELAHMET. https://www.ozercemkelahmet.com/articles/subagent-orchestration-coding-agents
BibTeX
@online{kelahmet2026subagent,
author = {Kelahmet, {\"O}zer Cem},
title = {{Subagents become the default in coding agents: Antigravity, OpenCode and Copilot CLI}},
year = {2026},
month = {nov},
url = {https://www.ozercemkelahmet.com/articles/subagent-orchestration-coding-agents}
}How this article connects
11 pages link to or from it. Drag to turn, click a dot to open it.
Version history1 revision
- Published
- Revisedlink to the METR article (Search Console: rising impressions)
Factual corrections are listed here with what changed. Wording and formatting edits are not listed.