Skip to content

Agent Trace Viewer

Inspect AI agent traces from LangChain runs, OpenAI Assistants run steps or a JSON step array, with LLM calls, tool calls, errors, timings and tokens.

Agent Trace Viewer

6 steps, 815 tokens, 1 failed

Total steps
6
Total tokens
815
Total duration
2.99s
Errors
1

About Agent Trace Viewer

Visualize and debug AI agent execution traces. Supports LangChain runs, OpenAI Assistant steps, and generic JSON arrays with type/name/input/output fields. All processing happens client-side.

What this tool does

To inspect an AI agent trace or tool-call log step by step, paste the trace JSON into the Agent Trace Viewer. It auto-detects generic step arrays, LangChain run exports, and OpenAI Assistants step lists, then renders every LLM call and tool call on a timeline with inputs, outputs, duration, and token counts. Parsing runs entirely in your browser, so traces containing prompts or customer data never leave your device.

Updated . Provided as is. Check the output before you rely on it in production.

How to use Agent Trace Viewer

  1. 1

    Paste or load your agent trace JSON

    Export trace JSON from your agent system. Paste into textarea or click 'Load Sample Trace' for example. Supports LangChain, OpenAI Assistants, or generic JSON arrays.

  2. 2

    Click 'Analyze Trace' to visualize

    Parser detects trace format automatically. Shows summary: total steps, token count, duration, error count. View as Timeline (visual bars) or Table (structured rows).

  3. 3

    Debug agent behavior

    Click any step to see full input/output, duration, token count. Look for tool failures, missing outputs, or loops. Filter by type (LLM, Tool, Error) to focus on issues.

  4. 4

    Search and filter steps

    Use text search to find specific tool calls or LLM outputs. Filter by step type. Measure efficiency: count steps, compare durations across runs.

Questions and answers

What is an agent trace?
An agent trace is the step-by-step log of an AI agent run: each LLM call, tool invocation and error with its inputs, outputs, timing and token use. This viewer parses a pasted trace into a timeline and a filterable table with totals for steps, tokens, duration and errors.
What trace formats are supported?
Three shapes: a LangChain export with a top-level runs array, an OpenAI Assistants run-steps list with a data array, and a plain JSON array of steps with type, name, input, output, duration and tokens. Nested child_runs are not expanded.
Can I debug LangChain agents with this tool?
Yes. Paste a LangChain export with a top-level runs array to see each run on a timeline or in a table with its duration, token count, inputs and outputs. Nested child_runs are not expanded, so flatten them into the runs array first.
Does this tool send my traces to a server?
No. All processing happens entirely in your browser. Your agent traces never leave your machine — nothing is sent to any server.
How is this different from Langfuse or AgentOps?
This is a quick paste-and-view tool with zero setup — no account, no backend, no SDK integration. For continuous production monitoring, use a full observability platform like Langfuse or AgentOps.
For AI agents: how to call this tool

Machine-readable contract, endpoints and examples. Humans can ignore this section.

Best Path For Builders

Browser workflow

Runs instantly in the browser with private local processing and copy/export-ready output.

Browser Workflow

This tool is optimized for instant in-browser execution with local data handling. Run it here and copy/export the output directly.

/agent-trace-viewer/

For automation planning, fetch the canonical contract at /api/tool/agent-trace-viewer.json.

How do I inspect and debug an AI agent trace step by step?

Debugging an agent run means answering three questions: which steps ran, what each step received and returned, and where time and tokens went. The Agent Trace Viewer turns a raw trace log into a step-by-step timeline so you can answer all three without reading nested JSON by hand.

Step by step

  1. Paste the trace JSON. The viewer auto-detects the format — no configuration or schema mapping needed.
  2. Read the timeline view first. Each step is typed as an LLM call or a tool call, in execution order, so you can see the agent's decision loop at a glance.
  3. Expand any step to inspect its exact input and output payloads. This is where prompt bugs, malformed tool arguments, and truncated responses show up.
  4. Check per-step duration and token counts to find the slow or expensive steps in the run.
  5. Look for steps flagged as failed, then compare their input against the previous step's output — most agent failures are a mismatch between what one step produced and what the next step expected.
  6. Switch to the table view to scan long runs, sort steps, and compare many tool calls side by side.

Which trace formats does it accept?

Format Detected by Typical source
Generic step array Top-level JSON array of step objects Custom agent frameworks, hand-rolled logging
LangChain runs Object with a runs array LangChain / LangSmith run exports
OpenAI Assistants steps Object with a data array of run steps OpenAI Assistants run-steps API responses

Unrecognized structures produce an explicit format error rather than a partial render, so you know when a trace needs reshaping into one of the three shapes above.

Can I paste production traces safely?

Agent traces routinely contain system prompts, user messages, and tool credentials in argument payloads. This viewer parses and renders the trace entirely client-side — there is no upload, no storage, and no analytics on trace content. Closing the tab discards the data. Still, redact secrets before sharing screenshots of a rendered trace.