How to Use Sub-Agents on Macha (Multi-Agent Delegation)
As you build more agents, you'll want a way to bring them together — one front door that sends each request to the specialist best suited to handle it. That's what sub-agents are for. A "lead" agent can call your other agents as helpers, deciding on its own which one to use for each task. It's how you go from a handful of separate agents to a coordinated team.
Watch it in action
What sub-agents are
A sub-agent isn't a new kind of agent — it's just one of your existing agents, made available to another agent. When you build or edit an agent, you can give it access to other agents you've already created; those become its sub-agents. The "lead" agent can then hand off work to them.
Click that Sub-Agents card and the panel opens on the right: a short explainer — "Add other agents this agent can delegate tasks to. Each sub-agent becomes a callable tool" — and an + Add Sub-Agent button. Click it and you get a searchable list of your other agents; toggle one on and it's now a sub-agent the lead can call.
Each sub-agent keeps its own tools and knowledge, scoped to its job. So a transcription agent has audio tools, a knowledge-base helper has your docs, and so on — and the lead agent doesn't need all of those tools itself.
How delegation works
The magic is in the lead agent's instructions. You describe, in plain language, how it should choose between its sub-agents — "For audio files, use the transcription agent. For product questions, use the knowledge-base helper. For summaries, use the summarizer."
Then, in practice: the lead agent looks at the incoming request, decides which sub-agent is best suited, and calls it — automatically. In the video example, a Support Lead agent has sub-agents for ticket summarizing, call transcription, and knowledge-base help; ask it to transcribe a file and it recognizes the task, picks the transcription agent, and delegates. You didn't tell it which agent to use — it figured that out from your instructions.
Why use sub-agents instead of one big agent
You could cram every capability into a single mega-agent, but delegation is usually cleaner:
- Specialization. Each sub-agent stays focused on one job, with only the tools it needs — which makes each one easier to write, test, and trust.
- One entry point. The lead agent is a single front door that routes to the right specialist, so you (or a trigger) only deal with one agent.
- Reusability. A good summarizer or KB-helper agent can be a sub-agent of several leads — build it once, reuse it everywhere.
- Easier debugging. When something's off, you can tell which specialist handled it, instead of untangling one giant instruction set.
How to set it up
- Build your specialist agents first — a summarizer, a transcription agent, a KB helper — each focused with its own tools and knowledge.
- Build (or edit) the lead agent, scroll to its Sub-Agents card, click Add Sub-Agent, and pick those specialists from the list.
- Write the routing instructions — tell the lead agent when to use each sub-agent.
- Test it in chat: give it a few different requests and confirm it delegates to the right specialist each time.
(Macha includes guards against runaway delegation — depth limits and circular-call protection — so a chain of sub-agents can't loop forever.)
A worked example: a Support Lead team
A common setup is a Support Lead that fronts a small team of specialists:
- Summarizer — condenses long threads into a clear internal note.
- Order Lookup — pulls order status and tracking from Shopify.
- KB Helper — answers product questions from your help center.
- Transcription — transcribes audio attached to a ticket.
The Lead's instructions do the routing: "For audio, use Transcription. For 'where's my order', use Order Lookup. For product questions, use KB Helper. For anything you can't handle, summarize with Summarizer and hand to a human." A ticket comes in, the Lead reads it, and delegates to the right specialist — one front door, four experts behind it. Add a Ticket Created trigger to the Lead, and the whole team runs autonomously: every ticket gets routed and handled without you wiring each specialist to its own trigger.
The beauty of it is reuse — that same Summarizer or KB Helper can be a sub-agent of several different leads, so you build each specialist once and compose them however you need.
Best practices
- Keep specialists narrow. One clear job per sub-agent makes routing reliable.
- Be explicit in the routing instructions. Spell out which sub-agent handles which kind of request.
- Reuse your best agents as sub-agents across multiple leads.
- Test the routing, not just each agent — make sure the lead picks correctly across the range of requests you expect.
Frequently asked questions
What is a sub-agent? An existing agent that you've given another agent access to, so the "lead" agent can delegate tasks to it.
How does the lead agent decide which sub-agent to use? From its instructions — you describe when to use each — plus its own reasoning about the request.
Do sub-agents keep their own tools? Yes — each sub-agent has its own tools and knowledge scoped to its job.
Why not just build one big agent? Focused agents are easier to write, test, trust, and reuse; a lead agent routes between them cleanly.
Can a sub-agent call its own sub-agents? Delegation can nest, with built-in depth and circular-call guards so it can't loop forever.
The bottom line
Sub-agents turn your individual agents into a coordinated team: build focused specialists, give a lead agent access to them, and describe how to route. The lead handles the "who should do this?" decision on its own — so you get the clarity of small, single-purpose agents with the convenience of one front door.
Build your first agent team: create a couple of specialists and a lead to route between them. 7-day free trial, no credit card required. Start free.
