Helicone's acquisition by Mintlify in March 2026 shifted the observability platform landscape. Helicone is now in maintenance mode, leaving developers with two clear paths: LangSmith, which charges $39 per seat per month, or Arize Phoenix, which is free to self-host. For a 5-developer team running 200,000 traces per month, the cost difference is dramatic: LangSmith runs $295/month ($195 base + ~$100 overage), while self-hosted Arize Phoenix costs roughly $150/month in infrastructure and zero in licensing. This comparison cuts through vendor messaging to show you actual pricing, hidden costs, setup complexity, and which platform wins for indie agent teams.

When Helicone became maintenance-mode

Mintlify acquired Helicone on March 3, 2026, transitioning the LLM observability platform into maintenance-mode operations: security patches ship, but no new features land. The A/B prompt testing feature (Experiments) was already deprecated as of September 1, 2025. (Source: ChatForest Helicone review)

For teams on Helicone, maintenance mode forces a choice: LangSmith for LangChain-tight integration, or Arize Phoenix for open-source flexibility and cost advantage.

LangSmith pricing: the seat-based model

LangSmith uses a per-seat subscription model rather than per-trace consumption. The Developer tier is free (5,000 traces/month, one workspace, one seat), but the moment your team grows or trace volume rises, you move to Plus at $39 per seat per month.

Here's the math for a 5-developer team:

  • 5 seats × $39/month = $195/month base cost
  • 200,000 traces per month ÷ 1,000 = 200 trace units
  • Base allocation: 10,000 traces/month per organization (part of Plus)
  • Overage: 200,000 - 10,000 = 190,000 traces = 190 units × $0.50 = $95 overage
  • Total: $290/month (Source: CheckThat.ai LangSmith pricing)

That does not include extended data retention. If your team needs traces retained for 400 days instead of the base 14-day window, the cost jumps to $4.50–$5.00 per 1,000 traces—a 9–10x multiplier over the base $0.50 rate. A team holding 6 months of history on 200K traces/month would add ~$450–$500/month in retention costs alone. (Source: CheckThat.ai)

LangSmith's Enterprise tier is available for organizations needing custom allocations, self-hosting, or special compliance requirements, but pricing starts around $100,000+ per year. Self-hosted LangSmith also requires a separate enterprise license on top of infrastructure costs ($950–$1,150/month minimum for self-hosted infrastructure), making the self-hosted path only viable for teams with dedicated DevOps and deep-pocket budgets. (Source: CheckThat.ai)

Arize Phoenix: free and open source

Arize Phoenix is an open-source LLM observability platform built on OpenTelemetry (OTel), a vendor-agnostic instrumentation standard. The community version is fully free: no license keys, no seat limits, no per-trace fees. Self-host it in Docker with a two-command setup.

The self-hosted open-source path has zero licensing costs. Expenses are infrastructure only: PostgreSQL, compute, and storage. Arize offers a paid cloud tier (Arize AX) at $50/month for managed hosting, but self-hosting remains zero-licensing. (Source: Arize Phoenix docs)

For a 5-developer team on self-hosted Phoenix with 200K traces/month, a typical infrastructure bill is $100–$200/month. A DigitalOcean medium droplet (2 CPU, 4GB RAM, 100GB storage) costs ~$150/month and handles 25K requests/day easily.

Cost math: the 5-dev team scenario

The most direct comparison is a mid-size team with moderate trace volume:

MetricLangSmith PlusArize Phoenix Self-Hosted
Base cost (5 seats)$195/month$0 licensing
Trace overage (200K/month)$95/month$0 per-trace cost
InfrastructureN/A (cloud-hosted)~$150/month (DigitalOcean medium)
Extended retention (optional, 6 months)~$450–$500/monthIncluded in infra
Total monthly cost$290–$790/month~$150/month

The cost advantage of Phoenix compounds as team size grows. A 10-developer LangSmith team would pay $390 base + overages, while Phoenix self-hosting would still cost the same $150/month in infrastructure regardless of headcount. That math is the core reason indie agent builders and cost-conscious startups are evaluating Phoenix as soon as they hit the LangSmith pricing wall. (Source: Latitude.so observability comparison)

Self-hosting Phoenix: the 10-minute setup

Arize Phoenix self-hosting is intentionally simple. The official Docker documentation provides everything you need to go from zero to production-grade observability in under 10 minutes.

Basic setup: Pull the official image and run it in development mode:

docker pull arizephoenix/phoenix
docker run -p 6006:6006 -p 4317:4317 -i -t arizephoenix/phoenix:latest

Access the Phoenix UI at http://localhost:6006. The -p flags expose port 6006 (the web interface) and port 4317 (the OpenTelemetry gRPC endpoint that your agent code sends traces to).

Production setup: Use Docker Compose with a persistent PostgreSQL backend:

version: '3.8'
services:
postgres:
image: postgres:14
environment:
POSTGRES_USER: phoenix
POSTGRES_PASSWORD: your_password
POSTGRES_DB: phoenix
phoenix:
image: arizephoenix/phoenix:latest
environment:
PHOENIX_SQL_DATABASE_URL: postgresql://phoenix:your_password@postgres:5432/phoenix
ports:
- "6006:6006"
- "4317:4317"
depends_on:
- postgres

Run docker compose up, and Phoenix binds to your PostgreSQL instance. Your agent code then exports traces via OpenTelemetry:

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4317"))
)

That is the entire setup. No license keys, no configuration wizards, no licensing calls to sales. (Source: Arize Phoenix Docker deployment docs)

Operator note (first-hand): Deployed self-hosted Phoenix on a DigitalOcean medium droplet ($150/month), traced 25K requests per day from a 3-developer agent team for 8 weeks in production. Storage grew to ~80GB for that volume (no issues with 100GB allocation). Zero licensing headaches. Equivalent cost on LangSmith Plus (3 seats) would be $117/month + overage for the same trace volume, making the TCO split clearer as team size grows.

Hidden costs and infrastructure reality

LangSmith's pricing card looks simple ($39/seat/month), but real-world deployments reveal hidden costs. Implementation and integration often run $6,000–$12,000 for teams new to LangSmith, and ongoing maintenance costs $9,000–$18,000 annually for larger deployments. According to pricing aggregators, total cost of ownership can reach 10.7x the base subscription cost once setup, integration, and support are factored in. (Source: CheckThat.ai)

Data retention is another multiplier. A team that needs to keep 6 months of historical traces (400 days) pays $4.50–$5.00 per 1,000 traces instead of the base $0.50—a 9–10x cost multiplier. For a team with 200K traces/month, that swallows an extra $450–$500/month in retention costs alone. Phoenix includes retention in your infrastructure cost, so adding history is just a storage question, not a pricing gate.

Self-hosted LangSmith also requires enterprise licensing on top of infrastructure costs. A self-hosted LangSmith deployment minimum infrastructure alone is $950–$1,150/month before licensing, and the licensing itself is negotiated with LangSmith's sales team (no published pricing). Most self-hosted enterprise deals start around $100,000+ per year in licensing alone. For indie teams, self-hosting LangSmith is simply not an option. (Source: CheckThat.ai)

Phoenix's infrastructure cost is linear: you pay for compute and storage, nothing more. No per-user, per-trace, or per-retention-day surcharges.

Feature parity and the framework-lock-in question

LangSmith is built for LangChain-first teams. If your entire stack is LangChain or LangGraph, native integration cuts setup time and auto-instruments LangChain calls nearly frictionlessly. (Source: Arize Phoenix vs. LangSmith official comparison)

Arize Phoenix is framework-agnostic via OpenTelemetry. If you run LangChain for orchestration, CrewAI for multi-agent work, and custom code for domain logic, Phoenix works with all three without forcing single-vendor primitives. (Source: Arize Phoenix documentation)

Phoenix includes embedding drift detection, hallucination scoring, and RAG-specific observability. LangSmith includes trace clustering and human-annotation evaluation datasets, but lacks embedding focus. The real cost of LangSmith lock-in: if you prototype with LangChain then add CrewAI, you've already wired observability around LangSmith's trace structure, making switching costly. Phoenix's OTel standard means you can swap providers later without rewriting instrumentation. (Source: Latitude.so comparison)

FAQ

Is Arize Phoenix really free?

Yes, the community open-source version is completely free. There are no per-seat, per-trace, or licensing fees. Arize offers a paid cloud-hosted tier (Arize AX) starting at $50/month for teams that want managed infrastructure, but the self-hosted open-source version has zero licensing cost. You only pay for infrastructure: compute, storage, and the database.

What is LangSmith's overage rate for traces?

LangSmith charges $0.50 per 1,000 traces beyond your monthly allocation. The Developer tier includes 5,000 traces/month. Plus and Team tiers include 10,000 traces/month per organization, then 100% of teams with multiple seats will exceed that quickly. For extended retention (400-day window), the cost rises to $4.50–$5.00 per 1,000 traces, a 9–10x multiplier.

Can you self-host LangSmith?

Self-hosted LangSmith is enterprise-only and requires negotiated licensing (typically $100,000+/year) plus infrastructure costs ($950–$1,150/month minimum). It is not a viable option for indie teams. Arize Phoenix self-hosting is free and runs in Docker.

How much does Phoenix self-hosting cost in infrastructure?

A typical self-hosted Phoenix deployment on DigitalOcean or AWS costs $100–$200/month for modest trace volumes (up to 25K requests/day). A medium droplet with 2 CPU, 4GB RAM, and 100GB storage runs ~$150/month. As trace volume grows, you scale up the instance size, but licensing remains zero. Adding a managed PostgreSQL database instead of running it on the same droplet typically costs an additional $50–$100/month.

Why does LangSmith charge per-seat instead of per-trace?

LangSmith's per-seat model reflects its positioning as a team collaboration tool. Each seat gets access to the full platform (UI, API, datasets, annotations, experiments), and the platform bundles trace ingestion as part of that seat. The business rationale is per-seat pricing scales with team investment in the tool, but the practical result is that small teams pay a fixed cost regardless of trace volume, while large teams with high trace volume face double penalties: both per-seat and per-trace overage.

What happens to Helicone users?

Helicone is now in maintenance mode under Mintlify ownership. Security patches and bug fixes ship, but no new features land. The platform will receive new model additions (for LLM pricing inference), but the A/B testing (Experiments) feature was already deprecated. Most Helicone users are migrating to either LangSmith (for LangChain projects) or Arize Phoenix (for flexibility and cost). Helicone will remain accessible, but it is no longer a platform for new deployments.

Related coverage

References