Subagents

Subagents are the building block of multi-agent systems. What you learn here — how to delegate, why a clean context matters, what makes a handoff good — is the same skill you'll apply when you move on to agent orchestrators, role-based agent teams, and production-scale agent workflows. If you can't decompose work into a parent agent and subagents that return clean results, every multi-agent design you meet later will feel like magic instead of structure. Master this and you unlock: Agentic Workflows (where subagents implement pipelines), Multi-Agent Systems (where the handoff is the whole game), and Agent Memory (where shared context is the hard part).

Imagine you are a project manager at a consulting firm. A client asks for a market analysis report. You don't sit down and write the whole thing from memory. You have a researcher who looks up data, an analyst who makes charts, and a copywriter who drafts the text. Each person gets a clear task, works with their own notes and files, and hands you back a finished piece. You never see every spreadsheet they opened or every draft they wrote — only the deliverables. Subagents are the same idea, but for AI models. Instead of one model trying to do the whole job in a single stretched-out conversation, you have a parent agent (the manager) that decides the plan, and it spins up a separate agent (the researcher) to do one focused piece of work. The subagent has its own context — its own tiny conversation window or scratchpad — and it doesn't know what the parent is doing beyond the task it was given. It works, produces a result, and sends only that result back. The parent never carries the subagent's working notes, its false starts, or its intermediate steps. That separation is the whole point. It keeps the parent's mind clear, so the parent can keep planning and coordinating instead of being swamped with trivia.

Think of a busy restaurant kitchen. The head chef (the parent agent) reads the orders coming in. They don't cook every dish themselves. Instead, they call out a ticket to the grill station, a ticket to the saucier, a ticket to the pastry section. Each station is a subagent: it has its own workspace (its grill, its pans, its ingredients), it knows the recipe for its dish, and it works in parallel with the other stations. When the grill station finishes a steak, it doesn't send the whole ticket back — it sends the plated steak and a quick note like 'medium rare, rested'. The head chef never knows every flip of the spatula. The analogy holds up well, but it breaks down in one important place: subagents in AI don't have their own bodies or hands. They are still just software — the same model architecture, the same kind of code — but wrapped so that they appear to operate separately. The 'station' is a separate context window, and the 'steak' is a text result. That means you, the architect, get to decide what a subagent can see and what it returns. A real kitchen has physical walls; in AI, the wall is something you draw in code.

A subagent is a separate agent instance, launched by a parent agent, given a scoped task and its own execution context, that returns only a result to the parent.

You already know what an AI agent is: a loop of decide, act, observe, repeat, with tools and memory. A subagent is still an agent — it has its own loop — but it is deliberately made smaller and more focused. You also know about tool use: a model calling a function to get data. Subagents feel like a more powerful version of a tool call — instead of just getting data, the subagent does a whole sequence of reasoning and tool calls and returns a conclusion. If you have notes on multi-agent systems, you'll see subagents are the building block of them: a parent agent coordinating several subagents, each with its own context, is exactly a multi-agent system. This concept also connects to agent memory: the parent and subagent each have their own memory, and deciding what gets shared (and what gets retired) is the handoff quality that matters.