FastRoutervs.Helicone

Mintlify's stated rationale for the acquisition is "AI knowledge infrastructure" — they want to build agents that autonomously maintain and update documentation, and the Helicone gateway/observability primitives are useful inputs. Mintlify was already a Helicone customer pre-acquisition.

For current Helicone users:

• Cloud product still runs. Free, Pro ($79/mo), Team ($799/mo), and Enterprise tiers continue to be supported. SLAs unchanged.

• Security patches and new model support continue. The team has committed to keeping the lights on.

• No new features. No new evaluators, no new gateway capabilities, no new analytics surfaces.

• OSS repo accepts community PRs. But there's no core team driving feature work.

• Mintlify-internal use likely deepens. Some Helicone capabilities may end up tightly coupled to Mintlify's agent platform over time.

Pattern is similar to other "acqui-hire-with-a-product" outcomes: the existing platform doesn't disappear, but it stops being a competitive product. The longer you wait, the more your stack accumulates dependencies on a tool that isn't moving.

Helicone's observability layer is genuinely well-designed — sessions, custom properties, per-user/per-feature cost aggregation, request/response tracing across 100+ providers. It's also the part of Helicone with the most parity in the broader market. FastRouter ships an observability stack at feature parity for almost all of those primitives, and the rest of the category (Langfuse, Braintrust, OTel-native backends) covers the same surface.

If your reason for being on Helicone is observability, the migration is structurally low-risk. The data model maps cleanly to FastRouter's traces, sessions, and custom properties; the dashboard surfaces are similar; per-user cost tracking is included; OTel export keeps you backend-agnostic if you'd rather stay portable.

Helicone shipped a real Rust-based gateway in late 2025 — provider routing with weighted policies, instant failover on rate limits/timeouts/server errors, Redis-based caching with cross-provider compatibility (cache OpenAI for Anthropic for up to 95% cost reduction on cache hits), per-user rate limiting, ~10K req/sec capacity per node. As of the acquisition, those capabilities are stable but won't extend further.

FastRouter's gateway is actively developed: 7 routing strategies, AI Auto Model Router, MCP credential vaulting, weighted shuffle for canary releases, category-based routing as a first-class strategy. If routing depth and AI-driven model selection are part of your roadmap, you'll outgrow what maintenance-mode Helicone can offer.

Helicone's experiments and evaluators were genuinely interesting — LLM-as-judge with side-by-side comparison, dataset-driven testing, prompt versioning paired with experimentation. The team had ambitious roadmap signals before the acquisition. Those signals are now frozen.

FastRouter's eval layer is the part of the product that's moving fastest:

• Smart Evaluations — AI quality scoring on live production calls.

• Automatic Evaluations — background sampler that benchmarks competing models on real traffic.

• GEPA — Generative Evolutionary Prompt Architecture iterates across prompt and model combinations toward Pareto-optimal cost/quality.

• Video evaluations — compare model output on video inputs, a content type no other gateway in the category currently supports.

If evals were one of the reasons you chose Helicone, the gap will widen meaningfully over the next 6–12 months across the whole category.

Helicone is Apache 2.0 on GitHub. There's a Docker Compose for development, a Helm chart for Kubernetes, and the gateway repo is also open source. Self-hosting Helicone keeps the product running indefinitely on your own infrastructure — patches still come, models still get added, and you're not exposed to the cloud product's roadmap freeze.

The trade-off is the same as any self-hosted observability platform. You're operating Postgres, Clickhouse, Redis, container orchestration, log retention, the upgrade path. None of that is unique to Helicone — it's the carrying cost of any stateful platform — but worth pricing honestly. For most teams that originally chose Helicone Cloud to avoid running infrastructure, going OSS is a solution that costs more than it saves.

If self-hosting is what you want anyway (compliance, sovereignty, code visibility), Helicone OSS is a reasonable target. LiteLLM is the more common self-hosted choice for the gateway role; pair with Langfuse for evals.

None of these need to be done all at once. Pick the one that matches your constraints, then sequence the work over a quarter.

1. Move to a managed alternative — FastRouter

Lowest engineering lift. Both products are OpenAI-compatible: change the base URL, swap the API key, port your custom property names. Sessions, traces, prompts, and per-user cost tracking all map cleanly. FastRouter offers hands-on migration support for production cutovers and can run in passive audit mode against a slice of your traffic for 7 days first, so you have measured numbers before the switch.

2. Self-host Helicone OSS

Highest fidelity to what you have today. Apache 2.0 repo, Docker Compose for dev, Helm chart for production. You inherit the operational burden — Postgres, Clickhouse, Redis, scaling, upgrades — and you're frozen at the OSS feature set, but the product keeps running on your terms. Best fit if you have a strong DevOps function and Helicone-specific workflows you don't want to retrain.

3. Instrument with OpenTelemetry, stay backend-agnostic

Strategically the most defensive option. Wrap your LLM calls with OpenTelemetry GenAI semantic conventions (or OpenLLMetry / OpenInference), then send to whatever backend you want — Langfuse, FastRouter, your own ClickHouse, multiple at once. You decouple from any single vendor's roadmap. Highest engineering lift up front; you don't have to do this migration again next time someone gets acquired.