Debugging Multi-Agent Systems: Why "It Works" Isn't Enough Anymore

As agent systems move from single-chain prototypes to multi-agent production pipelines, a new failure mode has become common: the agent technically did what it was told, but the outcome is still wrong.
Debugging a single LLM call is straightforward. You look at the prompt, the response, done. Debugging a multi-agent system is a different problem entirely — a request that gets handed off through 4-5 agents can fail because:
The wrong tool got selected (but the tool call itself succeeded)
Retrieved context was accurate but stale
One agent wrote to a memory scope that a different agent read from later, for an unrelated reason
The final output looks fine, but the reasoning path that produced it wasn't
The core issue: most tracing tools log what happened, not why.
A trace showing "Agent B called Tool X with these params" tells you the call happened. It doesn't tell you why Agent B decided to call Tool X, what context it believed was true at that moment, or whether that context was still valid.
What actually helps:
Tag memory events with intent, not just content — log why a write happened, not just what was written
Make every step replayable in isolation — you should be able to fork a run from any node and re-execute just that segment
Separate "tool call succeeded" from "tool call was the right call" — these get conflated in most logging setups, and it's the second one that actually matters for debugging
We ran into this building Cartha, a governance and observability layer for AI agent fleets, and it changed how we think about tracing — treating memory scope and decision rationale as first-class, queryable data rather than something buried in a log line.
Curious how others are handling this — are you building custom instrumentation, or leaning on LangSmith/Langfuse and accepting the gap?