What Is Arize Phoenix for Agent Tracing?

When an AI agent takes several steps to complete a task, calling tools and retrieving documents along the way, understanding what happened inside that run requires detailed tracing. Arize Phoenix is an open-source platform built for exactly this kind of observability and evaluation. This article explains what Phoenix is and how it supports agent tracing.

What Phoenix Is

Phoenix is an open-source observability and evaluation platform for applications built on large language models, developed by Arize AI. It is built on OpenTelemetry, an industry standard for telemetry data, and uses OpenInference instrumentation to capture the specifics of language-model and agent activity. Because it follows open standards, traces produced by Phoenix can work alongside other tools that understand OpenTelemetry.

Phoenix is designed to run almost anywhere, from a local machine or Jupyter notebook to a containerized deployment or the cloud. This flexibility makes it approachable for individual developers experimenting locally and for teams running it as shared infrastructure.

Tracing Agent Runs

The heart of Phoenix is tracing. It records the path a request takes as it propagates through multiple steps, capturing prompts, retrievals, tool calls, and outputs. For an agent, this produces a granular view of each run, showing the full sequence of decisions and actions rather than just the final answer.

This level of detail helps developers identify bottlenecks, track token usage, and debug specific problems such as an agent selecting the wrong tool. When a run produces an unexpected result, the trace provides the evidence needed to understand why, which is essential for iterating on agent behavior.

Evaluation

Tracing tells you what an agent did; evaluation tells you how well it did. Phoenix includes an evaluation framework for measuring output quality. You can score traces and spans using language-model-based evaluators, code-based checks, or human labels. Running these evaluations consistently lets teams track performance over time and catch regressions before they reach users.

Combining tracing with evaluation in one platform means developers can move quickly from noticing a quality issue to inspecting the exact run that caused it, then to measuring whether a fix worked.

Framework Support and Self-Hosting

Phoenix is intentionally vendor- and language-agnostic. It offers out-of-the-box support for many popular agent frameworks, including the OpenAI Agents SDK, LangGraph, CrewAI, LlamaIndex, and others, along with a range of language-model providers. This breadth means teams can adopt Phoenix without committing to a single framework.

For organizations concerned about data sensitivity, self-hosting is a notable advantage. Because Phoenix is open source and can run in your own environment, traces stay on infrastructure you control rather than being sent to a third-party service. This combination of open standards, broad framework support, and self-hosting makes Phoenix a common choice for teams that want observability without vendor lock-in.