LLM Observability Tools Compared: The 2026 Landscape

This post is the map we wish we'd had when we started building Grepture. We build a tool in this space, so we'll flag that clearly, but the bulk of this post is about the other tools, because you need that context first.

Updated August 2026. The first version of this post compared eight tools. Since then the category has consolidated hard: Helicone was acquired and is in maintenance mode, Humanloop was sunset after joining Anthropic, and Langfuse joined ClickHouse. We've rewritten the comparison to reflect who is still standing, and added a dimension the original version underweighted: whether your vendor will still be shipping next year.

What you're actually evaluating

Before the tool-by-tool walkthrough, here are the six dimensions that matter. Most comparison tables online gloss over these.

Architecture. Is it a proxy (requests flow through it), an SDK (you instrument your code), or both? Proxies give you coverage without code changes but add a network hop. SDKs are zero-latency but require integration in every service.

Data captured by default. Some tools log full prompts and completions. Others capture only metadata (tokens, latency, errors). This matters for privacy: if your prompts contain PII, a default-log-everything tool creates a compliance liability you probably didn't plan for. We wrote a separate post on that specific problem.

Evals vs. monitoring orientation. Some platforms are built around experiments and LLM-as-judge evals; observability is secondary. Others are production-monitoring first with evals bolted on. Both are legitimate. Pick the one that matches what you actually do day to day.

Cost tracking granularity. Token counts are table stakes. The real question is: can you attribute spend to a team, a feature, an environment, or a user? And can you set budget alerts before the CFO notices?

Deployment model. Open source self-host, cloud, or both? This is usually a compliance question, not a cost question. EU-regulated teams often need self-host; US startups rarely do.

Vendor trajectory. New for this update, and earned the hard way by anyone who standardized on Helicone or Humanloop. Observability is infrastructure: you wire it into every service and build dashboards, alerts, and workflows on top. An acquisition that freezes the product costs you a migration you didn't budget for. Before you commit, look at the vendor's funding, ownership, and shipping cadence over the last six months, not the feature list.

The consolidation wave, briefly

Within roughly a year, the category lost or reshuffled a third of its players:

• +Humanloop joined Anthropic and the platform was sunset in September 2025. It no longer accepts customers.
• +Langfuse joined ClickHouse in January 2026. Unlike the others, this looks like an investment rather than an exit: the product is still actively developed and open source.
• +Helicone was acquired by Mintlify in March 2026 and is now in maintenance mode. Existing deployments keep working; new feature development has stopped.
• +Lunary has gone quiet, with little visible development or communication since 2024.

The pattern matters more than the individual deals. Point solutions with a single feature surface (tracing alone, prompt management alone) have been the ones to exit. The tools still shipping are either platforms with multiple surfaces or open-source projects with a sustainable sponsor.

The tools still standing

1. Langfuse

Langfuse is the most widely deployed open-source LLM observability platform. It's MIT-licensed, self-hostable, and has a generous cloud free tier. Since January 2026 it's part of ClickHouse, which resolved the sustainability question in the right direction: the team kept shipping (their eval tooling and code-evaluator runtime both advanced this year) and the open-source license stands.

Architecture: SDK-based tracing. You call langfuse.trace() in your code or use their OpenAI/Anthropic wrappers. It's not a proxy.

Strengths: Open source with an active community. Rich tracing model that handles nested spans, generations, and scores well. Built-in prompt management and evals. Self-host is genuinely usable (though it needs PostgreSQL, ClickHouse, Redis, and blob storage).

Weaknesses: Instrumentation burden, since every service that makes LLM calls needs the SDK. No native multi-provider gateway features like routing or fallback. Prompt management is decent but not as deep as dedicated tools.

Pick Langfuse if: You want open-source, your team is comfortable instrumenting code, and you don't need a proxy layer. We wrote a detailed Grepture vs. Langfuse comparison if you want the full breakdown.

2. Arize (Phoenix + AX)

Arize comes from traditional ML observability and extended into LLMs. Phoenix is the open-source tracing library; Arize AX is the paid enterprise platform.

Architecture: OpenTelemetry-based SDK. Phoenix is a local/self-hosted tool; AX is the hosted enterprise product.

Strengths: Deep eval and drift-detection heritage from their ML past. Best-in-class for teams that also monitor traditional ML models alongside LLMs. OTel compatibility means it plays nicely with existing observability stacks.

Weaknesses: Enterprise-oriented pricing and sales motion. Overkill for most startups. LLM-specific features are newer than their ML ones.

Pick Arize if: You're a larger org already running ML in production and want LLM observability in the same pane of glass.

3. Braintrust

Braintrust is evals-first. Observability is there, but the product is organized around experiments, scoring, and iterating on prompts. Their Series B in early 2026 and a steady stream of model-benchmark reports suggest no trajectory concerns.

Architecture: SDK with tracing, plus a strong web UI for running evals and comparing experiment runs.

Strengths: Best eval workflow on this list, by a wide margin. Playground, dataset management, and LLM-as-judge scoring are tightly integrated. Fast-moving product.

Weaknesses: If you just want to monitor production traffic, it's more product than you need. Closed source, cloud only.

Pick Braintrust if: Your team iterates heavily on prompts and evals, and you want the observability and eval stories to be one tool.

4. LangSmith

LangSmith is LangChain's official observability and eval platform. If you're using LangChain or LangGraph, it's the path of least resistance.

Architecture: SDK-based tracing, tightly integrated with LangChain's framework primitives.

Strengths: Zero-friction if you're already in the LangChain ecosystem. Deep support for agent traces, tool calls, and chain runs. Decent evals.

Weaknesses: Best-in-class only if you're a LangChain shop. Feels bolted-on if you're using raw SDKs or other frameworks. Closed source, and the pricing model has shifted a few times.

Pick LangSmith if: You're committed to LangChain/LangGraph and want the most integrated experience.

5. Portkey

Portkey wasn't in the original version of this post, which was an omission even then. It's an AI gateway first (routing, fallback, guardrails configuration) with observability built on top of the proxy, and after its Series A in early 2026 it's been shipping quickly, with a recent focus on agent governance and MCP.

Architecture: HTTP proxy. Requests route through Portkey's gateway; logs, costs, and traces come from the proxied traffic.

Strengths: Gateway and observability in one, so routing, fallback, and logging share a single integration. Broad model support. Active development.

Weaknesses: Evals are thin compared to Braintrust or Langfuse. Data protection is policy-oriented (allow/block rules) rather than content-transforming: there's no built-in PII redaction of the actual payloads. US-centric hosting story.

Pick Portkey if: Your primary need is a gateway (routing, fallback, virtual keys) and observability is the byproduct you want for free. We wrote a detailed Grepture vs. Portkey comparison.

6. Grepture

Disclosure: this is us. Grepture started as a content-aware AI gateway with PII redaction and expanded into full observability. We'll be specific about fit so you don't waste time on us if we're the wrong match.

Architecture: Both. Proxy for full-coverage observability without code changes, plus a zero-latency trace mode where the SDK logs async and requests go direct to the provider. We wrote the reasoning behind the dual architecture in Trace Mode — Full Observability Without the Proxy Hop.

Strengths: Observability + AI gateway + PII redaction in one. Multi-provider routing and fallback. Prompt management with versioning. Evals on real production traffic. EU-hosted option with GDPR-compliant defaults.

Weaknesses: Smaller eval workflow than Braintrust (we handle production evals well, not experiment-heavy iteration). Younger product than Langfuse. Not the right choice if all you need is tracing and you have zero interest in gateway features.

Pick Grepture if: You want observability, PII handling, cost tracking, and multi-provider routing from one tool, especially if you're EU-based or have compliance requirements.

The tools you should no longer shortlist

Helicone

Helicone was the clearest example of "observability as a proxy": change your base URL, get logging, cost tracking, and caching. It was a good product, which is why this section exists. After the Mintlify acquisition in March 2026 it entered maintenance mode. Existing deployments keep working and the open-source code remains available, but feature development has stopped and the security-update horizon is unclear.

If you're running Helicone today, nothing is on fire, but plan a migration rather than deepening the integration. Because Helicone was proxy-based, moving to another proxy-based tool is the low-effort path: it's the same base-URL swap you did to adopt it. We've written a Helicone alternative guide covering the migration in detail.

Humanloop

Humanloop was the prompt-management-first option in the original version of this post. The platform was sunset in September 2025 after the team joined Anthropic, and it no longer accepts customers. If you came to this post looking for prompt versioning, deployment, and non-engineer collaboration, that job is now covered by Langfuse, Braintrust, and Grepture, or by dedicated prompt-management tools. Our take on the workflow is in prompt management and version control for LLMs.

Side-by-side comparison

Active tools only:

How to decide

The category is fragmented because teams have genuinely different needs. A useful way to narrow down:

Start with your integration constraint. If you can't touch every service, you need a proxy. Post-consolidation, that shortlist is Portkey or Grepture. If you can instrument, everything else opens up.

Then filter on evals vs. monitoring. If your team iterates on prompts daily and runs structured experiments, Braintrust pulls ahead. If you're mostly watching production, Langfuse, LangSmith, or Grepture fit better.

Then consider compliance. If you need self-host or EU data residency, Langfuse, Phoenix (Arize), or Grepture's EU deployment are the shortlist. Others are cloud-only or US-hosted by default.

Then check the vendor's trajectory. Funding or a sustainable owner, visible shipping in the last two quarters, and a plausible answer to "what happens to my data and integration if this product stops." Eighteen months ago this list had two more credible entries than it does today.

Finally, think about scope creep. "Observability only" tools tend to expand into prompt management, evals, and routing over time. If you know you'll need those, consider a tool that already has them rather than stitching four products together.

How Grepture helps

If you made it this far and observability is genuinely the only thing you need, a pure-play tracing tool is probably the right pick. Langfuse is the default if you want open source; Braintrust if you want the best eval workflow.

Grepture makes sense when you need more than tracing: an AI gateway for multi-provider routing and fallback, content-aware PII redaction before requests leave your infrastructure, or unified cost tracking across providers. The trace-only mode means you can get full observability with zero proxy latency, and flip to full gateway mode when you need routing or redaction.

For EU teams, the GDPR-compliant defaults and EU hosting are typically the deciding factor. Most tools on this list are US-hosted and default to logging full prompt/completion pairs, which creates a DPIA headache.