Is a sub-agent a separate product?

Usually it is the same kind of agent with a narrower brief, scoped context and limited tools.

Who checks the sub-agent's work?

The delegating agent, against the brief's acceptance criteria, with people sampling the final output.

Why not one big agent?

Focus, parallelism and independent testing, traded against coordination cost.

AI Glossary / Agents and automation / Beginner

Sub-agent

Definition

A sub-agent is an agent that works under another agent's direction: it receives a specific subtask, does it with its own tools or skills, and returns the result to the agent that delegated it.

What it means

When one agent is given too broad a job, a common design move is to let it delegate. The main agent, sometimes called the orchestrator or manager, spins up or calls sub-agents for defined pieces: research this, check that, draft the other.

The sub-agent sees only what it needs. It gets a brief and the relevant context, not the whole history, which keeps it focused and limits how far any mistake or leak can travel.

The pattern mirrors good management. A clear brief, defined deliverable and acceptance check make delegation work; vague briefs make confident, useless results. The delegating agent stays responsible for the final answer, just as a manager owns the team's output.

Sub-agents also carry the practical benefits: specialists can use different models or tools, run in parallel, and be tested and replaced independently.

For a business reading a vendor's architecture, sub-agents explain both capability and cost: every delegated subtask is more model calls, so the design's value must beat its coordination overhead.

How it works

The delegating agent decomposes the goal and writes a brief for each subtask: what to do, what context applies, what form the answer must take. The sub-agent executes, possibly with its own tools and memory, and returns a result.

The parent validates what comes back before using it: does it answer the brief, is it consistent with what other sub-agents found, does it meet the quality bar? Failed results are retried, reassigned or escalated.

Isolation is deliberate: a sub-agent's context window and permissions are scoped to its subtask, which contains both errors and costs.

The pattern nests: a sub-agent can itself delegate, though depth multiplies coordination cost, so practical designs stay shallow.

Three practical examples

Research: the main agent delegates source gathering to one sub-agent and fact checking to another, then synthesizes the brief itself.
Operations: a dispatch sub-agent handles scheduling while a compliance sub-agent checks the same job against policy.
Reporting: separate sub-agents pull figures, draft commentary and verify the draft against the figures.

Think of it this way

Think of a project manager handing work packages to specialists: the surveyor surveys, the accountant costs, the lawyer reads the contract. Each gets a brief and a deadline, and the manager assembles the pieces into one answer for the client.

The limit: human specialists push back when the brief is wrong. A sub-agent executes the brief as given, so the brief's quality sets the ceiling on the result's quality.

Worked example

delegating a supplier comparison

Suppose a manager asks an agent to compare three suppliers across price, reliability and contract terms.

The agent delegates: one sub-agent gathers pricing from the three quotes, another checks delivery performance records, a third reads the contract terms for exit clauses. Each returns a structured summary with sources.

The parent agent spots that the pricing summary mixes currencies, sends that subtask back with the instruction corrected, and assembles the comparison only after the corrected table arrives. The scenario is invented; brief, validate, retry, assemble is the loop.

The final comparison shows its working: every section names its source, which is what delegation with acceptance criteria buys.

Illustrative case study

A fictional consultancy lets its report agent delegate freely, and sub-agents begin delegating to their own sub-agents. Costs triple and nobody can say which agent wrote a given paragraph.

The redesign caps delegation at one level and requires the parent to log every subtask, its brief and its result. Costs halve and every paragraph gains an accountable origin.

The invented lesson: sub-agents need the same controls as contractors: scope, budget, deliverable definition and a named person, or agent, answerable for the result.

Common misconceptions and mistakes

Sub-agents are employees. They execute briefs; they do not push back, notice a stupid instruction or know the context they were not given.
Delegation multiplies reliability. It multiplies capability only when acceptance checks exist; without them it multiplies confident errors.
More delegation is more power. Each layer adds cost and coordination overhead; shallow, few-specialist designs usually win.

Business use

Sub-agent patterns suit deliverables with separable parts: research packs, comparisons, reports and any task where pieces benefit from independent checking.

Demand from any such system: scoped briefs per subtask, acceptance criteria, a delegation depth limit and a log of who produced what, so results are auditable.

Check your understanding

A report's costs triple and nobody can trace which agent wrote a paragraph. What two controls fix this?

Answer: Cap delegation depth and log every subtask with its brief and result, so each section has an accountable origin.

Related terms

Learn next

AI Agents and Automation for Small Business covers delegated workflows with approvals and logging: https://aiforbusinessandlife.com/academy/ai-agents-automation-small-business. [C4]

Sources

[S2] Google, Machine Learning Glossary. [S5] Anthropic, Building effective agents. Full URLs are in the source ledger. Verified 11 October 2026.

Previous: Stylometry Next: Sub-band coding