Can Claude manage other agents? How to set up a Claude manager agent that delegates

Yes. Claude can act as a manager agent: it plans the work, splits it into tasks, hands each task to a worker agent with its own context, and reviews what comes back. It works when the manager is kept from doing the work itself, every handoff carries the full context, and each result is checked before it counts as done.

What is the manager and worker pattern for AI agents?

In the manager and worker pattern, one agent owns the goal and the plan, and other agents do the work.

• The manager reads the request, breaks it into tasks, writes a brief for each, assigns them, tracks status and decides what happens next. It writes no code or content itself.
• Workers each get one task with a narrow scope and their own context window. They execute, then report back in a fixed format.
• A reviewer (another agent, a test suite, or you) checks each result before it counts as done.

The payoff is focus. Each worker sees only what its task needs, so its context stays clean. Independent tasks run in parallel. Workers can be specialists with their own tools and instructions. And the manager's context stays small enough to hold the whole plan.

The cost is real too: more tokens, because every worker reads its own context, and more coordination. For a ten-minute fix, one agent is faster. The pattern pays off when a job has several independent parts, or runs over several days.

How do I make Claude a manager agent in Claude Code?

Claude Code has the pieces built in. The simplest manager is your main session delegating to subagents. To make the role stick, define the manager as its own agent and take away its editing tools:

---
name: lead
description: Plans work and delegates it to workers. Never edits files.
tools: Agent(implementer, reviewer), Read, Grep, Glob
---
You are the lead. Break each request into tasks, brief one worker per task,
wait for every result, send each result to the reviewer, then report to me.

Save it as .claude/agents/lead.md, define implementer and reviewer the same way, and start a session as the lead with claude --agent lead. The Agent(implementer, reviewer) entry limits which workers it may spawn, and with no Edit, Write or Bash tool, delegating is the only way it can get anything done.

For bigger jobs, agent teams (experimental, enabled with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1) add a shared task list and direct messages between teammates, with one lead assigning the work. Claude Code orchestration compares these options with parallel sessions and worktrees.

How do I prompt a lead agent to delegate well?

The brief the manager writes is the only thing a worker knows, so make the manager write every brief in the same shape:

For each task, write a brief with:
- Goal: one sentence describing the outcome, checkable by a stranger
- Context: the files, decisions and constraints that matter, quoted or linked
- Scope: the files or systems this worker owns, and what it must not touch
- Done when: checks that prove it is finished (tests pass, file exists, link loads)
- Report: what changed, how you verified it, what you could not verify, open questions

Then add the rules that keep the manager in its lane:

1. Plan before assigning, and show me the task list first for anything that touches production.
2. One owner per task. Parallel workers never share a file.
3. Do not start the next phase until every worker in this one has reported.
4. Compare each report against its "Done when" before marking anything complete.
5. Bring me decisions only: a question I can answer in one line, with your recommendation.

Good briefs are boring and specific. A worker that has to guess will guess confidently, and you will find out at review.

Why does the manager agent end up doing the work itself?

This is usually the first failure you hit. The manager reads the codebase to plan, spots the fix, and makes it, because for a model with edit access that is the shortest path to done. Anthropic's docs on agent teams name it directly: the lead sometimes starts implementing tasks itself instead of waiting for teammates, and the suggested fix is to tell it to wait for its teammates to finish.

Instructions help. Structure works better:

• Remove the tools. A manager without Edit, Write or a shell can only delegate. In Claude Code, set that in the agent's tools list, as above.
• Give planning its own output. Ask for the task list as a file, so the manager's job has a visible deliverable of its own.
• Watch for drift. If the manager's summary describes code changes in detail, it probably made them. Check the diff against the workers' reports.

A manager that does the work also stops managing. The workers sit idle, nobody reviews its changes, and its context fills with the implementation detail it was supposed to keep out.

How do you stop context getting lost between manager and workers?

A worker starts fresh. In Claude Code it loads its own instructions, your project instructions and the brief, and nothing from the manager's conversation. Every decision the manager made in chat and never wrote down is invisible to it.

Ways to close the gap:

1. Write decisions to a file. Keep a docs/decisions.md that the manager appends to and every brief links. "Reuse the existing Stripe customer, never create a new one" belongs there, where every worker can read it.
2. Quote the source. If an error message or a spec line matters, paste it into the brief word for word. Paraphrases drop exactly the detail that matters.
3. Make workers ask. Tell workers to stop and report a question when the brief is ambiguous, instead of choosing an interpretation and running with it.
4. Keep a task ledger. One file listing each task, its owner, its status and the path to its report. When the manager's own context gets compacted, the ledger survives.
5. Standardize what comes back. A fixed report format keeps each result small enough for the manager to hold many at once.

Who reviews the workers' output?

If nobody does, the manager will accept a worker's summary as fact and pass it to you as done. Workers report optimistically: "tests pass" sometimes means "the tests I wrote pass".

Build review in layers:

• Machine checks first. Tests, type checks, a build, a link that loads. Require each worker's report to include the command it ran and the output.
• A separate reviewer agent. Give it the original brief and tools to read files and rerun checks, with no edit access, and ask it to find where the result falls short of "Done when". A second agent catches what the author agent talked itself into.
• You, for anything irreversible. Deploys, payments, customer emails and public posts should stop and wait for a human yes. Have the worker prepare the exact content and pause there.

Then make "done" mean reviewed. A task the reviewer has not passed stays in review, however confident the report sounds. That one rule saves much of the cleanup that multi-agent setups otherwise leave behind.

How does Kav act as the manager?

In Kavela the manager role is built in. You talk to one agent, Kav, who runs your workspace: it plans the work, files each piece as a task on the workspace calendar, and hands it to the worker agent that fits. You see the week's agent work at a glance, and you can talk to Kav in the app or from Telegram.

Workers each run in their own cloud computer, with a shell, files, git and a browser, and keep running after you close your laptop. For each worker you choose what powers it: a Kav AI tier, "My Claude plan" or "My Codex plan". With your plan, Claude Code or Codex runs inside that worker's cloud computer on your subscription, and still reaches the workspace's files, skills and connected apps.

Anything that needs you, like a deploy or a post about to go live, waits in one Approvals inbox, and each task ends with its deliverables attached for you to check. To start with a team, agent packs add ready-made workers in one click: Ship builds production apps, and Echo posts to X or LinkedIn only after you approve the exact content.

Kavela is in early access and runs workers on your own Claude subscription, with a 14-day free trial. Start your free trial