# What Are the Top Helicone Alternatives to Route, Debug, and Analyze Agents?

Canonical HTML URL: https://www.zenml.io/blog/helicone-alternatives

Compare 8 Helicone alternatives for routing, tracing, and evaluating agents: Kitaru, Langfuse, LangSmith, Arize Phoenix, Opik, Portkey, LiteLLM and Braintrust.

Note: this is a repo-owned Markdown mirror for agents and readers. It omits visual-only UI, decorative media, navigation, analytics, and other browser chrome.

- **Author:** Hamza Tahir
- **Published:** 2026-11-13
- **Category:** Kitaru
- **Tags:** kitaru, agents, evaluation, LLMOps, discovery
- **Reading time:** 20 mins

---

Helicone made its name as the one-line way to log LLM calls. You change a base URL and start logging your LLM requests through its gateway with cost, latency, and errors attached.

But Helicone's future is less clear. On March 3, 2026, Mintlify [announced its acquisition](https://www.mintlify.com/blog/mintlify-acquires-helicone) and said Helicone would operate in maintenance mode. The sign-in page says new signups are disabled, and its public [changelog](https://www.helicone.ai/changelog) has no entries after November 2025.

That's a good reason to review your options. We reviewed 8 Helicone alternatives to help you choose what comes next.

## A Quick Overview of the Best Helicone Alternatives

- **Why look for alternatives:** Helicone's product status is unclear after the Mintlify deal; it stores eval scores instead of running evals, and its gateway features need the proxy in your critical path.
- **Who should care:** AI engineering and platform teams who run agents in production behind Helicone's proxy or its async logging.
- **What to expect:** A review of 8 Helicone alternatives, from replay-based evals in Kitaru to self-hosted trace stores (Langfuse, Phoenix, Opik), eval-first platforms (LangSmith, Braintrust), and gateways (Portkey, LiteLLM).

## The Need for a Helicone Alternative?

Helicone handles routing and request logging. But those features don't answer every question a team has once agents reach production. Here are three reasons we think you'll look for an alternative.

### 1. Helicone Collects Scores but Does Not Run Evals or Prevent Regressions

An engineer who changes an extraction prompt or an agent's model needs to test that change against representative failures before it ships. Helicone doesn't run evaluations for you. You run RAGAS, LangSmith, or your own code and post the scores against a request ID. Helicone also deprecated its Experiments feature, so the eval run and the regression check both live outside Helicone.

### 2. You See the Agent Calls, but You Cannot Reproduce Why the Agent Failed

Helicone's Sessions feature groups related requests, tool calls, and vector database queries into a parent-child view. That's useful when you're trying to understand which step went wrong. But finding the bad tool call is only half the job.

Let's suppose a support agent approved a refund after an empty policy lookup. You can read its trace, but you can't ask Helicone to rerun the agent's real code with a revised prompt and the original tool results.

A [May 2026 feature request](https://github.com/Helicone/helicone/issues/5679) also asks for browser interactions and LLM traces to be replayed together. The request points to a broader challenge: when a failure depends on earlier state, developers need more than a record of individual calls.

### 3. You Don't Want a Third-Party Gateway in the Production Request Path

Helicone's proxy routes calls and can retry failures, cache responses, or apply rate limits. But those features work because requests pass through the proxy.

Helicone also offers asynchronous logging through OpenTelemetry. As its [Proxy vs. Async documentation](https://docs.helicone.ai/references/proxy-vs-async) explains, that approach keeps logging outside the model request path, but it doesn't provide the same proxy features. Caching, retries, and custom rate limits remain gateway functions.

This doesn't mean Helicone's proxy is unsafe or unsuitable; it's an architecture choice. Teams that only need traces may prefer direct instrumentation with OpenTelemetry or an SDK, without adding a gateway to every model call.

## Evaluation Criteria

For the alternatives in the list, we evaluated them against 4 key areas:

1. **Agent tracing and debugging:** Can you follow an agent from its original input to the final answer? We looked at LLM calls and tool results, plus retrieval steps and error details. We also checked how you investigate a failure.
2. **Evaluations:** Can you run LLM-as-a-judge, custom code checks, and human evaluations? Can you score individual steps as well as the full agent outcome, and detect regressions automatically?
3. **Framework integrations:** How easily does the platform work with LangGraph, the OpenAI Agents SDK, Google ADK, PydanticAI, and the rest of your Python stack? We also considered how much instrumentation you need to add.
4. **ETL and data access:** Can you retrieve complete traces with their metadata and tool results? We checked APIs and OpenTelemetry support, plus bulk exports to warehouses such as BigQuery, Snowflake, and ClickHouse.

**👀 Note:** Helicone lists HQL from Pro at $79 per month and its plan's Data Export feature from Team at $799 per month. It also documents a CLI that pulls request logs through the API and writes them as CSV, JSON, or JSONL.

## What are the Top Alternatives to Helicone

| Helicone Alternative                                          | Best For                                         | Key Features                                                                       | Pricing                                                                              |
| ------------------------------------------------------------- | ------------------------------------------------ | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| [**Kitaru by ZenML Labs**](https://www.zenml.io/product/kitaru)                   | Replaying production sessions against one change | • Re-runs real agent code with recorded tool history • Expert review and a CI gate | • Free (open source) • Pro Starter comes with a 14-day free trial and then $39/month |
| [**Langfuse**](https://langfuse.com/)                         | An open-source trace store you can export from   | • MIT core with OTLP ingest • Scheduled Parquet export                             | • Free self-host or Hobby • Core $29/month                                           |
| [**LangSmith**](https://www.langchain.com/langsmith-platform) | Evals and a gateway in one account               | • LLM judges, pairwise and human evals • LLM Gateway in beta                       | • Free • Plus $39/seat/month                                                         |
| [**Arize Phoenix**](https://phoenix.arize.com/)               | Self-hosted tracing on OpenTelemetry             | • OpenInference auto-instrumentation • Span replay in the playground               | • Free (self-host) • AX Pro $50/month                                                |
| [**Comet Opik**](https://www.comet.com/site/products/opik/)   | The cheapest paid hosted tier with an OSS core   | • Test Suites • Helicone integration                                               | • Free (open source) • Pro Cloud $19/month                                           |
| [**Portkey**](https://portkey.ai/)                            | A managed gateway with guardrails                | • Fallbacks, retries, caching • Guardrails and a feedback API                      | • Free • Production $49/month                                                        |
| [**LiteLLM**](https://www.litellm.ai/)                        | A self-hosted, open-source gateway               | • 100+ providers behind one API • Budgets and rate limits • Logging callbacks      | • Free (open source) • Enterprise custom                                             |
| [**Braintrust**](https://www.braintrust.dev/)                 | Eval-first teams that gate merges on scores      | • Scorers, human review, and CI • Gateway in public preview                        | • Free • Pro $249/month                                                              |

## 1. Kitaru by ZenML Labs

![Kitaru homepage with the headline "Insights from your agent's traces", a one-line install command, and a terminal showing trace import, analysis, evaluator, and replay commands](https://assets.zenml.io/content/blog/helicone-alternatives/f529152b/01-kitaru.avif)

[Kitaru](https://www.zenml.io/product/kitaru) by ZenML Labs is an open-source, replay-based evaluation runtime for AI agents. It takes sessions your agent already ran, changes exactly one thing, reruns your real agent code, and scores the result next to the original.

A gateway records the model requests your agent made. Kitaru starts from the original input and re-runs the agent's real code. Its tool policies can return results from the recorded session so a test doesn't have to repeat external actions.

Kitaru has adapters for PydanticAI, LangGraph, OpenAI Agents SDK, and Claude Agent SDK. You can also build a project-local adapter for another framework. Its importers support Langfuse, LangSmith, Braintrust, Logfire, Arize Phoenix, and Kitaru JSONL.

### Feature 1. Replay With Recorded Tool History

![Animated walkthrough of a Kitaru replay that reruns a baseline session with recorded tool results and then forks it with one override](https://assets.zenml.io/content/blog/helicone-alternatives/38a4727b/02-kitaru-replay.gif)

[A replay starts from](https://docs.zenml.io/kitaru/core-concepts/replay) a baseline session and feeds your agent its original inputs. A tool policy decides how tool calls get answered: `history` returns the recorded result, `static` returns a fixed one, and `passthrough` runs the live tool.

For each supported tool that issues refunds or writes to a database, configure a `history` policy with `on_miss` set to `fail`. Matching calls reuse recorded results. An unmatched call covered by that policy stops the replay before the tool executes. With no policy configured, Kitaru runs tools live.

You replay unchanged first to get a faithful baseline, then fork with one override: a model, a prompt, or a code change. The diff you read is your change, not replay noise.

### Feature 2. Evaluators, Human Review, and a CI Gate

![Animated walkthrough of Kitaru evaluators writing typed results per session and a domain expert recording a verdict in an investigation](https://assets.zenml.io/content/blog/helicone-alternatives/b095b4b4/03-kitaru-evaluators.gif)

[Evaluators](https://docs.zenml.io/kitaru/core-concepts/evaluators) are Python or TypeScript checks that write typed results for each session. Ten deterministic evaluators ship with the server, and a typed model judge ships as a separate package.

In an [investigation](https://docs.zenml.io/kitaru/core-concepts/investigations), a domain expert answers a question about a session and sets a verdict (acceptable, problematic, or uncertain) pinned to the exact evidence.

You can test a fixed cohort of failures and successful counterexamples after changing an agent. Kitaru runs one replay per session and compares the results. Use `--wait` to catch experiment run failures. To block a change on evaluation quality, have CI check the evaluator scores or verdicts against your release threshold.

### Feature 3. Build Regression Cohorts From Cases That Actually Happened

![Animated walkthrough of Kitaru grouping failed sessions and successful counterexamples into a versioned regression cohort](https://assets.zenml.io/content/blog/helicone-alternatives/327267c2/04-kitaru-cohorts.gif)

Group failed sessions, important production paths, and successful counterexamples into cohorts. Kitaru stores membership as immutable cohort versions, so every experiment runs against a fixed set of sessions that you can identify later. A production incident, for example, can become a permanent regression case instead of disappearing into an old trace.

Let's say a support agent wrongly approves a $280 refund; you can keep that case beside valid refund sessions so the next prompt or model change has to fix the mistake without breaking the cases that already work.

### Pricing

Kitaru is free to self-host under Apache 2.0, with unlimited recording, imports, cohorts, evaluators, experiment runs, and replay on your own workers. One-line install: `curl -fsSL https://kitaru.ai/install | bash`, and `kitaru login --local` starts the server in Docker or Podman.

The hosted option is ZenML Pro, which hosts Kitaru for your team and adds AI engineers that read every new trace next to your evals. Pro Starter offers a 14-day free trial with no credit card. Pro Enterprise has custom pricing:

- **Pro Starter:** $39 per month; 1 AI agent, 1 ML project, unlimited seats, hosted dashboard, schedules, triggers and alerts.
- **Pro Enterprise:** Custom; more agents and projects, on-prem or air-gapped deployment, your own LLM endpoint, SSO, SCIM, custom roles and audit logs, and an SLA.

![ZenML pricing page with three plans: Open Source (free, self-hosted), Starter at $39 per month with a 14-day free trial, and Enterprise with custom pricing](https://assets.zenml.io/content/blog/helicone-alternatives/a6182cef/05-kitaru-pricing.avif)

### Pros and Cons

Kitaru re-runs your agent against recorded external behavior. You can use your existing tracing platform and bring selected failures into Kitaru for expert review, versioned evaluations, and replay-based regression checks. That's useful when you want to check whether a fix works without repeating production side effects.

However, Kitaru is a young project, so interfaces can change. It is deliberately narrow: no gateway for routing or caching, no live monitoring dashboard, no prompt playground, and no OTLP ingest endpoint.

## 2. Langfuse

![Langfuse homepage with the headline "Open Source Agent Evals & Observability" and buttons to start free, read the documentation, or onboard with AI](https://assets.zenml.io/content/blog/helicone-alternatives/057827d1/06-langfuse.avif)

[Langfuse](https://langfuse.com/) is an open-source LLM observability and evaluation platform with an MIT-licensed core. Now part of ClickHouse, it offers tracing and prompt management, along with datasets and evaluations.

### Features

- Trace agent execution with typed observations for model calls, tool invocations, and retrieval steps. The agent graph shows how those steps relate, while error levels help you find the failed call. This is useful when a single user request triggers several agents or tools.
- Evaluate outputs and traces with custom code, LLM-as-a-judge, and human annotation queues. Attach scores to relevant observations or experiments, then compare results after a prompt update. You can also run experiment checks in CI.
- Collect and export trace data through integrations for LangGraph, the OpenAI Agents SDK, Google ADK, and PydanticAI. Its OTLP endpoint accepts HTTP traces, while blob export can send Parquet, CSV, or JSONL files to supported cloud storage. That helps if you need trace data in a warehouse for your own analysis.

### Pricing

[Langfuse is free to self-host](https://www.zenml.io/blog/langfuse-pricing). It also provides a free Hobby plan for up to 2 users, 50,000 units, and 30-day data access. Then you can choose from its paid tiers:

- **Core:** $29 per month
- **Pro:** $199 per month
- **Enterprise:** $2,499 per month

![Langfuse pricing page with four plans: Hobby (free), Core at $29 per month, Pro at $199 per month, and Enterprise at $2,499 per month](https://assets.zenml.io/content/blog/helicone-alternatives/132d8720/07-langfuse-pricing.avif)

### Pros and Cons

Langfuse answers the ETL criterion well, down to a documented ClickHouse warehouse connection. It gives you tracing, prompt versioning, and evaluations without locking their history into a hosted-only service.

However, a slow interface and data loading errors can feel icky. Self-hosting also means maintaining Postgres, ClickHouse, Redis, and object storage. You get control over your traces, but you take on the operational work.

👉 Also read: [Kitaru vs Langfuse](https://www.zenml.io/compare/kitaru-vs-langfuse)

## 3. LangSmith

![LangSmith homepage with the headline "Ship great agents faster with LangSmith" and a diagram of the deploy, test, build, and monitor loop](https://assets.zenml.io/content/blog/helicone-alternatives/b036bf86/08-langsmith.avif)

[LangSmith](https://www.langchain.com/langsmith-platform) is LangChain's platform for observing, evaluating, and deploying agents. Its LLM Gateway, now in public beta, adds spend caps, rate limits, fallbacks, and PII redaction.

### Features

- Investigate agent failures with nested runs, traces, and conversation threads. Use filters to find errors and inspect the steps leading up to them. LangSmith's Polly assistant can help investigate trace data when a long agent session is difficult to untangle by hand.
- Test agent quality with LLM judges, code evaluators, pairwise comparisons, and human feedback. Online evaluators can score individual runs and relevant child steps. A pytest integration lets you run evaluation checks in CI before merging a prompt or code change.
- Instrument frameworks and export traces through integrations for LangGraph, the OpenAI Agents SDK, Google ADK, and PydanticAI. LangSmith also accepts OTLP and supports bulk Parquet export to S3-compatible storage. Use that export when you need to analyze historical traces in BigQuery, Snowflake, or ClickHouse.

### Pricing

[LangSmith offers](https://www.zenml.io/blog/langsmith-pricing) a free Developer plan for solo users, and two paid plans:

- **Plus:** $39 per seat per month
- **Enterprise:** Custom

![LangSmith pricing page with three plans: Developer at $0 per seat, Plus at $39 per seat per month, and Enterprise with custom pricing](https://assets.zenml.io/content/blog/helicone-alternatives/19c0f173/09-langsmith-pricing.avif)

### Pros and Cons

LangSmith pairs its eval suite with a gateway of its own, so it can replace both halves of Helicone under one account. [Users appreciate](https://aws.amazon.com/marketplace/reviews/reviews-list/prodview-a7jhtpxkv5oek) its step-by-step traces, token-cost visibility, and ability to compare prompt or model tests.

The common complaint is the learning curve. It takes time to understand how runs, projects, datasets, and experiments fit together. LangSmith bulk trace export requires Enterprise for customers who signed up after August 3, 2026. Customers who signed up on or before that date can use it on Plus or Enterprise until February 1, 2027.

👉 Also read: [Kitaru vs LangSmith](https://www.zenml.io/compare/kitaru-vs-langsmith)

## 4. Arize Phoenix

![Arize Phoenix homepage with the headline "Open-source AI observability & evaluation" and options to self-host or use AX Cloud](https://assets.zenml.io/content/blog/helicone-alternatives/61a0c12d/10-phoenix.avif)

[Arize Phoenix](https://phoenix.arize.com/) is Arize's self-hosted tracing and evaluation tool, built on OpenTelemetry and OpenInference. It's licensed under the Elastic License 2.0, while Arize AX is the managed platform.

### Features

- Trace LLM parameters, prompt templates, tool calls, retrieved documents, token usage, and runtime exceptions. A filter such as `status_code == 'ERROR'` narrows a project to the failing spans, which helps when a RAG agent returns a bad answer and you need to check both retrieval and generation.
- Auto-instrument traces from LangGraph, the OpenAI Agents SDK, Google ADK, and PydanticAI. Other services can send spans over OTLP through HTTP or gRPC, so your tracing setup can extend beyond one framework.
- Score traces and compare experiments with model-based checks, code evaluators, and human annotations. Save inputs in datasets and run candidates against them. You can use pytest-based checks when you want evaluation results to affect a CI job.
- Export span data through the REST API or Python client for your own analysis. Arize AX Enterprise also offers Data Fabric for warehouse connections to BigQuery, Snowflake, and Databricks.

### Pricing

Arize AX is a separate product. Its hosted AX Free plan includes 25,000 spans per month and 15-day retention.

- **AX Pro:** $50 per month
- **AX Enterprise:** Custom pricing

![Arize AX pricing page with three plans: AX Free, AX Pro at $50 per month, and AX Enterprise with custom pricing](https://assets.zenml.io/content/blog/helicone-alternatives/35d9fe5e/11-phoenix-pricing.avif)

### Pros and Cons

Phoenix works well for engineers who want OpenTelemetry-based tracing and evaluations on their own infrastructure. Its span views are useful for inspecting retrieval steps, model calls, and tool activity without putting a gateway in front of production traffic.

The self-hosted product is available; however, the license is source-available rather than OSI-approved. In [February 2026](https://github.com/Arize-ai/phoenix/discussions/11233), a team ingesting about 100,000 LLM interactions a day reported slow searches on span metadata. Phoenix also isn't a gateway, and its playground can rerun a model call, not the complete agent's tool loop.

👉 Also read: [Langfuse vs Phoenix](https://www.zenml.io/blog/langfuse-vs-phoenix)

## 5. Comet Opik

![Comet Opik product page with the headline "AI Observability & Evals For the Agentic Era" and buttons to try Opik free or get a demo](https://assets.zenml.io/content/blog/helicone-alternatives/52f873c7/12-opik.avif)

[Opik is Comet's open-source](https://www.comet.com/site/products/opik/) observability and evaluation project, licensed under Apache 2.0. It supports Helicone integration, so Helicone's gateway can stay in front of your models while Opik takes the traces.

### Features

- Follow agent behavior through traces, spans, and conversational threads. Opik records model calls, tool calls, and external API activity. Agent graphs are available for supported frameworks, which helps when an agent makes several decisions before reaching an incorrect answer.
- Build repeatable evaluation suites with Test Suites. You can add natural-language assertions backed by an LLM judge, then configure repeat runs and pass thresholds to account for model variation. This is useful when a candidate prompt passes one test but fails on the next attempt.
- Score production behavior and review failures with online evaluation rules for traces, spans, or threads. Human reviewers can use annotation queues to label problematic cases before those cases become test data.
- Connect and export data through integrations for LangGraph, the OpenAI Agents SDK, and Google ADK. PydanticAI traces can flow through Logfire and OpenTelemetry. Use the SDK, REST API, or `opik export` CLI to retrieve data; self-hosted teams can also query ClickHouse.

### Pricing

Opik is open-source and free to self-host with unlimited spans and retention. Its free cloud plan offers 25,000 spans per month with up to 10 members. For scale, you can pick from its paid tiers:

- **Pro Cloud:** $19 per month
- **Enterprise:** Custom pricing

![Opik pricing page with four plans: Open Source ($0), Free Cloud ($0), Pro Cloud at $19 per month, and Enterprise with custom pricing](https://assets.zenml.io/content/blog/helicone-alternatives/93a8c061/13-opik-pricing.avif)

### Pros and Cons

Opik has the cheapest paid hosted tier here and a self-hosted path with no span ceiling. Its combination of observability, evaluations, and prompt management makes it an appealing option if you want to add quality checks after leaving Helicone.

However, Opik's own [LLM Gateway](https://www.comet.com/docs/opik/integrations/opik-llm-gateway) is a beta built for development and testing, so it does not replace Helicone's proxy. Self-hosting comes without user management; RBAC and SSO are Enterprise only. The OpenTelemetry endpoint accepts HTTP only.

👉 Also read: [Opik vs Langfuse](https://www.zenml.io/blog/opik-vs-langfuse)

## 6. Portkey

![Portkey homepage announcing "Portkey is now PRISMA AIRS AI Gateway" with a diagram of the gateway between AI apps, models, and tools](https://assets.zenml.io/content/blog/helicone-alternatives/9cf01d49/14-portkey.avif)

[Portkey](https://portkey.ai/) is an AI gateway with observability, guardrails, governance, and prompt management in one platform. Palo Alto Networks completed its acquisition of Portkey on May 29, 2026. Prisma AIRS AI Gateway became generally available on July 16, 2026.

### Features

- The gateway handles fallbacks, load balancing, automatic retries, conditional routing, circuit breakers, canary tests, and caching. You can send traffic to another provider when the primary model fails or exceeds a rate limit, which is the sort of work Helicone's gateway also handles.
- Trace related model calls by assigning a trace ID to requests. Portkey's [Traces view](https://portkey.ai/docs/product/observability/traces) groups those calls, while span IDs represent parent-child relationships. OpenTelemetry can add non-LLM steps to help explain an agent run.
- Check requests with guardrails that return a yes or no verdict per check, and the feedback API attaches a score from -10 to 10 to a trace. Use these controls to catch policy violations or compare one prompt response, not to replay an entire agent session.
- Supports common agent frameworks through documented integrations for LangGraph, the OpenAI Agents SDK, and PydanticAI. Google ADK support is available through the Python SDK.

### Pricing

Portkey has a free Developer plan, perfect for prototyping and testing. Its hosted plans include:

- **Production:** $49/month
- **Enterprise:** Custom pricing

![Portkey pricing page with three plans: Developer (free forever), Production at $49 per month, and Enterprise with custom pricing](https://assets.zenml.io/content/blog/helicone-alternatives/aa8ea43d/15-portkey-pricing.avif)

### Pros and Cons

Portkey is a hosted gateway with request logs, like Helicone, and it adds guardrails. It's a good fit when you're managing several model providers and want one place to investigate failed requests.

However, its new owner is a security vendor in the middle of a rebrand. The [open-source gateway](https://github.com/Portkey-AI/gateway) has not shipped a release since January 2026. Log export and full-log OpenTelemetry export are Enterprise-only. Tracing centers on requests, and regression tests go through integrations such as Promptfoo.

## 7. LiteLLM

![LiteLLM homepage with the headline "The AI Gateway for platform teams" and a diagram routing apps, agents, and machines through the LiteLLM gateway to LLMs, MCPs, and agents](https://assets.zenml.io/content/blog/helicone-alternatives/c4f83536/16-litellm.avif)

[LiteLLM](https://www.litellm.ai/) is an open-source AI gateway from BerriAI, and the best Helicone alternative for platform teams. It puts more than 100 model providers behind an OpenAI-compatible API and can run on your own infrastructure.

### Features

- Handle model traffic through a proxy with fallbacks, retries, load balancing, and caching. You can point several applications at one endpoint and choose how requests move between providers when a model fails.
- Control access and spending with virtual keys, budgets, and rate limits. LiteLLM also records request-level cost and error information. A shared session ID can group requests, which helps you investigate usage by user or application.
- Trace agents through Lens, LiteLLM's early-access tracing product. Lens accepts OTLP agent traces, stores data in ClickHouse, and documents integrations for LangGraph, the OpenAI Agents SDK, Google ADK, and PydanticAI.
- Forward request logs with logging callbacks to tools such as Langfuse, LangSmith, Arize, OpenTelemetry, and S3. Enterprise integrations extend the export options. Use callbacks when you want LiteLLM to handle routing while another system handles deeper trace analysis.

### Pricing

LiteLLM is open-source and free to self-host on your own Postgres and Redis.

### Pros and Cons

LiteLLM's open-source gateway routes traffic on your own infrastructure with no per-request bill, and it feeds whichever trace store you choose. However, you run and patch it yourself, and that matters. On October 21, 2026, LiteLLM's release pipeline published a compromised `litellm==1.107.0` to [PyPI](https://docs.litellm.ai/blog/security-incident-oct-21-2026-attack-chain) and its container registries. LiteLLM advises anyone who ran the compromised release to isolate the affected environment, rotate credentials it could access, and redeploy from a verified clean release. A hack also happened back in March this year.

## 8. Braintrust

![Braintrust homepage with the headline "Ship quality agents at scale" and buttons to start building or contact sales](https://assets.zenml.io/content/blog/helicone-alternatives/c5ccbb63/17-braintrust.avif)

[Braintrust](https://www.braintrust.dev/) is an eval-first platform for tracing production, running evals, and catching regressions before they reach users. Its hosted Gateway supports multi-provider routing and caching, plus fallbacks for failed requests, and it is free during its public preview.

### Features

- Traces nest spans typed as task, llm, tool, function, or score. Hierarchy, thread, and timeline views show the run, while filters help you find failed calls and investigate why a conversation went off track.
- Run evaluations against production and test data with LLM judges or your own code. Braintrust supports online scoring, human review queues, and side-by-side experiment comparisons. These checks help you see whether a model switch fixes one failure but hurts other cases.
- Gate code changes with evaluation results through a GitHub Action that runs tests in CI. You can compare a candidate against a baseline and decide whether score changes meet your team's release threshold.
- Instrument agents and query their data through LangGraph, the OpenAI Agents SDK, Google ADK, and PydanticAI integrations. Braintrust also accepts OTLP. Use BTQL to query stored logs and inspect patterns across production traffic.

### Pricing

[Braintrust offers](https://www.zenml.io/blog/braintrust-pricing) a free Starter plan and two paid plans:

- **Pro:** $249 per month
- **Enterprise:** Custom pricing

![Braintrust pricing page with three plans: Starter at $0 per month, Pro at $249 per month, and Enterprise with custom pricing](https://assets.zenml.io/content/blog/helicone-alternatives/cb354f71/18-braintrust-pricing.avif)

### Pros and Cons

Braintrust has unlimited users on every plan, so reviewers add no seat cost. However, cloud storage export and self-hosting are Enterprise only. Braintrust offers no SLA for the hosted Gateway. Processed data and scores are metered separately.

👉 Also read: [Kitaru vs Braintrust](https://www.zenml.io/compare/kitaru-vs-braintrust)

## Which Helicone Alternative Should You Choose?

Helicone gave you a gateway and a request log with one base URL change. Its alternatives split that job, so pick the part you need.

- **Portkey** and **LiteLLM** replace the gateway for routing, fallbacks, budgets, and request logs.
- **Langfuse**, **Phoenix**, and **Opik** put a trace store that ingests OTLP on infrastructure you control.
- **LangSmith** and **Braintrust** center the workflow on evals, datasets, and human review.

Underneath all of those sits the second Helicone complaint. Every tool here can show you the request that failed. Kitaru can rerun your agent's code and reuse recorded results for supported tool calls that match under a `history` policy.

That is what you need before a model swap or a prompt rewrite ships. Our platform lets you keep the gateway you like for routing, point Kitaru at last month's real sessions, replay them against the change, and see what breaks before your users do.

[Try Kitaru for free](https://www.zenml.io/product/kitaru).
