Agents

Agent Path Visualization

Understanding agent-based LLM applications is hard. Agentic systems are often designed to make autonomous decisions and chain together dozens—sometimes hundreds or even thousands—of operations. Each operation results in one or more spans. This level of complexity makes it nearly impossible to trace an agent's behavior by manually inspecting individual spans or traces.

Why Agent Path Visualization Matters

Instead of wading through hundreds of spans, stakeholds like developers and AI PMs want to quickly answer questions like:

• What are the most common execution paths?

• Where are things failing?

• Which agents are calling which?

• Is there any self-looping behavior?

These kinds of questions are not easily answered by trace lists alone.

That’s why we built Agent Path Visualization—a way to abstract individual spans into higher-level agent or node-based graphs. These visualizations help map your application flow in a human-understandable way, bridging the gap between granular telemetry and system-level insight.

What You Can Do With It

🔎 Single Trace View

In the single trace view, spans are grouped and visualized as nodes (agents or components). This helps reduce trace complexity. You can interact with the graph by:

• Clicking a node to jump directly to relevant spans.

• Visually identifying key transitions and branching.

• Spotting self-looping behavior.

Perfect for: AI PMs and developers looking to quickly understand what happened in a given execution—without deep trace spelunking.

📈 Aggregate View

While single trace is useful, the Aggregate Agent View gives you a system-wide understanding across all traces during a selected time period.

Here’s what it shows:

• Common Paths: Identifies frequently taken DAG paths.

• Traffic Intensity: Nodes and edges are visually scaled by span count—thicker edges and larger nodes represent higher usage.

• Live Stats on Hover: View real-time metrics like span counts, average latency, and evaluation results tied to that node.

• Tooltip Drilldown: Click on a node to view detailed tooltips including:

  • Total spans for that node/agent

  • Latency averages

  • Evaluation scores (e.g., Jailbreak, Correctness)

Explore and Debug With Precision

From the aggregate view, you can drill in further:

• Inspect Traces: Filter the trace list to show only traces that include a selected node/agent.

• Inspect Paths: Focus on a specific node to explore inbound and outbound transitions. Understand how it connects to other agents or nodes.

This is your entry point to zoom from 10,000 feet down to individual traces.

How It Works

The visualization is powered by span metadata that identifies agents and defines the transitions between them. These include:

• metadata.agent_name or metadata.node_name: the name of the component

• metadata.next_agent or metadata.next_node: the next component(s) in the sequence

These attributes are automatically tracked for popular frameworks like LangGraph, CrewAI, OpenAI Agents, and AutoGen. For custom agents or hybrid systems, you can implement these yourself using our Agent Metadata Integration Guide.

Why It’s Powerful

Agent Path Visualization is designed to:

• Bring clarity to chaos in complex traces

• Allow PMs, QA, and eng teams to reason about system behavior without low-level trace inspection

• Identify systemic issues: failure loops, bottlenecks, and hot paths

• Provide actionable visual insight to drive LLM app iteration

Whether you’re debugging latency, improving prompt routing, or analyzing agent effectiveness, this view gives you the system-level perspective you need.

Next Step: Instrumenting Your Agents

To get started with custom metadata or understand what frameworks are already supported, see the Implementing Agent Metadata guide.