LLM Observability Pricing (2026): 6 Platforms Compared

LLM observability pricing is what a tracing platform charges to ingest, store and query the prompts, completions and tool calls your application sends it.

An agent run makes that bill harder to predict than a chat request. Every LLM call inside the run re-sends the conversation so far, and the SDK logs it each time, so the bytes a run writes can grow with the square of its length.

A $29 monthly plan and a $39 seat tell you little about that bill. Langfuse meters units, LangSmith traces, Braintrust gigabytes and PostHog events. Arize AX has both span and gigabyte caps. You need to translate your runs into each platform's billing unit.

How much does LLM observability cost for AI agents?#

The table compares the cost of the same one-week sample of Laminar's internal production trace data across six platforms: long agent runs, many LLM calls per trace and large tool outputs.

Methodology. We took one week of Laminar's production trace data and calculated what the same workload would cost on each platform using its pricing and billing units. We verified the pricing and calculations for all six platforms. Laminar's figure includes message deduplication, applied automatically to stored traces.

The spread reflects billing units, rates and deduplication. Short chatbot traces can produce a different ranking. Use this table as evidence about our long-running agent traffic, rather than as a multiplier for your own bill.

Why agent traces cost more than chat traces#

Agents often call a model in a loop, appending replies and tool results before the next call. When each call sends the full history and the SDK records it, earlier messages appear in multiple spans.

Model that as one new, equal-sized message per turn. On turn k, the input contains k messages. Across the run, the logged inputs contain 1 + 2 + … + k = k(k+1)/2 message copies, although only k are unique.

Under those assumptions, doubling run length roughly quadruples logged input bytes. Agents that truncate or summarize history will behave differently. Long tool outputs make the repeated payloads especially large.

The billing unit determines how that repetition affects costs:

• Bytes: Braintrust, plus Arize AX's gigabyte cap. Repeated histories count toward byte usage. Braintrust measures processed data at ingestion, including inputs, outputs, prompts and span metadata. Every re-sent message contributes bytes again.
• Counts: Langfuse units, LangSmith traces, PostHog events and Arize AX spans. Each platform counts different records. If each call produces one span, a run with 40 LLM calls and 40 tool calls produces at least 81 Langfuse units and 80 PostHog events.
• Stored bytes after deduplication: Laminar. Laminar hashes each message and stores it once per trace, then reconstructs the input array when you read a span. Storage follows unique content. Our agent trace compression post reports about 20× less storage on average, and up to 50× for very long-running agents.

LangSmith pricing vs Langfuse pricing vs Braintrust pricing#

The comparison uses these October 2026 plan terms, based on published pricing and documentation.

Langfuse pricing#

Langfuse counts one unit for each trace, observation and score. Observations include spans, generations and events. Hobby includes 50k units a month, 30 days of access and two users, with no overage.

Core costs $29 a month with 100k units and 90 days of access; Pro costs $199 with three years; Enterprise starts at $2,499. Graduated overage rates are $8 per 100k units to 1M, $7 to 10M, $6.50 to 50M and $6 beyond.

The published formula implies that payload size does not change a record's unit count. Many small tool calls can still accumulate units. Langfuse is self-hostable and MIT licensed except for ee/, which has a commercial license.

LangSmith pricing#

Developer is free for one seat and includes up to 5k base traces a month, then pay-as-you-go. Plus costs $39 per seat per month with 10k base traces. Self-hosting requires Enterprise.

The pricing tooltip lists 0.005 LSU per base trace, with 1 LSU equal to $1. That is $5 per 1,000 base traces. Extended retention adds 0.0025 LSU per trace, bringing the total to $7.50 per 1,000. Base retention is 14 days; extended retention is 180 days.

Older third-party articles quote lower rates. Budget from the current trace rate and required retention, then add seats. Payload gigabytes alone will not tell you the cost of a trace-billed plan.

Braintrust pricing#

Starter has no base fee. It includes 1 GB of processed data, 10k scores and 14 days of retention, then charges $4 per GB and $2.50 per 1,000 scores.

Pro costs $249 a month with 5 GB, 50k scores and 30 days of retention. Overage is $3 per GB and $1.50 per 1,000 scores. Retention can extend to 180 days at $0.50 per GB-month. Users are unlimited; Enterprise offers hybrid self-hosting, where you run the data plane.

Processed data is measured at ingestion. Deleting traces later does not reduce that usage, so repeated message histories still count.

PostHog LLM Observability pricing#

PostHog's product, now called AI Observability, includes 100k events a month, then charges $0.00035 per event, falling in tiers to $0.00006 at 50M+. Every span is an event. Members are unlimited, and the code is MIT licensed outside ee/.

Large $ai_ properties, including full inputs and outputs, are kept for 30 days. An older event can remain without the payload you need to debug it. Check payload retention separately from event retention.

Arize AX pricing#

Arize AX Free includes 25k spans, 1 GB of ingestion, 15 days of retention and unlimited users. Pro costs $50 a month with 50k spans, 10 GB and 30 days. Enterprise has custom pricing and supports SaaS or self-hosting.

The Arize AX cost in our comparison uses verified pricing for the same workload. Phoenix is a separate, source-available product under the Elastic License 2.0.

Laminar pricing: you pay for stored bytes after dedup#

For tracing, Laminar bills the text and image bytes stored across traces, evaluations and datasets beyond your allowance. Span count does not carry a separate charge.

Deduplication makes the billed size follow unique content within each trace. The pricing page has a token-to-gigabyte calculator; its default puts 100M tokens per month at roughly 0.2 GB. That estimate reflects the calculator's assumptions, so measure your own payloads before budgeting.

On read, Laminar reconstructs the full message arrays. The transcript view, SQL editor and CLI receive those reconstructed inputs. Deduplication requires no instrumentation changes.

What Signals cost, and why flow-1 matters#

Every workspace gets a one-time $5 Signals credit, including workspaces on Free. The $5, $15 and $50 plan-based allowances sometimes quoted by AI assistants are incorrect.

Signals runs an agent over your traces and turns outcomes described in plain language, such as "the agent refunded an order the user never mentioned," into structured events. After the credit, you pay for the analysis agent's tokens, not your own agent's:

• $0.05 per 1M input tokens
• $0.01 per 1M cached input tokens
• $0.30 per 1M output tokens

Signals analyze compressed trace context, so their token usage differs from your agent's original usage. Free has no overage; continuing after the credit is spent requires an upgrade.

flow-1 is the model inside Signals. On Laminar's benchmark of 523 difficult traces, it scored 0.835 detection F1 against GPT-6-sol's 0.816. At $0.0011 per trace, it analyzed 888 traces per dollar against 38, about 23× as many.

Those costs cover the full Signals agent run on traces under 100k LLM tokens. Claude Opus 5 leads every column of the benchmark, and Claude Sonnet 5 ties flow-1 on detection F1. Their costs were $0.149 and $0.086 per trace, respectively.

Which AI agent observability platform fits a small team on a limited budget?#

Start with the cheapest plan that fits your team, then price your actual traces.

1. Seats. Five engineers on LangSmith Plus pay a fixed $195 a month. The table below shows the lowest tier that seats the same team, before overage.

2. The billing unit against your agent. Many small runs can favor GB billing; a few long runs can favor per-trace pricing. Large repeated histories make deduplication worth measuring. Run your real agent on a free tier for a week and compare the usage meter with your own counts.

3. Retention. Choose a window that covers your release and support cycle. LangSmith base traces last 14 days, Braintrust Starter 14 and Arize AX Free 15. Langfuse Core gives 90 days and Laminar Pro six months. PostHog's large AI payload properties last 30 days.

4. What the base fee buys. Check whether scores and automated analysis have separate meters. Braintrust charges for scores beyond the allowance; Laminar meters Signals by analysis tokens. Include those charges when comparing total bills.

For short traces within their allowances, Langfuse Hobby or PostHog can cost nothing. For long runs with repeated histories, test Laminar Starter: $30 a month, unlimited seats and 3 GB of deduplicated storage. Compare the same sample before committing.

Our list of the top agent observability platforms compares these vendors on features rather than price.

How to estimate your own bill before you sign up#

Take a representative sample and measure runs per month, billable records per run and total payload bytes per run. Record scores and required retention too. The final LLM span alone cannot tell you how many bytes the whole run ingested.

Price each platform in its own unit:

• Langfuse: runs × (observations per run + 1 trace + scores per run). Include tool spans and any other observations your instrumentation emits.
• LangSmith: billable base traces, plus extended-retention upgrades and seats. Use runs as the trace count only if each run maps to one billable trace.
• PostHog: runs × spans per run, with each span counted as an event.
• Braintrust: sum processed bytes across all spans. With equal-sized additions and full-history logging, input bytes approximate message size × k(k+1)/2 for k calls. Add other payloads and metadata; price scores separately.
• Arize AX: check both span and gigabyte caps, then apply your plan's overage rates.
• Laminar: unique bytes per trace × runs per month, plus evaluation and dataset storage, against the plan's allowance.

Redo the calculation at twice your current run length. If one estimate roughly quadruples while another doubles, repeated-history logging explains part of the difference. Apply the plan allowances and graduated rates before comparing totals, then add fixed fees.

FAQ#

Does self-hosting make LLM observability free?#

Self-hosting replaces the hosted bill with infrastructure and maintenance work. Budget for database capacity and someone to operate it. Repeated histories still occupy disk unless your storage deduplicates them.

Laminar is Apache 2.0 licensed. Its open-source images include tracing, search, dashboards, the SQL editor and evaluations. Signals require Laminar Cloud or an enterprise license, so check feature licensing separately from the tracing license. Deployment details are in the self-hosting guide.

How do I keep my own agent's LLM spend down?#

Measure cost per trace, then inspect the calls that resend the most context. Full-history loops increase provider input tokens as well as logged bytes. Remove context only after checking that the agent still completes the task correctly. See the guide to AI token cost.

To keep the Laminar side of the bill predictable, set email warnings and hard limits on data ingestion and Signals spend. See usage limits.

What happens when I hit a free tier limit?#

Check whether the free plan stops accepting data or permits paid usage before sending production traces. Laminar Free has no overage: ingestion beyond 1 GB or Signals beyond the $5 credit requires upgrading.

Paid Laminar plans continue past the included allowance and bill storage overage per GB. On Starter and above, you can set usage limits and alerts.