Sub-Agents Are Here: Build a Team of Specialist AI Agents

Sub-agents are Macha's answer to that ceiling. Instead of one overloaded generalist, you build a small team of specialist AI agents — one that triages, one that looks up orders, one that knows your billing policy cold — and let a lead agent delegate to whichever specialist the situation needs. Each sub-agent carries its own tools, its own model, and its own knowledge base. The lead agent calls them the way it would call any other tool, gets the answer back, and keeps going.

This isn't a roadmap teaser. Sub-agents have been live in Macha since March, matured through April, and got full run-by-run observability in June. Here's how they work, where they earn their keep, and the honest cases where you should not reach for them.

What a sub-agent actually is

A sub-agent is just a regular Macha agent that another agent is allowed to call. There's no separate "sub-agent" object type — any agent in your workspace can be a lead, a specialist, or both. You wire the relationship up on the lead agent's configuration page, in the Sub-Agents panel.

When the changelog first introduced this on March 8, 2026, the framing was deliberately plain: "Agents can now call other agents as tools, enabling hierarchical task delegation. Assign specialist sub-agents for specific workflows." That's the whole mental model. If your lead agent has a tool for "search orders" and a tool for "update a ticket," a sub-agent is simply a third kind of tool — one that happens to be a fully reasoning agent on the other end.

Mechanically, that means each specialist brings its own complete loadout:

• Its own tools — the billing specialist gets Stripe; the order-status specialist gets Shopify; the triage agent gets nothing but the ticket itself.
• Its own model — pay for a heavyweight reasoning model only on the agents that need it, and run a fast, cheap model on the simple classifiers.
• Its own knowledge base — point the policy specialist at your Confluence space and the escalation specialist at your runbooks, without cross-contaminating either.

By the April 9 release, Macha had formalised the guardrails: delegation can go up to three levels deep, with circular-reference prevention so an agent can't (directly or transitively) call itself into an infinite loop.

Why split one agent into many

The case for specialist agents is the same case you'd make for splitting a 600-line function into smaller ones: focus, testability, and reuse.

Focus. A short, single-purpose prompt beats a sprawling one. An agent whose entire job is "decide the topic and priority of this ticket" will classify more reliably than a generalist that also has to remember refund rules. The wider industry research backs this up — practitioners describe multi-agent orchestration as the canonical pattern for support precisely because it combines intent classification, domain routing, tool usage and context continuity, and each of those is cleaner as its own role (Talkdesk, Dataiku).

Reuse. Build an "Order Lookup" specialist once and let your triage agent, your reply agent, and your escalation agent all call it. Fix a bug in how it reads Shopify, and every agent that delegates to it gets the fix for free. You're composing behaviour instead of copy-pasting prompts.

Cost control. Because each sub-agent picks its own model, you can run a cheap classifier up front and only invoke an expensive reasoner when the conversation actually warrants it. (More on the credit math below — it cuts both ways.)

This is the same architecture the bigger vendors converged on: Zendesk's Forethought, for example, ships a multi-product spread (Solve, Triage, Assist, Discover) that hand work between each other rather than one monolithic bot. The difference with Macha is that you assemble the team yourself, on top of the helpdesk you already run.

A worked example: the support team you'd actually build

Here's a realistic lineup for an e-commerce store running on Zendesk. The agents list below is a real Macha workspace — note the dedicated Sub-agents column, added on June 17, which shows at a glance how many specialists each agent has wired up (hover and you get their names).

A sensible structure:

When a "I want to cancel order #2205, it hasn't shipped" ticket arrives, the lead triage agent recognises it as an order-cancellation case, delegates to Order Lookup to confirm fulfilment status, then delegates to Billing Specialist to confirm refund eligibility — exactly the kind of multi-tool flow Macha already powers in single-agent use cases like Handle order cancellation requests. The difference is that each step is owned by an agent that does nothing else, so each step is easier to get right and easier to debug.

You don't have to build all of this by hand. Macha's Build with AI panel can stand up a configured agent — tools, instructions, triggers, and sub-agent links — from a plain-language description, with the automatic circular-dependency checks that shipped on April 3.

Read-only in chat, action-taking on triggers

One detail worth flagging because it's a real safety design, not marketing. As of the April 3, 2026 release, sub-agents have write permissions in autonomous mode but stay read-only during interactive chat.

In plain terms: when a human is chatting with the lead agent live, the specialists it calls can look things up but can't send replies or mutate tickets — so a delegated step can't surprise you with an irreversible action mid-conversation. When the same lead agent runs from a webhook trigger (a new Zendesk ticket, a Freshdesk update), the specialists are allowed to take their write actions — reply, update priority, add an internal note — because that's the whole point of an autonomous workflow. It's a sensible default that keeps the interactive surface safe while letting the automated surface actually do the work.

You can finally see what each specialist did

Delegation is only trustworthy if you can audit it. Early on, sub-agent activity streamed into the status log with indentation, and the tools a sub-agent used showed up in the "Tools Used" popup on the saved message. Useful, but shallow.

The June 10, 2026 release made it properly observable. Every sub-agent invocation now produces its own conversation record, linked back to the parent. In chat, a card appears under each delegated message showing the sub-agent's avatar, handle, model, connector logos and tool count, with a green "Handed off" badge. Click to expand and you get the specialist's full nested conversation — system prompt, every tool call with its arguments, every tool result, and the final reply — rendered like the main chat.

Three things make this practical rather than noisy:

• No setup. It's lazy-loaded and works automatically for every new sub-agent run.
• It covers automation too. Whether the lead was triggered by a user in chat or fired by a webhook, the sub-agent's run is captured the same way.
• It stays out of your way. Sub-agent runs don't pollute the user-facing conversation counter, but remain available for 45 days under the standard TTL policy.

For anyone who's tried to debug a multi-agent system elsewhere — where a delegated step is a black box and you're left guessing which agent hallucinated — this is the difference between "delegation we can ship" and "delegation we're scared of."

What it costs

Macha bills credits per AI action — not per ticket, not per deflection — at a rate that depends on the model the agent uses (roughly 0.5–9 credits by model, with the default GPT-5.4 Mini at 1). The important consequence for multi-agent setups: each sub-agent run consumes its own credits at its own model's rate. A lead agent that fans out to three specialists is doing four agents' worth of reasoning, and you pay for four.

That's not a gotcha — it's the lever. Run a cheap classifier as the lead and reserve a strong, pricier model for the one specialist that needs deep reasoning, and a fan-out can cost less than one bloated generalist on a top-tier model running every turn. Run four heavyweight models where one lightweight agent would have sufficed, and it costs more. Architect deliberately.

On plan limits: agents are capped by tier — the Professional plan ($699/mo, 10,000 credits) includes 25 agents, which is comfortably enough to build a real specialist team; Enterprise is unlimited. You can start on the 7-day free trial, no credit card required. Full numbers live on the pricing page.

Watch-outs: when not to build a team

Multi-agent is an architecture, not an upgrade. It's genuinely easy to over-engineer, and the research is blunt about it: a significant share of failed multi-agent deployments threw a team of agents at query classes that a single well-tuned agent would have resolved more accurately and at lower cost (SearchUnify, Ema). Honest places to not reach for sub-agents:

• Your workflow is genuinely one job. If "answer from the help centre" covers 90% of your volume, one agent with a knowledge source is simpler, cheaper, and easier to reason about. Don't split for the sake of it.
• Latency-sensitive live chat. Each delegation hop adds a model round-trip. For real-time chat where every second counts, a fan-out to three specialists can feel sluggish. Reserve deep delegation for asynchronous, trigger-driven work where a few extra seconds don't matter.
• You haven't nailed the single agent first. Specialists inherit the failure modes of the prompts inside them. If your one agent isn't reliable, five unreliable agents won't average out to reliability — they'll compound.
• Unclear ownership. A team only helps if each role has a crisp boundary. If two specialists both "kind of" handle refunds, the lead agent's routing gets fuzzy. Define one job per agent and test each in isolation (Macha's Test Run lets you replay real tickets against a single agent before you wire it into a team).

The rule of thumb: start with one agent, watch where it strains, and promote the strained responsibility into its own specialist. Grow the team from real pressure, not from a diagram.

How to start

1. Build and harden your lead agent first — most teams start with a triage or auto-reply agent. (See the Macha on Zendesk overview for the helpdesk-native setup.)
2. Identify the one responsibility it does worst, and split that into a dedicated specialist with just the tools and knowledge that job needs.
3. Wire the specialist into the lead's Sub-Agents panel, keep delegation shallow (one or two levels is plenty for most support flows), and pick the cheapest model that's accurate for each role.
4. Run it from a trigger, watch the "Handed off" cards to confirm each specialist did its part, and add the next specialist only when you feel the next strain.

The full mechanics — assignment, depth limits, write-permission behaviour and audit cards — are in the sub-agents documentation.

FAQ

What's the difference between a sub-agent and a regular agent? None, structurally. Any Macha agent can act as a lead or a specialist. "Sub-agent" just describes the relationship — an agent that another agent is allowed to call as a tool. The same agent can be a standalone agent in one place and a specialist in another.

How deep can delegation go? Up to three levels, with built-in circular-reference prevention so an agent can't call itself into a loop, directly or indirectly.

Can sub-agents take actions, or only read? Both, depending on context. In autonomous (trigger-driven) runs they can perform write actions like replying or updating a ticket. During an interactive live chat they're read-only by design, so a delegated step can't take an irreversible action mid-conversation.

Will I be able to tell which agent did what? Yes. Since June 2026, every sub-agent run is recorded as its own linked conversation, surfaced as an expandable "Handed off" card under the delegated message — including the specialist's tool calls, results and final reply. Runs are kept for 45 days.

Does each sub-agent cost extra credits? Yes. Macha charges credits per AI action, and each sub-agent run bills at its own model's rate. Use cheap models for simple specialists and reserve expensive reasoning models for the agents that genuinely need them.

Do I have to wire all this up manually? No. The Build with AI panel can create a fully configured agent — including sub-agent links — from a plain-language description, with automatic circular-dependency checks.