Sub-Agent Runs, Now Fully Visible in Chat: Multi-Agent Observability Without the Setup

As of the June 10, 2026 release, Macha closes that gap. Every sub-agent run is now fully visible inside the chat itself — the system prompt it ran with, every tool call it made and the exact arguments, every tool result it got back, and the final reply it handed up to its parent. No SDK, no tracing dashboard, no configuration. It just appears under the delegated message as an expandable card. This is multi-agent observability, but built into the place you already work instead of bolted on beside it.

The black box gets darker when agents delegate

"Agent observability" became a real category in 2026 for a reason. As guides from IBM and others put it, most agents still operate as opaque black boxes, and the primary tool for auditing one is an agent trace — a step-by-step record of what it actually did. Without it, "you cannot assign responsibility, fix the root cause, or prevent it from happening again."

Multi-agent systems make this strictly harder. As Braintrust's 2026 observability guide notes, delegation adds a whole new failure mode on top of the single-agent ones: handoff failures, "where Agent A passes incomplete or incorrect context to Agent B." When the sub-agent returns a bad answer, the team debugging it "cannot see that the root cause was upstream." The industry's answer is hierarchical tracing — the handoff is recorded as a span on the parent's trace, the sub-agent's run nests underneath it, and one trace ID flows through both.

That model is correct, and it's exactly what Macha now does — with one important difference. The dev-tooling answer (Braintrust, LangSmith, Arize Phoenix, Langfuse, Datadog) assumes you're an engineer who will instrument code, ship traces to a separate platform, and read them in a trace viewer. Even the "no manual instrumentation" adapters still expect SDK or OpenTelemetry wiring. Macha's audience is the support operator and the agent builder, not only the engineer — so the trace had to live where they already are: in the chat.

What you actually see

Sub-agents in Macha are a first-class feature: an agent can delegate to specialist sub-agents, each with its own tools, model, and knowledge base, up to three levels deep with built-in circular-reference prevention. You wire them up on the parent agent's configuration — pick which agents it's allowed to call, and Macha treats each one as a tool the parent can invoke.

Before June 10, when a parent delegated, the sub-agent's tool calls streamed past with indentation in the status log and its tools showed up in the "Tools Used" popup — useful, but ephemeral. Once the message was saved, the why behind a sub-agent's answer was effectively gone.

Now, every sub-agent invocation produces its own conversation record, linked back to the parent. In the chat, a new card appears directly under each delegated message. Collapsed, it shows you the at-a-glance identity of who handled the work:

• the sub-agent's avatar and handle (which specialist ran),
• its model (so you can see a cheap mini model handled a simple lookup, or a stronger model took the nuanced reply),
• its connector logos and tool count (which systems it could touch),
• and a green "Handed off" badge marking the delegation.

Click it, and the card expands into the sub-agent's full nested conversation, rendered with the same styling as the main chat: the system prompt it ran under, every tool call with its arguments, every tool result it received, and the final reply it returned to the parent. It reads exactly like a normal chat transcript — because that's what it is — just one level down.

Why "with arguments and results" is the load-bearing detail

Plenty of products will tell you that a tool was called. The useful part is what was passed and what came back. When a billing sub-agent calls zendesk_update_ticket_tags or a Stripe lookup, the question that matters in a post-mortem is never "did it call the tool" — it's "did it call it with the right order ID, and did the result actually say what the agent claimed it said." Macha shows you both halves: the arguments the sub-agent chose, and the raw result it acted on. That's the difference between confirming an agent's intent and confirming its behavior — and on live customer tickets, only behavior counts.

Zero setup, and it covers autonomous runs too

Two design choices make this genuinely useful in production rather than a debug toy.

First, it's lazy-loaded with no configuration. Every new sub-agent run is captured automatically; there's nothing to turn on, no instrumentation to add, no separate observability bill. The trace is a by-product of running the agent, not a thing you opt into.

Second — and this is the part that matters most for support teams — it works identically for autonomous triggers. Most of the time your interesting multi-agent runs don't happen while you're watching them in chat; they happen at 2 a.m. when a webhook fires, a triage agent picks up a new Zendesk ticket, and it delegates to a specialist that quietly takes a real action. Whether the parent was called by a person in chat or fired by a trigger, the sub-agent's run is captured the same way and shows the same expandable card. So the morning after, you can open the conversation and reconstruct precisely what the chain of agents did unattended.

That pairs with a safety default worth knowing: sub-agents can write (post replies, update tickets) when running via autonomous triggers, but stay read-only during interactive chat. So the runs most likely to have changed something are exactly the ones you'll most want to audit — and now you can.

The same June 10 release also added a Sub-agents column to the Agents list (hover any row to see the names of the linked specialists) and fixed a quieter but nastier bug: previously, opening an agent in the builder and saving any change — even just the description — could silently clear its sub-agent links. Those links now persist correctly across edits. Observability is only worth so much if the topology under it keeps resetting; this closes that loophole.

Where it sits in the stack

It's worth being clear about what this is and isn't. Macha is an AI agent layer on top of the helpdesk you already run — Zendesk, Freshdesk, Gorgias, Front — not a replacement for it. Sub-agent visibility is observability for the agents you built inside that layer; it doesn't reach into, say, native Zendesk automations or another vendor's bot. If you're standing Macha up on Zendesk, the Macha-on-Zendesk overview covers how the agent layer and your helpdesk fit together.

It also isn't a full evals platform. A trace tells you what one run did; deciding whether your agents are systematically good is a different job — that's what Macha's agent evaluation and Studies tooling are for. Think of sub-agent visibility as the per-incident microscope, not the population-level dashboard.

Watch-outs and when this isn't the answer

A few honest caveats:

• Visibility is not prevention. Seeing that a sub-agent made a bad tool call after the fact is strictly better than not seeing it — but if you need a hard stop before an action, that's a job for scoping the sub-agent's tools and using the read-only-in-chat default, not for the trace. The trace is how you learn; guardrails are how you block.
• Runs expire. Sub-agent runs stay available for 45 days under Macha's existing TTL policy, and they deliberately don't count toward your user-facing conversation total. That's the right call for keeping your history clean, but it means a six-month-old incident won't have a nested run to open. If you need permanent audit retention for compliance, export what matters while it's live.
• Deeper chains mean more to read. Three levels of delegation is powerful, but a run that fans out across several specialists produces a lot of nested transcript. The card structure keeps it navigable, but multi-agent designs are still something to reach for deliberately — not the default shape for every workflow.
• It's a debugging and trust tool, not a metric. If your question is "what's my overall resolution rate," sub-agent cards won't answer it. Pair them with reporting.

Cost: viewing is free, delegating runs like any agent

Two separate things here. Viewing a sub-agent run costs nothing — it's a by-product of the run, with no observability surcharge. Delegating to a sub-agent costs what any agent response costs: credits per AI action, by the model that sub-agent uses (the default GPT-5.4 Mini is 1 credit; the range is roughly 0.5–9 credits depending on model). A parent that calls two specialists is simply running two more model responses, and you can now see each one and its model right on the card — which, incidentally, makes it obvious when a sub-agent is over-provisioned on an expensive model for a trivial lookup. See the pricing page for current plans and credit allowances.

FAQ

What is multi-agent observability? It's the ability to see, step by step, what a system of delegating AI agents actually did — each agent's reasoning, tool calls, tool results, and handoffs — so you can debug failures and trust the outcome. In Macha, it's rendered directly in chat as an expandable run card under each delegated message, with no setup.

Do I have to configure or instrument anything? No. It's lazy-loaded and automatic for every new sub-agent run. There's no SDK, no tracing dashboard to connect, and no extra configuration.

Does it work for agents triggered by webhooks, not just chat? Yes. Whether the parent agent was started by a person in chat or fired by an autonomous trigger, the sub-agent's run is captured identically and shows the same expandable card — so you can audit unattended runs after the fact.

Can I see the actual tool calls a sub-agent made? Yes — the expanded card shows every tool call with its arguments and every tool result the sub-agent received, plus its system prompt and final reply. You're auditing behavior, not just intent.

How long are sub-agent runs kept? 45 days, under Macha's existing TTL policy. They don't count toward your user-facing conversation total. For longer retention, export what you need while the run is still live.

How deep can delegation go? Up to three levels, with automatic circular-reference prevention so agents can't loop into each other.

Try it

If you already run sub-agents in Macha, you don't have to do anything — open a conversation where an agent delegated and the card is there. If you don't yet, start a 7-day free trial, no credit card required, connect your helpdesk, wire one specialist sub-agent to a parent, and run a delegation. The sub-agents docs cover the setup; the visibility comes for free. For more on how the agent layer fits over Zendesk and friends, browse the blog.

Written by Abbas (Customer Support & AI, Macha) · Reviewed by Ankeet Guha (Co-founder & CTO) · Published 2026-06-24 · Last updated 2026-06-24.