top of page

Orchestrator and Subagents: A Team of Agents, and Why They Don't Talk to Each Other

carocsteads
5 days ago
4 min read

Agents, from the ground up · Part 4 of 7. One agent is useful. A coordinated team of them is how agent systems scale. Here's how that team is actually organized.

Some tasks are too big for one agent's desk: "audit every detector in the codebase," "write tests for these twelve modules," "research five competitors and compare them." Stuffing all of that into one context window means it fills up with noise, the agent loses track, and everything happens one slow step at a time.

The fix is to split the work up.

The shape: hub and spoke

One orchestrator agent reads the big task, breaks it into pieces, and spawns a specialist subagent for each piece. When they finish, the orchestrator combines their results into one answer.

It's a hub-and-spoke shape. Everything flows through the orchestrator, never from worker to worker. Think of a project lead who hands out assignments and collects reports, while the contractors never meet each other.

Subagents are born, work, and vanish

The lifecycle of a subagent is short and strict:

  1. Born with a fresh, isolated context. It gets only its brief, not the whole conversation the orchestrator has been having.

  2. Works through its own think, act, observe loop: reading files, running tools, making mistakes and fixing them.

  3. Returns a summary to the orchestrator.

  4. Vanishes. Its messy intermediate work (the forty files it skimmed, the three dead ends) is thrown away. Only the summary survives.

That last step is the secret. The orchestrator's desk stays clean. It never sees the mess, only ten tidy reports.

A worked example

Say I ask: "Check all of FinBot's attack detectors for gaps." The orchestrator might do this:

  • List the detectors (say, path traversal, SQL injection, prompt injection, and data exfiltration).

  • Spawn four subagents in parallel, each with a brief like: "You are reviewing the path-traversal detector only. Try encoded and nested variants. Report each miss with an input that demonstrates it. Don't modify code."

  • Collect four short reports.

  • Merge them, remove duplicates, rank by severity, and hand me one list.

Four focused investigations ran at the same time, and none of them got distracted by the others' files.

Why don't the workers talk to each other?

It's deliberate, for three reasons:

  • Isolation keeps context clean. If workers chatted, each one's window would fill with everyone else's noise. That's exactly the problem we were trying to escape.

  • Parallelism needs independence. Tasks can only run at the same time if they don't depend on each other mid-flight. The moment worker B has to wait for worker A, you're back to running in sequence, just with extra steps.

  • It's debuggable. An isolated worker's behavior is basically a function of its brief. If one gives a bad result, you can rerun it with the same brief and see exactly what happened. Ten agents gossiping with each other is a distributed-systems nightmare that nobody can reproduce.

If two pieces of work need to talk, they shouldn't be parallel subagents. The orchestrator sequences them instead.

So dependencies are handled by the orchestrator: run A, read its result, then feed that into B's brief. Peers never message each other.

The brief is everything

Because a subagent starts with a blank slate, the brief is the only thing it knows. It wasn't there when you explained your coding conventions an hour ago. A good brief reads like instructions to a capable contractor who just walked in the door:

  • The goal, and what "done" looks like.

  • The scope: which files and data, and what's off-limits.

  • The constraints: "read-only," "don't change the public API," "use the existing fixtures."

  • The return format: "a list of findings, each with file, line, and a demonstrating input." Structured summaries are much easier for the orchestrator to merge.

Most "the subagent did something dumb" bugs are really "the brief left something out" bugs.

When not to use subagents

Teams have overhead. Every subagent re-reads files and spends its own tokens, so ten in parallel can cost far more than one agent working through it in order. Reach for them when the pieces are truly independent and big enough to deserve their own desk. For a small task, or one where every step depends on the last, a single agent is simpler, cheaper, and easier to follow.

The security angle

Isolation is also a containment boundary. If one subagent reads a poisoned file with hidden instructions in it, the damage stays inside that subagent's bubble. The orchestrator only sees its summary. That's not a complete defense, since a summary can still carry a bad instruction upward, but it's far better than letting every agent read every other agent's raw input. Give each subagent only the tools its piece needs, and treat incoming summaries as data, not commands.

Next up, Part 5: Memory vs. context. What an agent actually remembers, what it forgets, and why "memory" means two completely different things.

Enjoyed this? Get every new post by email with the Subscribe to the blog form at the bottom of this page. You can also sign up as a site member (top of the page) to follow along.

Agents, from the ground up · © Carolina Steadham

Comments


Subscribe to the blog

© 2026 by Carolina Steadham. All rights reserved.

bottom of page