Arize AX Free vs Pro: which should I use if I need more ingestion (GB/month) and longer retention for debugging?

Quick Answer: If you’re bumping into ingestion (GB/month) and retention limits while debugging, Arize AX Pro is the better fit. AX Free is ideal for early experiments; AX Pro gives you 10x the ingestion volume and 2x the retention window so you can trace more agents, more often, over a longer history—without changing how you instrument.

Why This Matters

When you’re debugging production agents, your biggest enemy is missing data. If traces drop because you hit span or GB limits—or you can’t look back far enough in time—you lose the full picture of how your agents behave in the wild. Choosing between AX Free and AX Pro is really about whether you can afford to miss those signals: more ingestion and longer retention translate directly into better incident response, faster root-cause analysis, and higher-confidence changes.

Key Benefits:

• More complete coverage: Higher ingestion (spans and GB/month) lets you trace a larger fraction of traffic, not just a tiny sample.
• Deeper historical context: Longer retention means you can compare behavior before and after prompt/model changes and catch slow-burn regressions.
• Fewer blind spots in debugging: With more data and time, it’s easier to replay specific sessions, inspect multi-agent paths, and tie online incidents back to experiments.

Throughout this piece, I’ll assume you’re instrumenting with OpenTelemetry (or planning to) and that you care deeply about tracing every step of your agents, not just their final answers.

Core Concepts & Key Points

Concept	Definition	Why it's important
Trace spans per month	The number of individual spans (nodes in your trace graph) you can send to Arize AX each month.	Agent workloads are span-heavy: more spans/month means you can capture more tool calls, retries, and reasoning steps without sampling away critical detail.
Ingestion volume (GB/month)	The total volume of telemetry and evaluation data (traces, metadata, evaluator outputs) you can ingest monthly.	Multi-modal prompts, long contexts, and detailed tool results add up quickly; more GB/month lets you log rich context instead of cutting corners.
Retention window (days)	How long Arize keeps your traces and related data available for debugging, dashboards, and experiments.	Longer retention lets you investigate incidents that surface late, analyze slow drifts in agent behavior, and compare releases over real production history.

How AX Free vs Pro Actually Differ (for Debugging)

One platform. Two tiers tuned for different stages of your agent journey.

AX Free — best for early-stage and low-volume debugging

AX Free is designed for individuals and small, early-stage teams who are just starting to ship agents or small workloads:

• Trace spans: 25k spans per month
• Ingestion volume: 1 GB per month
• Retention: 15 days
• Support: Community
• Includes:
  • OTEL-based spans & traces
  • Agent tracing graphs and session support
  • Online evals
  • Product observability (monitors & custom metrics) at low volume
  • Alyx, the Arize agent, to help you instrument and debug

When AX Free is “enough”:

• You’re instrumenting a single agent or a few workflows with low request volume.
• You mainly need short-term debugging after deploying a change.
• You’re okay with sampling traffic or tracing only a subset of sessions.

AX Pro — best for teams that actively debug and iterate

AX Pro is the step up for teams who are running real workloads and need reliable observability, but aren’t yet at full enterprise scale:

• Trace spans: 50k spans per month
• Ingestion volume: 10 GB per month
• Retention: 30 days
• Support: Email support
• Everything in AX Free, plus:
  • Higher rate limits
  • Longer retention
  • More room for multi-agent, tool-heavy traces

When AX Pro is the better choice:

• You have ongoing production traffic and need to see more than just a few days of history.
• You want to trace a larger fraction of your requests (or all critical workloads) without worrying about blowing your limits.
• Your agents are complex (multi-agent graphs, many tool calls, RAG) and span counts per request are high.
• You’re starting to build a data-driven iteration loop—tying production traces into experiments and evals—and need those traces to stick around longer.

TL;DR on the ingestion + retention tradeoff

If your main concern is “I just want to see what my agent is doing right now,” AX Free can hold enough.
If your concern is “I need to investigate incidents over weeks, compare releases, and not miss edge cases,” AX Pro is the safer default.

How It Works (Step-by-Step)

From a developer’s perspective, AX Free and AX Pro behave the same: you instrument once, then scale up as you need more ingestion and retention. Here’s the flow I use in production environments.

1. Instrument with OTEL and OpenInference once

   • Use OpenTelemetry to emit spans for:
     • Prompt construction
     • LLM calls (including retries)
     • Tool calls and responses
     • Routing decisions and multi-agent hops
   • Follow OpenInference-style conventions so every LLM and tool call is structured and queryable.
   • Configure your OTEL collector/exporter to send traces to Arize AX.

   Outcome: Vendor-agnostic tracing you can reuse across Free → Pro → Enterprise without re-instrumenting.

2. Start on AX Free to shape your trace schema

   • Use the Free tier to:
     • Validate that spans are correctly linked into traces and sessions.
     • Ensure you’re logging the right metadata: user IDs (hashed/pseudonymized), route names, evaluator scores, cost metrics.
     • Set up a couple of Online Evals for obvious failure modes (hallucinations, tool-call correctness).
   • Keep an eye on:
     • Span usage: Are you hitting 25k spans/month early?
     • Ingestion GB: Are large prompts, embeddings, or tool payloads consuming your 1 GB quickly?
     • Retention: Do you find yourself wishing you could “go back” more than 15 days?

   Outcome: A clean, production-ready tracing and evaluation schema—just constrained in volume and time.

3. Upgrade to AX Pro when your debugging demands outgrow Free

   Clear signals you’ve outgrown AX Free:

   • You’re sampling aggressively just to stay under span limits—and losing visibility into rare failures.
   • Incidents arise based on events older than 15 days (e.g., model changes, seasonal behaviors) that you can’t investigate.
   • You’re building CI/CD experiments or post-deploy analyses and need a full month of traces to compare before/after.

   After moving to AX Pro:

   • Keep the same OTEL setup; just update your credentials.
   • Increase your tracing coverage (less sampling, more full-session traces).
   • Expand Online Evals and monitors, especially for:
     • Path divergence (agents “following strange paths” but still succeeding)
     • Tool-call correctness
     • Latency and cost SLOs

   Outcome: More ingestion and longer retention on the same open-standard foundation, giving you a realistic debugging window for production agents.

Common Mistakes to Avoid

• Treating Free limits as “good enough” for production SLOs

  With only 1 GB and 25k spans/month, it’s easy to end up tracing such a small slice of traffic that you miss critical incidents.

  How to avoid it: Use AX Free to design instrumentation and basic evals. Once your agents are business-critical or multi-team, move to Pro so you’re not forced into unhealthy sampling just to keep lights on.

• Underestimating span counts in multi-agent setups

  A single user request can easily generate tens or hundreds of spans if you log every tool call, retry, and sub-agent decision (which you should if you care about reliability).

  How to avoid it:

  • Estimate spans/request (e.g., 30–100 for a multi-tool agent) and multiply by expected daily traffic.
  • If that number threatens your monthly span budget on Free, plan for Pro so you don’t end up randomly dropping spans from the most complex flows.

Real-World Example

I’ll use a pattern I’ve seen repeatedly: a marketplace search assistant rolled out to a subset of users.

• Phase 1: The team starts on AX Free while instrumenting a new assistant:

  • ~300 requests/day from an internal beta.
  • Each request creates ~40 spans (LLM calls, RAG retrieval, ranking, pricing API tools).
  • That’s ~12,000 spans/month—fine under 25k. 1 GB ingestion is also enough because they’re not logging heavy payloads yet.
  • 15-day retention is okay because they’re mainly debugging recent prompt tweaks.

• Phase 2: They pilot to real users:

  • Traffic grows to 1,500–2,000 requests/day, same ~40 spans each → 60k–80k spans/month.
  • They want to trace all requests for the first month to understand behavior, not sample.
  • They also add richer metadata and store some tool payload summaries for better debugging, pushing ingestion beyond 1 GB.
  • Retention becomes an issue: a bug tied to a model rollout 3 weeks ago can’t be fully investigated because older traces are gone.

This is where AX Pro becomes the obvious choice:

• 50k spans/month means they can at least:
  • Fully trace critical flows (e.g., users with high business value).
  • Use targeted sampling for less critical paths without going blind.
• 10 GB/month lets them log more contextual detail:
  • Larger prompts and retrieved documents
  • Evaluator outputs (LLM-as-a-Judge scores) and annotations
• 30-day retention lets them:
  • Compare behavior before and after prompt changes.
  • Understand whether a regression was introduced by a router update, a new tool integration, or an external API change.

Pro Tip: Use AX Free to get your span schema, OTEL setup, and Online Evals right; then upgrade to AX Pro before your agent becomes critical to a revenue flow. Retrofitting observability after you’re already in production pain is much harder than scaling up an already-instrumented system.

Summary

If your main constraint is “I need more ingestion and longer retention for debugging,” the key differences between AX Free and AX Pro are simple:

• AX Free: 25k spans/month, 1 GB/month, 15-day retention
  • Great for early experiments, prototypes, and low-volume debugging.
• AX Pro: 50k spans/month, 10 GB/month, 30-day retention
  • Better for active production debugging, multi-agent workflows, and teams that want a full month of history to analyze changes and regressions.

Both are built on the same open standards (OpenTelemetry, OpenInference-style conventions) and the same AI & agent engineering platform. You instrument once, then choose the plan that aligns with how much traffic you have and how serious your SLOs are. If ingestion limits and short retention are starting to constrain how you debug, AX Pro is the right next step.

Next Step

Get Started