Supported trace formats

prettyTrace turns raw agent logs into something you can read: a conversation with tool calls linked to their results, a timing waterfall for span-based traces, and stats on tokens, tools and errors. Paste a trace or drop a file on the viewer; the format is detected automatically.

Chat message formats

Traces that are a list of messages, optionally wrapped in a record with tools and metadata (the shape most agent datasets on Hugging Face use).

Format	What is recognised
OpenAI Chat Completions	`role`/`content`, `tool_calls` with JSON-string arguments, `role: "tool"` results linked by `tool_call_id`, `reasoning_content`
Anthropic Messages	top-level `system`, content blocks `text`, `thinking`, `tool_use` and `tool_result` (including `is_error`)
ShareGPT	`conversations` with `from`/`value`, including `function_call` and `observation` turns
LangChain	serialized messages (`HumanMessage`, `AIMessage`, `ToolMessage`, …) and the `type: "human" \| "ai"` dict form
JSONL	one trace per line; switch between traces with the arrows or `j`/`k`

{
  "messages": [
    {"role": "user", "content": "Where is my order?"},
    {"role": "assistant", "tool_calls": [{"id": "c1", "type": "function",
      "function": {"name": "get_order", "arguments": "{\"order_id\": \"W1\"}"}}]},
    {"role": "tool", "tool_call_id": "c1", "content": "{\"status\": \"shipped\"}"},
    {"role": "assistant", "content": "It shipped yesterday."}
  ],
  "metadata": {"model": "my-model", "reward": 1.0}
}

JSON packed inside strings (tool arguments, tool results, metadata columns) is unpacked for display, and reward/success fields are shown as pass/fail badges.

Span formats

Observability tools record an agent run as a tree of timed spans. prettyTrace shows these as a waterfall and also rebuilds the conversation from them: agents resend the full history on every LLM call, so the LLM span with the longest input usually is the whole conversation. When it isn't, the conversation is stitched together from the LLM and tool spans in order.

Format	What is recognised
OpenTelemetry (OTLP JSON)	`resourceSpans` documents, or a JSONL file of them as written by the collector's file exporter
OpenInference (Arize Phoenix)	`openinference.span.kind`, `llm.input_messages.`, `llm.output_messages.`, `llm.token_count.`, `llm.tools.`, `input.value`/`output.value`
OpenTelemetry GenAI conventions	`gen_ai.operation.name`, `gen_ai.input.messages` / `gen_ai.output.messages` (parts format), `gen_ai.usage.`, `gen_ai.tool.`, and the older `gen_ai.*.message` events
Traceloop / OpenLLMetry	`gen_ai.prompt.N.`, `gen_ai.completion.N.`, `traceloop.entity.input`/`output`
Flat span lists	Phoenix-style exports with `context.span_id` / `parent_id`
Jaeger	the `{"data": [{"traceID", "spans", "processes"}]}` JSON export
LangSmith	runs with `run_type`, nested `child_runs` or `parent_run_id`, token counts and errors
Langfuse	a trace with `observations` (`SPAN`, `GENERATION`, `EVENT`, …) linked by `parentObservationId`, or a bare list of observations

A file with spans from several traces is split into one record per trace ID.

What you get

Trace view: colour-coded turns, collapsible system prompts and reasoning, tool calls linked to their results (hover one to highlight the other), failed tool calls in red, search and per-role filters.
Timeline: one segment per turn sized by tokens; click a segment to jump to that turn.
Waterfall: span timing, nesting, models and token counts; click a span for its input, output, attributes and events.
Stats: where the tokens go, tool usage and errors, time spent in LLM calls versus tools.
Tools: the tool schemas offered to the agent, and which ones it never called.
JSON: the raw record as a collapsible tree, plus Format/Minify in the editor.

FAQ

Are my traces uploaded?

No. Parsing and rendering happen in your browser and prettyTrace has no server that receives traces. The site does show ads, and ad scripts run inside the page, so remove secrets, credentials and personal data before pasting. See the privacy policy.

How do share links work?

The trace is compressed into the part of the link after #. Nothing is stored on a server, which also means anyone who has the link can read the trace.

Why are token counts marked with “~”?

For chat formats they are estimated from the text (about four characters per token, one per digit). Span formats that record real token usage show the recorded numbers instead.

My format isn't recognised.

prettyTrace looks for a list under messages, conversations, trajectory, turns and similar keys, or for span fields. If yours is different, the error message lists what it looked for.