Building a sub-agent for each step beats fixed multi-agent roles

LLM agents break down when a task stretches across dozens of steps — checks, backtracking, experiments, running commands, fixing what failed. The context swells, noise piles up inside it, important details get buried, and the agent spends its time not on the work but on trying to recall what happened earlier. Multi-agent systems try to fix this by coordinating several roles, but that brings costs of its own: a lot of chatter between agents and a lot of manual setup.

The authors of "AOrchestra: Automating Sub-Agent Creation for Agentic Orchestration" propose a different framing. Let the main agent stop doing everything itself and instead run a team of workers — not fixed roles, but sub-agents created for a specific subtask at runtime.

An agent in four components

AOrchestra's key move is to describe any agent through the same legible recipe of four components: instruction, context, tools, and model. It is effectively a worker's card: what exactly needs doing, which facts to hand over, what it can act with, and which LLM fits best on price and quality.

This matters because most systems go one of two ways. Either they isolate context to avoid context rot, and the workers come out too generic; or they define static roles — researcher, coder, reviewer — which cover unexpected subtasks poorly and take manual engineering to maintain. Here specialization happens on demand: for each step the orchestrator assembles the parameters that step needs and launches a sub-agent as a tool.

The orchestrator never touches the environment

A telling detail: the orchestrator in AOrchestra never acts in the environment itself. It does not run commands, edit code or browse the web. It only decides what the next step should be, what context to pass along, and which worker to create. The sub-agent does the work and returns observations: what came out of it, where the errors are, which artifacts were saved.

That split disciplines the system. First, context can be handed over cleanly trimmed — exactly what this subtask needs. Second, tools are granted strictly on the merits: shell commands for Terminal-Bench, file editing and test running for SWE-Bench. Third, the model can be chosen per task — cheap and fast in some places, stronger in others — which is a lever on cost.

How they tested it

The authors evaluate the approach on three popular agentic benchmarks:

• GAIA — open-world search and reasoning tasks, where the point is to avoid drowning in context and to be able to check your hypotheses.
• Terminal-Bench 2.0 — Linux terminal scenarios that require running commands over and over.
• SWE-Bench-Verified — fixing bugs in real repositories, with tests as the mandatory check.

This is exactly where "build a sub-agent for the step" should prove itself: the task runs long, the environment shifts, and mistakes are unavoidable.

Not just accuracy, but controllability

Paired with Gemini-3-Flash, AOrchestra posts a clear gain over strong baselines: the authors report 16.28% relative improvement on average, and the per-benchmark tables show the gap can be wider still. On GAIA, AOrchestra reaches 80.00 pass@1; on Terminal-Bench 2.0 it hits 52.86 pass@1, well above several popular frameworks in the comparison.

The authors also show why "just pass the whole context" is no cure. With no context the worker can miss critical details; with the full context it drowns in the irrelevant. Their version — context curated by the orchestrator — gives the best result on a GAIA sample.

One more practical point: the system stays modular. The sub-agent can be swapped out — for a ReAct-style or mini-SWE-style one, say — and the orchestration still pays off. The improvement is not tied to one particular worker.

The cost side: closing in on a quality–cost balance

The authors emphasize control: the orchestrator can reach for cheaper models where that is safe and step up where the risk of error is high. They show this routing helps move toward Pareto efficiency — better accuracy without a proportional rise in cost, or lower cost without much loss of quality.

The paper's main takeaway

AOrchestra unties a knot in long-horizon agentic work: instead of heavy static roles and uncontrolled context passing, there is a legible scheme for managing sub-agents and a central orchestrator that assembles a worker for the task at every step. That cuts manual engineering, makes the system more portable across frameworks, and hands you a lever on the budget.

💾 Code