Explore Your Traces

• Traces
• Spans
• Sessions

​

The Traces tab

This is where most investigations start. The Traces tab shows every request your app has handled. Click any trace to expand its span tree and see exactly what happened: which components were called, what inputs and outputs flowed through, how long each step took, and where things went wrong.

​

The Spans tab

Sometimes you need to look across all traces at a specific type of operation — all LLM calls, all tool invocations, or all retrievals. The Spans tab lets you do that, showing individual units of work across your entire project.

​

The Sessions tab

Your users don’t send one-off requests — they have conversations. The Sessions tab groups traces into conversation threads by session.id, so you can follow an entire interaction from start to finish and spot where things go off track.

• Sort and filter sessions by duration, total traces, user ID, or token count
• Click into a session to see the full conversation with inputs and outputs for each turn
• Export session data to CSV or via the Python SDK
• Run session-level evals to detect patterns like user frustration or unresolved issues

session.id must be a non-empty string. Spans with an empty session ID won’t appear in the Sessions tab.

​

Token counts

​

Querying and filters

• Multi-span filters
• Time filters

​

Multi-span filters

Need to find traces based on complex patterns — like traces where an LLM call follows a retrieval, or traces with errors but no tool calls? Create multiple span queries and define relationships between them.

1. Define your first Span Query
2. Click Add Span Query (up to 5)
3. Use Find Traces Matching to combine them with operators: AND, OR, NOT, -> (temporal), => (parent-child)

Multi-Span Operator Details

• AND — traces with spans matching both A and B
• OR — traces with spans matching A or B
• NOT — traces without spans matching the query
• -> (Indirectly Calls) — A starts before B
• => (Directly Calls) — A is the direct parent of B
• Combine with parentheses: (A AND B) OR C, A AND NOT(B -> C)

​

Time filters

Use the Time Selector to focus on the period that matters. Choose presets, use the calendar, or type a custom range directly.

• Presets: Last 15 Min, Last Hour, Last 12 Hours, Last 7 Days, Last Month, Last 3 Months, Last 6 Months
• Custom range: Select “Custom” to pick a specific start and end date/time
• Time zone: Set your preferred timezone; it persists across sessions

​

Saved Views

​

Columns

• Span columns — TraceID, SpanID, Input, Output, Start/End Timestamp, Total Tokens, Status
• Span Evaluations — scores and labels from your span-level evals
• Session Evaluations — scores and labels from your session-level evals
• Annotations — human labels and scores from your team

​

Source mapping

• New spans get human-readable Input and Output columns derived from your paths
• You can filter with input / output instead of long attribute names (input contains 'refund')
• Evaluator tasks can map {input} and {output} directly

​

Export traces

• Export to Notebook — generates a prefilled Python snippet using the Arize SDK to export your data to a DataFrame. Copy it into a Jupyter notebook to start analyzing.
• Export as CSV — downloads the top 10,000 rows currently displayed. Customize columns before exporting.
• Configure Export via Agent (Skills) — opens the Arize Skills setup for exporting via your coding agent.
• Configure Export via Code — shows CLI, Python SDK, and REST API snippets for programmatic export.

​

Fetch a trace by trace ID

ax spans export <project-id> \
  --trace-id <trace-id> \
  --start-time "2024-01-01T00:00:00Z" \
  --end-time "2024-01-02T00:00:00Z" \
  --stdout

resp = client.spans.list(
    project="<project-id>",
    filter="context.trace_id = '<trace-id>'",
)

for span in resp.spans:
    print(span.span_id, span.name)

curl -X POST "https://api.arize.com/v2/spans?limit=500" \
  -H "Authorization: Bearer $ARIZE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "project_id": "<project-id>",
    "start_time": "2024-01-01T00:00:00Z",
    "end_time": "2024-01-02T00:00:00Z",
    "filter": "context.trace_id = '\''<trace-id>'\''"
  }'

​

Analyze traces for error modes

• Arize Skills
• Alyx
• Manually

Run the arize-trace skill in your AI coding agent (Claude Code, Cursor, Codex, Windsurf, and 40+ others) to export traces and analyze them locally.Install skill

npx skills add Arize-ai/arize-skills --skill "arize-trace" --yes

Set up authentication

export ARIZE_API_KEY="YOUR_API_KEY"
export ARIZE_SPACE_ID="YOUR_SPACE_ID"

Ask your agent

# Ask your AI coding agent:
"Export the last day of traces with errors from my project
and tell me what's going wrong"

Other prompts to try: “find me traces that have long latency, and summarize what they have in common”, “why are these traces failing”, “group last night’s errors by root cause”. The skill runs ax traces export under the hood; your agent reads the output and reports patterns.What you get back: a written summary of common patterns across the exported traces. Fast to run. Best for quickly spotting what is going wrong before you commit to deeper analysis. Works with Cursor, Claude Code, Codex, and more.

Alyx is the AI assistant built into the product. Open it from the Traces page or a trace detail view (or press Cmd+L / Ctrl+L) and ask for filters or categories directly:

• “What are the most common error types in the last 24 hours?”
• “Find me the common types of questions users are asking”
• “Filter for LLM spans with latency over 2 seconds”
• “Group failing traces by root cause”
• “Why did this trace fail?”
• “Create a dataset from the filtered spans”

You can also type natural language directly in the filter bar, Alyx converts it to query syntax automatically.What you get back: a Categorized Spans widget with category names, counts, short descriptions, and example spans you can click into. You can also apply the categories back to your spans as annotations. Great for a fast, structured first pass across large volumes of traces.

This is the deepest approach. A small pipeline: traces in → human annotations → named error modes → an evaluator out. Skills and Alyx give you fast coverage; manual annotation gives you categories you can stake a fix on.

1

Open your traces

Filter to failures in the Traces tab above. Plan to read 20–50 failing traces.Output: a filtered list of failing traces to work through.

2

Free-form annotate

For each trace, write a short free-form note about what went wrong. Don’t force it into buckets yet; just capture what’s weird. Examples: “not specific enough”, “made up info”, “too verbose”, “called wrong tool”.Use Human Annotations to capture these notes directly on the traces. Once patterns emerge, formalize them as labels in an annotation config and apply them to matching traces.Output: a set of human annotations attached to real traces, the raw material for clustering.

3

Cluster into error modes

Group your labeled annotations into error modes. Several notes about bad hotel IDs might cluster into a named pattern such as invalid_hotel_id. Expect 3–5 such patterns in total. Others could be tool_call_hallucination, retrieval_miss, or agent_loop.Track the rate of each error mode as a custom metric so you can see whether a fix actually lowers it.Output: 3–5 named error modes, each tracked as a custom metric so you can watch the rate over time.

4

Design evals from the error modes

For each labeled error mode, write an eval that catches it automatically (LLM-as-judge or a code check). The labeled traces become your regression suite. See Evaluators.Output: one evaluator per error mode, with the labeled traces as its regression suite.

​

Fix the error mode

• Save failing traces to a dataset: those traces become your regression suite for future prompt tweaks, retrieval updates, tool changes, or any other fix.
• Run an experiment: compare the old vs new version against the dataset; ship the fix only if the experiment shows improvement without regressions on other examples.

​

Next step