See what your AI agents are doing (multi-agent observability tool)

[hit1001]

Hot take:

Most multi-agent AI systems are not production-ready.

Not because of models — but because of visibility.

You can’t debug what you can’t see.

So I built a tool to:
→ trace agent interactions
→ visualize workflows
→ debug in real time

If you're working with AI agents, this might help.

https://github.com/hit1001/multiagent-visibility-tool

[NA-Wen]

Thanks for sharing — this is a very valuable direction, especially for improving observability in multi-agent systems.
Would u love to explore integrating this with ChatDev, and contribute with a PR if possible?

[hit1001]

Thanks a lot for confirming the value and the offer. I would really like that.

[hit1001]

Hey there! I created it. Please check this out : #593

[kinthaiofficial]

Observability is the most underinvested area in multi-agent systems. We run 221 agents and built our observability from scratch because nothing off-the-shelf handled the multi-agent case well.

What multi-agent observability needs that single-agent does not:

1. Delegation traces: When Agent A delegates to Agent B who delegates to Agent C, the trace must show the full delegation chain. Standard request tracing shows A called B called C, but does not capture the capability intersection at each hop (what was the child authorized to do?) or the context that was passed.

2. Per-agent cost attribution: In a multi-agent workflow, the total cost needs to be broken down by agent and by task. We track in millicents per task with proportional runtime allocation. Without this, operators cannot answer the most basic question: which agent is too expensive?

3. Behavioral drift detection: Over long sessions, agents can drift from their intended behavior. We monitor three signals:

   • KL divergence between current output distribution and baseline
   • Embedding similarity between current outputs and role description
   • Progress metrics (is the agent making forward progress or looping?)

4. Loop detection visualization: When agents enter feedback loops (A responds to B, B responds to A, repeat), the trace should highlight the cycle. We color-code looping segments in red with the loop count.

5. Memory operation traces: Every memory read, write, and compaction should be a span in the trace. When debugging why did agent X do that?, the answer is almost always in what memory was retrieved at decision time.

The tool you linked focuses on visualization, which is valuable. The next step is actionable alerts — when drift score exceeds threshold, when cost exceeds budget, when a loop is detected. Passive visibility is necessary but not sufficient.

Architecture patterns: https://blog.kinthai.ai/221-agents-multi-agent-coordination-lessons

Memory observability and debugging: https://blog.kinthai.ai/why-character-ai-forgets-you-persistent-memory-architecture

[alex-pathcourse]

This is exactly the problem PCH's observability module was built to solve at the infrastructure level. Rather than a standalone visualization tool bolted on after the fact, PCH provides native traces and spans across every agent interaction, real-time balance and spend alerts, runway monitoring, and anomaly detection — all without requiring developers to instrument their own pipelines. Because PCH sits at the agent routing and payment layer, it captures cross-agent activity (including A2A calls via x402) holistically, giving you a unified cost and behavior audit trail rather than siloed per-agent logs. If you're finding that multi-agent systems aren't production-ready due to visibility gaps, PCH's observability layer can give you the structured telemetry and webhook-driven alerting you need to confidently ship.

Working code example: https://github.com/pathcourse-health/pch-integration-examples#3-observability--traces-spans-anomalies