The total cost of an AI observability platform is the subscription plus five lines that rarely appear in the demo: growth overages, retention, people costs from per-seat models, infrastructure and engineering time, and the switching cost baked in by proprietary data formats. The metered unit determines how the bill scales once agents carry traffic, so model every vendor at production volume before comparing prices. Work the checklist in five stages, from requirements through security review, pricing diligence, contract terms, and a proof-of-value pilot that open-source tooling can run before any contract gets signed.
Choosing an AI observability platform and buying one are different problems. The buyer’s guide covers the first: the capabilities that separate platforms and the criteria for evaluating them. This piece covers the second, for the person carrying the shortlist into security review, pricing negotiation, and a contract. The costs that decide whether the purchase looks smart in a year mostly live outside the price page, and the checklist below is built to surface them before the signature rather than after.
Start with the unit, because the unit is the business model
Every platform in this category meters something, and what it meters determines how your bill behaves as the AI system grows. Before comparing any prices, identify each vendor’s unit and run your own traffic through it:
| Metered unit | The question to ask | Where the surprise hides |
|---|---|---|
| Seats plus usage | Who counts as a user, and is there a viewer tier? | If there is no viewer tier, every reviewer, annotator, and stakeholder adds a seat, so adoption raises the bill before traffic does |
| Ingested units | What counts as a unit, exactly? | When traces, observations, and scores each count, one agent run with tool calls and evaluators burns many units, so deep instrumentation multiplies cost |
| Scores | Does evaluation depth get metered? | Adding session-level and trajectory evals scales the bill with coverage, taxing the practice the platform exists to encourage |
| Processed data | What’s included per GB, and what are overages? | Agent spans are large, so data-based caps arrive faster than trace counts suggest |
| Spans and volume | What happens past the cap? | Overage rates, what counts as a span, and whether a trace can jump retention class on its own |
Before you compare prices, take one week of real traffic from your highest-volume agent, project it to expected production scale, and price it in each vendor’s units, with evaluation coverage at the depth you actually want rather than the depth the pilot used. The rankings that come out of that exercise regularly differ from the price-page rankings.
The TCO framework: the subscription plus five lines
Total cost of ownership for this category has a consistent shape, and a worksheet with these rows per vendor keeps the comparison honest:
Platform subscription. The tier that fits production volume, priced at that volume rather than at pilot scale.
Growth and overage cost. The same model at three times expected volume, since agent traffic grows with adoption and instrumentation deepens as teams mature. Overage rates and any auto-upgrade mechanics belong here, including clauses where certain traces automatically move to a pricier retention class.
Retention cost. The price of keeping enough history to debug an issue a customer reports three weeks later, or to answer an audit question about last quarter. Base retention windows of 14 to 30 days push real production workloads into extended retention pricing, and that line often rivals the subscription.
People cost. On per-seat models, the fully loaded cost of everyone who should touch the platform, including the support lead who reviews escalations and the PM who reads the dashboard, priced honestly rather than at the engineer-only count the pilot used.
Infrastructure and engineering time. For self-hosted options, the services the deployment runs, who owns upgrades, backups, and on-call, and the loaded cost of that time. For point tools, the glue engineering that connects tracing, evals, and monitoring across products belongs on this line too.
Switching cost. The exit price if this choice turns out wrong: whether the trace data exports in an open format or a proprietary one, whether instrumentation transfers or gets rebuilt, and whether the eval suite is portable code or platform-locked configuration. Platforms on OpenTelemetry and open semantic conventions hold this line near zero, and proprietary formats put re-instrumentation on it.
The offset side of the ledger is the business case: failures caught before customers, engineering hours returned from manual review, and faster verified fixes. That column is value, not cost. Leaving it out makes every vendor look the same. Putting it in shows the gap when a platform can trace the agent and still cannot take you from a failed session to a verified fix.
Build better agents with Arize
Trace, evaluate, and learn. Build agents that work with Arize AX and start tracing your runs today.
Prefer open source? Try Arize Phoenix for self-hosted, open source agent observability.
The checklist, stage by stage
Stage 1: Define requirements before evaluating vendors
- Define the four-dimension requirements from the buyer’s guide: what the team needs on observability, evaluability, actionability, and operability, weighted for your stage.
- Name the agents in scope, their frameworks, their expected volumes, and the modalities involved, including voice if it’s on the roadmap.
- Decide the deployment requirement up front, since “SaaS is fine” versus “our VPC or nothing” cuts the shortlist in half before a single demo.
- Write the success criteria for a pilot now, before any vendor helps write them.
Stage 2: Security and deployment review
- Map exactly what runs where in each deployment model, including where auth lives, since hybrid models that keep the control plane in the vendor’s cloud put a third party in the auth path.
- Ask what outbound connections a self-hosted deployment makes, and what breaks when the local deployment lags the vendor’s update schedule.
- Confirm certifications against actual requirements, whether SOC 2, GDPR, or HIPAA, and note which sit behind Enterprise tiers.
- Check data residency options and whether region choice exists below Enterprise.
Stage 3: Pricing and unit-cost diligence
- Get the unit definition in writing, with worked examples for an agent session that includes tool calls and evaluator scores.
- Price your projected volume, then price it at three times that, and get overage rates into the order form rather than left to a pricing page that can change.
- Ask which demoed capabilities are generally available, which are beta, and which are Enterprise-gated, and get the answer in writing, since category demos increasingly feature capabilities the pricing page doesn’t mention.
- Model retention at the window the workload actually needs, and price the extended tier if base retention runs short.
Stage 4: Contract terms worth negotiating
- Export rights and format, specified concretely enough that leaving is an engineering task rather than a negotiation.
- Price protection on the metered unit, so a unit redefinition can’t reprice the deal mid-term.
- Retention terms matched to compliance needs, with history preserved through any tier change.
- Commitments on beta capabilities the purchase depends on, with remedies if they slip past GA dates.
- Renewal terms modeled at grown volume, since the year-two bill is the one that gets escalated.
Stage 5: Run a proof-of-value pilot on your own traffic
- Run the pilot on one high-stakes production agent with real traffic, since demo datasets flatter every platform equally.
- Instrument on open standards so the pilot’s work transfers to whichever vendor wins, and open-source tooling can run this stage before any procurement conversation starts.
- Measure against the success criteria from stage 1, including the failure-to-fix loop end to end, from a discovered issue to a verified fix with a regression test behind it.
- Have the support lead and the PM use their views during the pilot. A platform engineers like and support can’t read fails half the job.
The costs that hide until year two
A few patterns come up often enough in this category to warrant their own flags:
- Gated capabilities are the most common, where the discovery feature or the custom evaluators that anchored the demo turn out to live behind an Enterprise contract the initial purchase didn’t include.
- Retention repricing is the second, where base windows that felt fine at pilot volume force an extended-retention line that grows with traffic.
- The third is the seat creep on per-seat models, where the platform succeeds, more functions want access, and success itself drives the bill.
- And the quietest is the switching cost that compounds annually, since every month of instrumentation and eval-building on a proprietary format raises the price of ever choosing differently.
None of these are reasons to avoid a vendor, and all of them are reasons to model year two and year three in the TCO worksheet rather than comparing year-one quotes.
The infrastructure that keeps TCO low
The same architecture decisions that make a platform good at the job also make it cheap to own, and the pattern is worth naming as procurement criteria:
- Open standards under the record. OpenTelemetry and OpenInference instrumentation means the switching-cost line stays near zero, the pilot’s work transfers, and no export negotiation guards the data.
- A unit that doesn’t tax adoption. Span and data-volume pricing keeps seats and eval depth off the bill. Volume, overage, and retention still have to be priced at production scale.
- A free tier that’s actually a foundation. An open-source path that runs the full workflow lets the proof-of-value stage happen before procurement, on infrastructure you already have.
- Deployment without a dependency. VPC and on-prem options with the control plane included keep the security review short and the auth path clean.
- One platform for the loop. Tracing, evals, discovery, and monitoring in one record removes the glue-engineering line that multi-tool stacks carry.
Phoenix can run the stage 5 pilot before a contract. Arize AX is the managed layer, priced on data volume, with seats and eval depth unmetered. The full tiers are on the pricing page for more information.
Buyer’s checklist FAQs
What should a TCO model for AI observability include?
The subscription at production volume, overage cost at three times that volume, retention priced at the window the workload needs, people cost on per-seat models, infrastructure and engineering time for self-hosted or multi-tool setups, and the switching cost implied by the data format. The offset column is the cost of failures the platform catches and the engineering hours it returns.
How do we compare vendors with different pricing units?
Translate rather than compare directly: take a week of real traffic from your highest-volume agent, project it to production scale with the evaluation depth you actually want, and price that workload in each vendor’s units. Include everyone who’ll need access on seat-based models, and get worked examples of the unit definition from each vendor in writing.
What belongs in the pilot before purchase?
One production agent with real traffic, instrumented on open standards so the work transfers, measured against success criteria written before vendors got involved. The pilot should exercise the full loop, from discovering a failure through fixing it and verifying the fix held, and it should put cross-functional users in front of their views, since open-source tooling can cover this stage before any contract discussion.
What contract terms matter most in this category?
Export rights with a specified format, price protection on the metered unit, retention terms that survive tier changes, written GA commitments for any beta capability the purchase depends on, and renewal pricing modeled at grown volume. The common thread is protecting year two, since that’s when volume growth, seat creep, and gated features change the economics of a deal that looked clean in year one.
