Phoenix is live · free plan, paid from $50/mo · last verified 4 Nov 2026 · viability healthy
Phoenix
Open-source LLM observability and agent evaluation you can trace, self-host, and eval end to end.
For debugging a multi-step agent, Phoenix hands you trace-level evidence and a real observe-eval-iterate loop with no per-span bill — a strong deal when the data has to stay in-house. The cost is operational: Helm upgrades, storage, and scaling are yours to run. Teams that don't want that work should start on AX Free and move to AX Pro at $50/mo when retention or span volume gets tight.
Verdict generatedVerified 8d ago · liveness 87/100 · cite: rightaichoice.com/tools/phoenix
- AI engineers debugging multi-step agent workflows with trace-level evidence
- Teams that must keep sensitive prompts and traces inside their own infrastructure
- Developers building eval datasets from real production failures
- Vendor-agnostic stacks already instrumented with OpenTelemetry
- Teams with no appetite for running Docker, Kubernetes, or Helm upgrades
- Prototypes whose traffic will outgrow AX Free's 25k spans and 15-day retention
- Buyers who want a fully managed SaaS experience with zero infrastructure work
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Phoenix if nobody on your team wants to own Docker, Kubernetes, or Helm upgrades and you need the managed multi-modal and enterprise features — those live in paid Arize AX tiers, not the free Phoenix OSS build.
AX Free's 25k spans, 1 GB ingestion, and 15-day retention cap out fast in production — exceeding them pushes you to AX Pro at $50/mo.
Phoenix OSS is free to self-host, and AX Free at $0/mo covers small teams with 25k spans and 15-day retention. AX Pro at $50/mo fits AI-native teams needing 50k spans, 10 GB ingestion, and 30-day retention — cheaper than most per-seat managed observability rivals, but you give up their fully managed depth unless you step up to AX Enterprise.
In short
Phoenix — Open-source LLM observability and agent evaluation you can trace, self-host, and eval end to end. Best for AI engineers debugging multi-step agent workflows with trace-level evidence, Teams that must keep sensitive prompts and traces inside their own infrastructure, Developers building eval datasets from real production failures. Free to start; paid plans from $50/mo.
What is Phoenix?
Phoenix — Open-source LLM observability and agent evaluation you can trace, self-host, and eval end to end. Best for AI engineers debugging multi-step agent workflows with trace-level evidence, Teams that must keep sensitive prompts and traces inside their own infrastructure, Developers building eval datasets from real production failures. Free to start; paid plans from $50/mo.
Phoenix is Arize's open-source observability and evaluation layer for LLM applications and AI agents. It records every step a request takes — prompts, retrievals, tool calls, final outputs — so a bad answer becomes a specific failed step in a trace instead of a hunch. You launch it locally with `uvx arize-phoenix serve`, in Docker, or on Kubernetes via Helm, and data stays in your own environment. The workflow it enforces runs in five stages: observe the trace, annotate what worked and what broke via human review or LLM-as-judge, form a hypothesis about the culprit, build a dataset from production traces, then replay the changed version under identical conditions and score cost, latency, and quality. PXI, the AI engineering agent, works directly against your traces — investigating issues, adding annotations, and running experiments inside the UI. Session support handles multi-turn conversations, and agent trajectory views show path and graph structure. Instrumentation is standards-based. Native OpenTelemetry with the OpenInference spec keeps Phoenix vendor-agnostic across models, frameworks, and languages, and coding agents can wire tracing in with `npx skills add Arize-ai/phoenix`. Managed-agent harnesses now include OpenCode alongside Claude Code, Codex and Cursor, running on Claude Sonnet 4.6 via your own Anthropic provider. The project is ELv2 licensed with 10k+ GitHub stars, 3M+ monthly downloads, and a 7k+ community; the Experiments SDK methods are now stable across the Python, JavaScript and Go clients. Phoenix is the open-source core of a two-product line. Sibling Arize AX is the managed platform: AX Free at $0 with 25k spans/month, 1 GB, and 15-day retention; AX Pro at $50/mo with 50k spans, 10 GB, and 30 days; AX Enterprise custom with SaaS or self-hosted deployment. Multimodal tracing (image, voice, PDF) and custom code evaluators sit on the AX side of the line. Pick Phoenix to own the stack, AX to rent it.
Key features
- Trace every agent step: prompts, retrievals, tool calls, and outputs
- LLM-as-judge evaluation for relevance, toxicity, and quality
- Human annotations and labeling queues on traces
- Build datasets from production traces for reproducible experiments
- Benchmark experiments across cost, latency, and performance
- PXI AI engineering agent investigates issues directly against your traces
- Agent trajectory visualizations with path and graph views
- Session support for multi-turn conversation tracking and session evals
- Native OpenTelemetry support with the OpenInference spec
- Self-host locally with uvx, Docker, or Kubernetes via Helm
- Online evals on traces and spans; offline evals on datasets
- Managed-agent harnesses including Claude Code, Codex, Cursor, and OpenCode
- Stable Experiments SDK methods in Python, JavaScript, and Go clients
- Prompt IDE for iterating on prompts against traced evidence
- Vendor-agnostic across models, frameworks, and languages
Behind the verdict
We reach for Phoenix when an agent misbehaves and nobody can point to the step that broke. Feeding it a trace beats reading logs — prompts, retrievals, tool calls and outputs land in one view, and PXI will dig into a run with you inside the UI. Pick it if your team already thinks in OpenTelemetry. Native OTel plus the OpenInference spec means traces survive a model or framework swap, and the same data feeds the eval loop: annotate, build a dataset from real failures, replay under matching conditions, score cost and latency alongside quality. Pass if nobody wants to own infrastructure. Local, Docker and Helm are all yours to maintain, and version upgrades land on your calendar, not Arize's. A small team without a platform engineer will feel that within a quarter. Watch the managed-platform boundary. Multimodal tracing for image, voice and PDF, and custom code evaluators, are AX features — if that's core to your build, price AX Free or Pro early rather than assuming Phoenix covers it. Closest alternative is Arize AX itself: same lineage, hosted, with 25k spans and 15-day retention free. Choose Phoenix for data residency and no metering; choose AX to skip the ops. Competing open-source tracing stacks exist, but few ship evaluation, annotations and experimentation in the same box. One caveat on volume: OSS Phoenix has no span meter, so your ceiling is whatever storage and query latency you can tolerate. Budget for retention policies before traces quietly pile up.
Models under the hood
as of 2026-11-07
Limitations
- Phoenix is an open-source observability and evaluation layer that runs locally or self-hosted, so when you self-host you own upgrades, storage, and operations.
- The managed offering lives under Arize AX, which is priced and tiered separately.
- It is vendor-agnostic across models, frameworks, and languages, so no single underlying model defines it — an upstream integration detail references Claude Sonnet 4.6 for the OpenCode managed-agent harness.
as of 2026-10-10
Researching Phoenix? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Is Phoenix still active?
Phoenix is live · free plan, paid from $50/mo · last verified 4 Nov 2026 · viability healthy.
Viability score
How well maintained and how widely used is Phoenix? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: November 2026
How we score →What's new in Phoenix
Checked 3 days agoAcross the latest 4 updates: 1 feature update, 2 changelog entries and 1 community discussion.
OpenCode harness added for managed agents
OpenCode joins Claude Code, Codex and Cursor as a managed-agent harness, available on every account. It runs on Claude Sonnet 4.6 via the user's Anthropic provider.
Vertex AI Gemini integration routed through stable /v1 gateway
The Vertex AI Gemini integration now points at a gateway routing only the stable /v1 API. Base URLs ending in /v1 or /v1beta1 are used as-is.
Experiments SDK methods marked stable; Python SDK proxy auth fix
Experiments SDK methods drop pre-release warnings in the Python, JavaScript and Go clients. The Python SDK now sends proxy URL credentials as a Proxy-Authorization header.
Arize blog: Evil Qwen and activation steering vs. SBOMs
Arize post argues model signing and SBOMs show what you shipped, while behavioral evals show what a model actually does. Uses a Qwen3.5-4B activation-steering example.
What do users say about Phoenix?
What people actually say about Phoenix — is it worth it?
We scanned public community sources for Phoenix on Aug 30, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Our own analysis of that scan says the posts were off-subject. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.
How we verified this
Every listed fact about Phoenix — pricing, features, links, status — is re-read from the vendor's own pages by our verification pipeline and each change is logged with a date; the last pass ran on 4 Nov 2026. Analysis is drafted with AI models and checked against our editorial standards before publishing; see how we verify.
Verification history
We have re-verified Phoenix 23 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — changed SSL certificate
- — changed pricing page, limitations
- — changed features, our verdict, who it suits, integrations, who should skip it, pricing tiers, description
- — changed pricing page, limitations, models
- — changed pricing page
- — changed who should skip it, pricing tiers, description, our verdict, summary, features
Showing the 6 most recent of 23 verification passes.
Free to cite with attribution — this page re-verifies continuously.
How much does Phoenix cost in 2026?
Phoenix: Free to start; paid plans from $50/mo. Pricing last verified 4 Nov 2026.
Plans compared
Every published Phoenix tier, its price as the vendor publishes it, who it fits, and what it adds over the tier below. The 12-month cost projection follows.
| Plan | Price | Billing | Who it's for |
|---|---|---|---|
| Phoenix OSS | Free | — | — |
| AX Free | Free | — | Small teams or individual builders evaluating Arize's managed platform with light production traffic and short lookback needs.Adds: Adds SaaS deployment with 25k spans/month, 1 GB ingestion, 15-day retention, 10 Signal issues/month, and unlimited users, evals, experiments, and annotations. |
| AX Pro | $50/mo | monthly | AI-native teams past prototyping that need longer retention, more span headroom, and multi-modal tracing across image, voice, and PDF.Adds: Lifts limits to 50k spans/month, 10 GB ingestion, 30-day retention, and 25 Signal issues/month for $50/mo, and unlocks custom code evaluators and multi-modal tracing. |
| AX Enterprise | Custom | quote | Teams with scaled AI use cases that need custom volume, self-hosted deployment, and enterprise controls such as SSO, audit logs, and HIPAA support.Adds: Removes Signal limits, makes span volume, ingestion, and retention custom, and adds a SaaS-or-self-hosted deployment choice; startup pricing is available. |
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Where the pricing makes sense
The company stage and team size where Phoenix's pricing actually pencils out — and where peers do it cheaper.
Phoenix OSS is free to self-host, and AX Free at $0/mo covers small teams with 25k spans and 15-day retention. AX Pro at $50/mo fits AI-native teams needing 50k spans, 10 GB ingestion, and 30-day retention — cheaper than most per-seat managed observability rivals, but you give up their fully managed depth unless you step up to AX Enterprise.
Has Phoenix's pricing changed?
No plan price for Phoenix has moved since we began logging in Aug 2026; the pricing page is re-read on every verification pass.
Who should pick Phoenix?
Pick Phoenix if you are AI engineers debugging multi-step agent workflows with trace-level evidence, Teams that must keep sensitive prompts and traces inside their own infrastructure, Developers building eval datasets from real production failures, Vendor-agnostic stacks already instrumented with OpenTelemetry.
Look elsewhere if you are Teams with no appetite for running Docker, Kubernetes, or Helm upgrades, Prototypes whose traffic will outgrow AX Free's 25k spans and 15-day retention, Buyers who want a fully managed SaaS experience with zero infrastructure work, Teams that need multimodal image, voice, and PDF tracing, which sits on AX.
Skip it if Skip Phoenix if nobody on your team wants to own Docker, Kubernetes, or Helm upgrades and you need the managed multi-modal and enterprise features — those live in paid Arize AX tiers, not the free Phoenix OSS build.
GeneratedReal-world workflow fit
Concrete scenarios for the personas Phoenix actually fits — and what changes day-one when you adopt it.
Instrument a LangChain agent with OpenTelemetry, run it locally via `uvx arize-phoenix serve`, and replay a production failure to see which tool call or retrieval went wrong.
Outcome: A trace showing the exact failed step, plus an annotation and a dataset row you can replay after the fix.
Stand up Phoenix on Kubernetes via Helm, wire LLM-as-judge evals for relevance and toxicity, and compare two prompt versions against the same dataset.
Outcome: Side-by-side cost, latency, and quality numbers with evidence you can take to a weekly review.
Skip self-hosting and use a free Phoenix Cloud instance or AX Free to trace live traffic and set up human annotations.
Outcome: Trace coverage without running Helm, with a clear upgrade path to AX Pro when spans exceed 25k/month.
Use cases
- Monitor live LLM responses for hallucinations and bias
- Compare prompt versions to optimize response quality
- Debug latency and token usage in production LLM pipelines
- Wire automated evaluations into CI/CD for AI features
- Trace end-to-end calls across LangChain, LlamaIndex, and custom chains
- Audit LLM outputs for compliance and safety
- Run A/B tests on prompt changes across model providers
- Investigate a failing agent run with PXI instead of reading raw logs
Setup time & first value
How long it actually takes to get something useful out of Phoenix — broken out by persona, not the marketing-page minute.
Self-hosting Phoenix OSS is a one-command start (`uvx arize-phoenix serve`), so a first trace can appear in under an hour. Wiring instrumentation across an existing codebase typically takes a day. Helm-based Kubernetes deployments take longer depending on your cluster setup. Two free Phoenix Cloud instances or AX Free get a small team to first value the same day without any infrastructure work.
Switching to or from Phoenix
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From raw log-based debugging: instrument with OpenInference, then replace grep-and-read workflows with trace-level investigation.
- →From LangSmith or similar hosted trace tools: re-point instrumentation at Phoenix via OpenTelemetry to keep the same span data without per-span billing.
- →From a homegrown eval script: import existing labeled examples as a Phoenix dataset and add LLM-as-judge evaluators alongside them.
- →From Phoenix Cloud to self-hosted OSS: run `uvx arize-phoenix serve` or Helm, then update the collector endpoint.
- ↗To Arize AX: keep the same OpenTelemetry instrumentation and point it at the managed endpoint to gain Signal, custom code evaluators, and enterprise controls.
- ↗To a managed rival: because tracing is standard OpenTelemetry, re-point the exporter without rewriting instrumentation.
- ↗To Arize AX Enterprise: step up for SSO, audit logs, HIPAA support, and self-hosted AX deployment.
Integrations
Resources & guides
Tutorials & Learning
YouTube returned 6 videos for “Phoenix”, and we withheld 6: 6 could not be judged, because “Phoenix” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Phoenix.
What are the best Phoenix alternatives?
The closest alternatives to Phoenix we list are LangSmith, Langfuse and Maxim AI. Ranked by direct product-type match, not category overlap.
| Alternative | Pricing | Starts at | Last verified |
|---|---|---|---|
| LangSmith | Freemium | Pricing not published | — |
| Langfuse | Freemium | Pricing not published | — |
| Maxim AI | Freemium | Pricing not published | — |
Alternatives to Phoenix
View allTools that pair well with Phoenix
Common stack mates teams adopt alongside Phoenix, with the specific reason each pairing earns its keep.
LangSmith
LangSmith agent observability: trace, monitor, and evaluate every LLM run with SmithDB-backed trace search.
Langfuse
Open-source LLM observability and agent evals: trace, evaluate, and improve AI agents on one MIT-licensed platform
Maxim AI
Maxim AI pairs AI agent evaluation, simulation and observability with Bifrost, an open-source LLM gateway.
Phoenix vs its closest rival
Phoenix's closest head-to-head is with Agnost Ai — If you need a fully managed, production-focused observability layer that catches the weird edge cases your evals miss, Agnost AI is the pick — but you'll pay undisclosed enterprise prices and get zero integration ecosystem. If you want free, open-source, self-hostable control with deep trace-level debugging, LLM-as-judge evaluation, and ghost-trajectory simulation, Phoenix wins hands-down. Go Phoenix unless you specifically require a commercial vendor's closed-box anomaly detection. Verdict generated
Head-to-head comparisons
Agnost Ai vs Phoenix
If you need a fully managed, production-focused observability layer that catches the weird edge cases your evals miss, Agnost AI is the pick — but you'll pay undisclosed enterprise prices and get zero integration ecosystem. If you want free, open-source, self-hostable control with deep trace-level debugging, LLM-as-judge evaluation, and ghost-trajectory simulation, Phoenix wins hands-down. Go Phoenix unless you specifically require a commercial vendor's closed-box anomaly detection.
GeneratedChroma vs Phoenix
If your priority is debugging and evaluating complex AI agent workflows, choose Phoenix for its deep trace visibility and LLM-as-judge evaluations. If you need a cost-effective, scalable vector search engine for RAG or semantic retrieval, Chroma’s serverless architecture and recent auto-ingest features make it the stronger pick. Both are open-source and freemium, but serve fundamentally different needs.
GeneratedNeon vs Phoenix
Neon is a serverless Postgres platform for app builders who need auto-scaling, branching, and AI backend primitives. Phoenix is an open-source observability tool for AI agent debugging and evaluation. They are complementary: Neon provides the data layer, Phoenix provides the monitoring layer. Choose Neon if you need scalable Postgres with branching; choose Phoenix if you need to trace and evaluate AI agent behavior.
GeneratedPhoenix vs Thefastest Ai
If you need to pick the fastest provider for a latency-sensitive chatbot, TheFastest.ai gives you free, daily-updated benchmarks across regions. If you're debugging or evaluating complex AI agent workflows — with full traces, LLM-as-judge scoring, and dataset creation — Phoenix is the open-source choice. They serve different problems: speed measurement vs. agent quality. Your pick depends on whether you're optimizing for latency or building reliable agents.
GeneratedFrequently asked questions
For makers of Phoenix
- Get a Verified Listing for Phoenix ($39): a written decision within 1 working day.
- Free listing for another tool: Free reviews are decided in order, within 3 weeks of the review starting.
Used Phoenix? Help shape our editorial sentiment research.