​

Metric Charts for Experiments

• Chart catalog — annotation score comparison, run latency, cost, token usage, and error rate, plus a dedicated chart for each annotation name on the dataset. Annotation scores, latency, and cost are selected by default.
• Per-dataset selection — your chart choice and the strip’s height persist per dataset across reloads.
• Drag to reorder — charts in the Selected section of the Charts menu have a drag handle, so you can order the strip however you read it. This applies to the project table charts as well.
• Token charts break down by sub-type — token count and cost charts split prompt and completion usage into a series per token type (input/output, cache_read, cache_write, reasoning, audio) instead of showing one opaque total.
• Breakdown bars in tooltips — cost and token tooltips on spans, traces, sessions, and experiments draw a proportional bar per token type alongside each value’s share of the total.
• Readable when narrow — chart panels keep their axes, legend, and titles legible as the strip is resized or the window shrinks (arize-phoenix 19.9.0+).

​

Download Spans and Traces

• Bulk download — select spans or traces in a project table and export them as OTLP JSON (an OTLP resource_spans envelope, ready to replay into any OTLP-compatible collector) or as JSONL in Phoenix’s span format. Choosing the traces scope pulls every span in each selected trace, not just the selected rows.
• Span detail downloads — the span header has a download menu with Download span JSON, Download span OTLP JSON, and Download trace.
• Streamed and paginated — downloads page through the API and are assembled incrementally, so large selections don’t have to fit in one response.

curl -H "Authorization: Bearer $PHOENIX_API_KEY" \
  "$PHOENIX_HOST/v1/projects/my-project/spans/otlpv1?span_id=4bf92f3577b34da6&limit=1000"

​

Filter Spans by Span ID

import { createClient } from "@arizeai/phoenix-client";
import { getSpans } from "@arizeai/phoenix-client/spans";

const client = createClient();

const result = await getSpans({
  client,
  project: { projectName: "my-project" },
  spanIds: ["4bf92f3577b34da6", "00f067aa0ba902b7"],
});
console.log(result.spans.length);

# Fetch specific spans by OpenTelemetry span ID
px span list --project my-project --span-id 4bf92f3577b34da6 00f067aa0ba902b7

# Bound a listing on both ends
px span list --project my-project --since 2026-07-24T00:00:00Z --until 2026-07-25T00:00:00Z
px trace list --project my-project --since 2026-07-24T00:00:00Z --until 2026-07-25T00:00:00Z

• --span-id on px span list takes one or more span IDs.
• --until on px span list and px trace list sets an exclusive end timestamp, pairing with the existing --since.

​

Root-Span Filtering in the Span Query DSL

• parent_span is None — matches spans with no parent span present, so orphans count as roots.
• parent_id is None — matches only spans that carry no parent pointer at all.

from phoenix.client import Client
from phoenix.client.types.spans import SpanQuery

client = Client()

# Root spans (including orphans) that took longer than a second
query = SpanQuery().where("parent_span is None and latency_ms > 1000")
df = client.spans.get_spans_dataframe(query=query, project_identifier="my-project")

​

Span Detail as Searchable Tables

• Attributes as a searchable table — flattened key/value rows with a search field and a count of every attribute on the span (the count reflects the span, not the current search).
• Annotations and notes as tables — sortable, resizable tables with annotator kind, value, author, and timestamp, and a delete action per row.
• Collapse or expand every section at once — one control in the span info tab flips all cards, so you can take in the shape of a span without scrolling. Individual cards stay independent afterward.
• Clip or wrap rows — the spans, traces, sessions, and experiments tables get a toggle that either clips each row to a single line for even scanning or wraps each row over as many lines as its content needs.

​

Toxicity Evaluator

from phoenix.evals import LLM
from phoenix.evals.metrics import ToxicityEvaluator

llm = LLM(provider="openai", model="gpt-4o-mini")
toxicity_eval = ToxicityEvaluator(llm=llm)

# Score a model output
scores = toxicity_eval.evaluate(
    {"text": "You are a worthless idiot and everyone despises you."}
)
print(scores[0])
# Score(name='toxicity', score=1.0, label='toxic', ...)

# Or point it at the user's message instead
scores = toxicity_eval.evaluate(
    {
        "input": {"query": "Write something mean about my coworker."},
        "output": {"response": "I won't help with that."},
    },
    {"text": "input.query"},
)

import { createToxicityEvaluator } from "@arizeai/phoenix-evals";
import { openai } from "@ai-sdk/openai";

const toxicityEvaluator = createToxicityEvaluator({
  model: openai("gpt-4o-mini"),
});

const result = await toxicityEvaluator.evaluate({
  text: "You are a worthless idiot and everyone despises you.",
});
console.log(result.label); // "toxic"

​

Monty — a Local Restricted-Python Sandbox

• Local, like WebAssembly and Deno — no environment variables, outbound network, or third-party dependencies. Use a hosted sandbox when an evaluator needs any of those.
• Shared runtime — one worker pool serves code evaluators, evaluator validation, and MCP code mode, and enforces per-execution deadlines and bounded output capture.
• Optional dependency — the provider reports as unavailable until pydantic-monty is installed in the server environment.

​

Claude Opus 5 and New Gemini Flash Models

• Claude Opus 5 is registered in the Playground for Anthropic and AWS Bedrock (anthropic.claude-opus-5), and appears in the PXI curated model list.
• Gemini 3.6 Flash and Gemini 3.5 Flash-lite join the Google provider in the Playground.
• The pxi terminal client defaults to claude-opus-5 — override with --model as before.
• Built-in token prices refreshed so cost tracking stays accurate for the current model lineup.

​

AI SDK v7 for the TypeScript SDKs

• @arizeai/phoenix-client 7.0.0 requires the optional ai peer dependency at ^7.0.0. AI SDK v7 no longer emits OpenTelemetry spans through the global tracer provider on its own, so to trace AI SDK calls inside an experiment task, pass the @ai-sdk/otel integration per call, constructed inside the task:

import { generateText } from "ai";
import { OpenTelemetry } from "@ai-sdk/otel";
import { openai } from "@ai-sdk/openai";

const task = async (example: { input: { question: string } }) => {
  const { text } = await generateText({
    model: openai("gpt-4o-mini"),
    prompt: example.input.question,
    telemetry: { integrations: [new OpenTelemetry()] },
  });
  return text;
};

• Evaluators from @arizeai/phoenix-evals are traced automatically and need no setup. Core client APIs keep Node.js 18 compatibility; AI SDK v7-backed features require the Node.js version AI SDK v7 supports. Type-checking the published declarations now requires TypeScript >= 5.3.
• @arizeai/phoenix-evals 2.0.0 emits evaluator spans under the OpenTelemetry gen_ai.* conventions from @ai-sdk/otel instead of the AI SDK v6 ai.* span format, and requires Node.js >= 22.12. The telemetry.tracer and telemetry.isEnabled options are unchanged.
• @arizeai/phoenix-otel 2.1.0 re-exports OTLPTraceExporter from the package root and adds an ESM-only @arizeai/phoenix-otel/vercel subpath re-exporting @arizeai/openinference-vercel, so custom span-processor setups no longer need to install the underlying packages:

import {
  ensureCollectorEndpoint,
  OTLPTraceExporter,
  register,
} from "@arizeai/phoenix-otel";
import {
  isOpenInferenceSpan,
  OpenInferenceSimpleSpanProcessor,
} from "@arizeai/phoenix-otel/vercel";

register({
  projectName: "my-agent",
  spanProcessors: [
    new OpenInferenceSimpleSpanProcessor({
      exporter: new OTLPTraceExporter({
        url: ensureCollectorEndpoint("http://localhost:6006"),
      }),
      spanFilter: isOpenInferenceSpan,
    }),
  ],
});

​

Also in This Release

• Dataset example provenance over REST — dataset examples created from a span now return a source object with the originating span_id and span_node_id, so you can walk from an example back to the trace it came from (arize-phoenix 19.5.0+).
• Retention policy project management — a retention policy’s projects are shown as a filterable token list, with a searchable picker for adding projects and a remove action on each token; removed projects fall back to the default policy (arize-phoenix 19.7.0+).
• Annotation metrics time series in GraphQL — spanAnnotationMetricsTimeSeries, traceAnnotationMetricsTimeSeries, and sessionAnnotationMetricsTimeSeries on Project return annotation summaries bucketed over a time range (arize-phoenix 19.5.0+).
• pytest plugin metadata — the @pytest.mark.phoenix marker accepts experiment_description and experiment_metadata, the plugin records the current commit as git_sha when it runs inside a Git checkout, and evaluator spans are traced through their own pipeline so they no longer mix with task spans (arize-phoenix 19.7.0+).
• px project list --name-contains — a case-insensitive name filter for the project listing (@arizeai/phoenix-cli 1.12.0+).
• Invalid span MIME types fall back to text instead of breaking the span view, and PXI API key errors surface to the user rather than being swallowed (arize-phoenix 19.8.0+).