Galileo Alternatives in 2026: 7 Honest Picks for Eval Teams

You are probably here because Galileo looks credible on paper, but the per-eval bill keeps creeping, Luna-2 is the only judge family that ships first-party, and the operational surface (gateway, inline guardrails, optimization loop) lives in adjacent tools. This guide compares seven Galileo alternatives across eval depth, license posture, deployment topology, and agent-era coverage. It names which gap each one fills and tells you when to stay on Galileo. Last updated May 20, 2026.

Where Galileo falls short

Galileo’s eval-platform pitch leads with Luna-2, the proprietary judge family marketed as the differentiator. The Luna-2 numbers are real: $0.02 per 1M tokens, 152 ms average latency, 0.95 reported accuracy, 10 to 20 metric heads scored in parallel under 200 ms on L4 GPUs. That math is hard to beat for trace-by-trace online scoring at production volume. Galileo’s enterprise story is also strong: SOC 2, RBAC, dedicated inference for Luna, VPC and on-prem on Enterprise, OWASP-aligned agent security work, and AutoTune for self-improving evaluators (shipped Apr 2, 2026). For regulated buyers in financial services and healthcare, the procurement match is real.

Teams comparing alternatives in 2026 hit three walls.

Wall 1: per-eval cost lock-in. Luna-2 is cheap per 1M tokens, but the cost shape is flat and proprietary. Once online scoring runs on every production trace, the meter never stops. There is no BYOK escape hatch where GPT-4o, Claude, or a self-hosted small open-weight judge can sit behind the evaluator at zero platform fee.

Wall 2: missing operational surface. Galileo does not ship a first-party gateway. There is no inline guardrail layer on the request path (Protect is adjacent, not a base-URL swap), no provider routing with retries and circuit breaking, no exact and semantic caching to drop judge cost. Teams stitch a gateway and a guardrail product around Galileo and pay the integration tax.

Wall 3: license posture. Self-host is Enterprise-tier only. No OSI open-source self-host path. For teams whose security review requires Apache 2.0 or MIT on the platform that holds trace data, Galileo is a non-starter before the feature comparison even begins.

Pick the alternative below that covers the wall you hit first.

TL;DR: Best Galileo alternative per gap

One-row summary: pick Future AGI when per-eval cost and missing operational surface both bite. Pick LangSmith when LangChain is the runtime. Pick Datadog LLM when the observability decision was made years ago.

License and self-host posture

ELv2 and “mostly MIT plus an ee/ directory” are not the same as OSI open source. Call them source-available in a security review. Future AGI is the only Apache 2.0 platform here that ships the full stack (evals, traces, gateway, simulator, optimizer) under one license.

The 7 Galileo alternatives, compared

1. Future AGI: best when per-eval cost + missing operational surface bite together

Apache 2.0. Self-hostable. Hosted cloud option.

Quick take. Future AGI is the pick when Luna-2’s per-eval cost is the problem and the missing operational surface (gateway, inline guardrails, optimization loop) makes the bill worse. The eval stack ships as a package: ai-evaluation is the code-first SDK with 50+ EvalTemplate classes backed by the Turing model family (TURING_LARGE, TURING_SMALL, TURING_FLASH) plus 20+ local heuristic metrics; traceAI carries the same rubric as a span-attached score on live traces; the Agent Command Center fronts 100+ providers with 18+ inline guardrails on the same plane; agent-opt closes the loop with six prompt optimizers (PROTEGI, GEPA, MetaPrompt, BayesianSearch, RandomSearch, PromptWizard).

Ideal for. Teams running Galileo online scoring at a volume where Luna-2 cost compounds, plus a separate gateway and a separate guardrail product around it. Strong fit for RAG, voice, support automation, and copilots across Python, TypeScript, Java, and C#.

Key strengths.

• Lower per-eval cost than Galileo Luna-2. 50+ pre-built evaluators (Tool Correctness, Plan Adherence, Goal Adherence, Task Completion, Hallucination, Groundedness, Faithfulness, PII, Toxicity, Code Syntax). Error localization names which input field caused the failure. BYOK lets any LLM (GPT-4o, Claude, self-hosted open weights) serve as judge at zero platform fee.
• 18+ inline guardrails at the gateway, not adjacent. PII, prompt injection, content moderation, secret detection, hallucination, topic restriction, tool permissions, MCP security, custom expression rules, webhook BYOG, Future AGI Evaluation, plus 15 third-party adapters (Lakera, Presidio, Llama Guard, Bedrock, Azure Content Safety, Pangea, Aporia, Enkrypt). ~29k req/s, P99 21 ms with guardrails on, t3.xlarge.
• Closed-loop optimization. Failing traces feed agent-opt as labeled rows. The optimizer ships a versioned prompt; the CI gate enforces the previous threshold; only versions that hold the contract reach the gateway.
• traceAI breadth. 50+ AI surfaces across Python, TypeScript, Java, and C# (LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Pydantic AI, DSPy, Mastra, Spring AI, LangChain4j). 14 OpenInference span kinds; Phoenix ships 8, Langfuse 5.
• Compliance. SOC 2 Type II, HIPAA, GDPR, CCPA per futureagi.com/trust; ISO 27001 in active audit.

Honest limitations. More moving parts than a single-purpose tracer. ClickHouse, Postgres, Redis, Temporal, and the gateway are real services on self-host; use the hosted cloud if you don’t want to operate the data plane. Turing judge latency (1-5 s cloud) is higher than Luna-2’s 152 ms; flat-rate per-trace online scoring at production volume still favors Luna-2 today on raw speed. Galileo’s regulated-buyer reference set is older.

Pricing. Free tier includes 50 GB tracing and storage, 100K gateway requests, 1M tokens, 60 minutes voice simulation, and 30-day retention; pay-as-you-go after that. Storage $2/GB. Pricing is usage-based, not per-seat. Compliance add-ons (HIPAA BAA, SAML SSO + SCIM) layer per tier. Pricing.

Verdict. Pick Future AGI when Luna-2 cost is the wall, BYOK on the judge plane matters, and runtime guardrails belong on the same network hop as the gateway. Skip if the only requirement is OSS tracing with prompts and datasets and Luna-2 cost is not yet an issue. See Future AGI vs Galileo.

Turing vs Luna-2 in one table

Luna-2 wins on raw judge latency. Turing wins on per-eval cost at scale, multimodal coverage, and the BYOK escape. Run a domain reproduction before standardizing on either.

2. LangSmith: best when LangChain or LangGraph is the runtime

Closed platform. MIT SDK. Cloud, hybrid, Enterprise self-host.

Quick take. LangSmith is the lowest-friction Galileo alternative for LangChain and LangGraph teams. If every agent run is a LangGraph execution, LangSmith gives you native tracing, evals, prompts, deployment, and Fleet workflows without translating concepts into a new vendor model. Outside LangChain, the value drops fast.

Key strengths. LangGraph spans render as the actual graph, not a flat list. Studio visualization, Playground replay, and Prompt Hub map cleanly to LangChain concepts. Fleet (renamed from Agent Builder) brings no-code visual agent authoring into the same plane. v0.13 self-hosted added IAM auth, mTLS, KEDA autoscaling, IngestQueues.

Honest limitations. Custom agents, LiteLLM, direct provider SDKs, or non-LangChain orchestration see the value drop. Platform closed; SDK MIT. Seat pricing makes cross-functional access expensive. No first-party simulator, no integrated gateway, no inline guardrails.

Pricing. Developer free with 5,000 base traces/mo, 1 seat. Plus $39/seat/mo with 10,000 base traces. Base overage $2.50/1K; extended traces $5.00/1K. Enterprise custom.

Verdict. Pick LangSmith when LangChain is the runtime and framework-native ergonomics matter more than OSS control. Skip when the stack mixes custom agents, LiteLLM, direct provider SDKs, and non-LangChain orchestration. See LangSmith Alternatives.

3. Langfuse: best for OSS-first observability

Mostly MIT. Self-hostable. Hosted cloud option.

Quick take. Langfuse is the strongest OSS-first Galileo alternative when the primary need is observability, prompt management, datasets, and evals on a stack you can inspect and operate. The trace UI is dense in a good way, prompt versioning supports labels and environments, and the self-hosting docs walk through the full data plane without hand-waving.

Key strengths. Largest OSS-first community in this category. Deep self-hosting story (web, worker, Postgres, ClickHouse, Redis or Valkey, object storage). Active changelog with Experiments CI/CD and rate-limit tuning in May 2026. Mature annotation queue.

Honest limitations. Eval surface is heuristic and LLM-as-judge; no first-party judge family with documented benchmarks. No error localization. Trajectory metrics like Tool Correctness are manual scorers. No runtime guardrails. No closed-loop optimization. The repo is MIT except for ee directories, which are commercial — call that out in procurement.

Pricing. Hobby free with 50K units/mo. Core $29/mo with 100K units. Pro $199/mo with 3-year retention, SOC 2, ISO 27001 reports. Enterprise $2,499/mo. Self-host free. Units meter traces, observations, scores, and evals together.

Verdict. Pick Langfuse when self-hosted observability with prompts and datasets is the entire requirement and Luna-2 cost is not yet an issue. Skip when the gap is eval rigor, runtime guardrails, or closed-loop optimization. See Langfuse Alternatives.

4. Arize Phoenix: best when OpenTelemetry adherence drives the decision

Source-available under ELv2. Self-hostable. Phoenix Cloud and Arize AX paths.

Quick take. Phoenix is built by Arize, the team that owned ML observability for embedding drift before LLM observability was a category. The pitch is OTLP-first ingestion, canonical OpenInference attributes, and a clean local workbench.

Key strengths. OpenInference reference — canonical attribute names land in Phoenix first. Auto-instrumentation for LlamaIndex, LangChain, DSPy, Mastra, Vercel AI SDK, OpenAI Agents SDK, Bedrock, and Anthropic across Python, TypeScript, Java. Embedding-drift heritage with retrieval-quality dashboards. Single-container self-host plus an OTel collector — lightweight.

Honest limitations. ELv2 is source-available, not OSI open source — flag in security review. Not a gateway, not a guardrail product, not a simulator. The eval surface is smaller than Future AGI’s or Galileo’s, and scoring lives in the Phoenix eval surface rather than as a span-attached primitive the way traceAI ships. Trajectory metrics are manual scorers.

Pricing. Phoenix free self-hosted. AX Free 25K spans/mo, 15 days. AX Pro $50/mo with 50K spans, 30 days. AX Enterprise custom with SOC 2, HIPAA, data residency.

Verdict. Pick Phoenix when OpenInference adherence and the Arize AX path are the buying signals. Skip when gateway, guardrails, simulation, closed-loop optimization, or strict OSI open source are on the list.

5. Braintrust: best for hosted closed-loop eval

Closed hosted platform. Enterprise self-host with closed installer.

Quick take. Braintrust is the closest hosted alternative when Galileo usage is mostly evals, prompts, datasets, online scoring, and CI gates. Tight dev loop for teams that do not need source-level backend control. Best eval UI in the closed category.

Key strengths. Polished UI for experiments, datasets, scorers, prompt iteration, and playgrounds. Sandboxed agent evaluation with tool-call execution; agent-evals more developed than Langfuse’s or Phoenix’s. Online scoring and CI gates in the same product as offline experiments. May 2026 added Java auto-instrumentation for Spring AI and LangChain4j.

Honest limitations. Closed platform; Enterprise-only self-host. No first-party voice simulator. Gateway, runtime guardrails, and prompt optimization are not first-class. Pro at $249/mo is the highest entry tier on this list; overage on processed data and scores adds up at production scale.

Pricing. Starter $0 with 1 GB, 10K scores, 14 days. Pro $249/mo with 5 GB, 50K scores, 30 days. Overage $3/GB and $1.50 per 1K scores. Enterprise custom.

Verdict. Pick Braintrust when structured evals with a polished UI is the dominant problem and gateway, guardrails, and simulation are off the list. Skip when OSS control is non-negotiable or the eval plan depends on simulated users and gateway guardrails in the same stack. See Braintrust Alternatives.

6. Helicone: best for gateway-first observability

Apache 2.0. Self-hostable. Hosted cloud option.

Quick take. Helicone is the right alternative when the fastest path to value is changing the base URL, seeing every request, and controlling spend. The center of gravity is the gateway. That matters when the production issue is provider routing, caching, p95 latency, cost attribution, user-level analytics, or alerting on live LLM traffic.

Key strengths. OpenAI-compatible gateway across 100+ models. Low-friction when direct provider SDK calls are spread across the codebase. Request logging, provider routing, caching, rate limits, sessions, user metrics, cost tracking, HQL, eval scores, and prompt management. Apache 2.0 self-host: gateway plus Postgres.

Honest limitations. Not a deep eval platform. Eval scores and datasets exist, but the center of gravity is gateway observability, not Luna-2-equivalent evaluator depth. On March 3, 2026, Helicone announced acquisition by Mintlify; services remain live in maintenance mode. Verify roadmap depth directly.

Pricing. Hobby free with 10K requests, 1 GB, 1 seat. Pro $79/mo with unlimited seats. Team $799/mo with SOC 2 and HIPAA. Enterprise custom.

Verdict. Pick Helicone when gateway-first analytics and cost control are the dominant need. Pair with a dedicated eval platform (Future AGI, Braintrust) if eval depth becomes the constraint.

7. Datadog LLM Observability: best when Datadog is already the standard

Closed platform. SaaS only.

Quick take. Datadog LLM Observability is the right pick when the observability decision was made years ago and the team’s incident workflow already lives inside Datadog. Trace and eval surfaces extend the APM plane, not a new vendor.

Key strengths. Inherits Datadog’s SLA, RBAC, alerting, dashboard, and SIEM posture. LLM Observability extends APM with trace ingestion, span-level evals, prompt and response capture, and quality checks. SOC 2, HIPAA, FedRAMP postures inherited from the parent platform. Single-pane-of-glass for teams that already correlate LLM traces with infra metrics.

Honest limitations. Closed, hosted-only, no OSS self-host. Eval surface is shallower than Galileo Luna-2, Future AGI Turing, or Braintrust scorers; trajectory metrics are limited. No first-party gateway with guardrails on the request path. Per-host APM pricing is decoupled from LLM call volume — expect to re-evaluate when LLM traffic dominates infra spend. No prompt optimization, no simulation.

Pricing. Bundled into APM tier; LLM Observability is a per-host or per-trace add-on inside Datadog’s commercial plan. List pricing varies by contract.

Verdict. Pick Datadog LLM when Datadog is already the standard and adding another vendor creates more incident risk than it solves. Skip when the gap is eval depth, BYOK judges, runtime guardrails, or OSS control. See Datadog LLM alternatives.

Coverage matrix: which gap does each tool actually close?

Decision framework: choose X if

• Future AGI if Luna-2 per-eval cost is compounding, BYOK on the judge plane matters, and runtime guardrails belong on the gateway. Buying signal: Galileo online scoring is telling you something is wrong, but there is no automated path from a failing trace into a regression dataset, an optimized prompt, and a deploy gate that catches the same class next time.
• LangSmith if LangChain or LangGraph is the runtime and framework-native ergonomics matter more than OSS control.
• Langfuse if self-hosted observability with prompts and datasets is the entire requirement and Luna-2 cost is not yet the wall.
• Phoenix if OpenInference adherence and the Arize AX path are the buying signals, and gateway plus guardrails are not on the list.
• Braintrust if structured evals with a polished UI is the dominant problem and gateway, guardrails, and simulation are off the requirement list.
• Helicone if request analytics, provider routing, caching, and cost attribution are the immediate need.
• Datadog LLM if Datadog is already the standard and another vendor adds more incident risk than it solves.
• Stay on Galileo if Luna-2 at flat-rate online scoring is genuinely cheaper for your trace volume, the enterprise reference set matters in procurement, and the missing gateway and OSS posture are not blockers.

Self-host operational footprint

Common mistakes when picking a Galileo alternative

• Over-indexing on Luna-2 parity. If 1% of traffic is high-stakes, Luna-2 grade scoring on 100% of traces is overkill. Sample, then escalate. Span sampling, async judges, and retrieval-aware spot checks often cover the same ground for less.
• Treating OSS and self-hostable as the same. Phoenix is source-available under ELv2. Langfuse ships enterprise directories outside MIT. The license shows up in procurement before the feature comparison does.
• Picking by integration logos. Verify active maintenance for the framework version you actually use. LangChain v1, OpenAI Responses, Claude tool use, and OTel semantic conventions break observability quietly.
• Pricing only the subscription. Real cost equals platform price times trace volume, token volume, test-time compute, judge sampling rate, retry rate, storage retention, and annotation hours. A cheap plan loses if every online score calls an expensive judge.
• Assuming migration is just tracing. Datasets, scorer semantics, prompt version history, human review queues, and CI gates are the hard parts. If Galileo Insights or AutoTune is doing real work, plan how that capability gets rebuilt.

Recent platform updates

How to evaluate this for production

1. Run a domain reproduction. Export a representative slice of real traces (failures, long-tail prompts, tool calls, retrieval misses, hand-labeled outcomes). Instrument each candidate with your harness, OTel payload shape, prompt versions, and judge model. If Luna-2 parity is on your list, score the same traces with Luna-2, a frontier judge, and a self-hosted small judge behind a gateway. Compare agreement and cost. Do not accept a vendor demo dataset.
2. Measure reliability under load. Track p50, p95, p99 ingestion, dropped spans, duplicate spans, failed judge calls, retry count, query latency, and alert delay as concurrency rises. One week of representative traffic, not a 10-minute load test.
3. Cost-adjust. Real cost equals platform price times trace volume, token volume, test-time compute, judge sampling rate, retry rate, storage retention, and annotation hours. Price the subscription and the judge plane together. A cheap subscription with expensive judge calls is not a cheap plan.

Where Future AGI fits

Teams comparing Galileo alternatives end up running three or four tools in production: one for traces, one for evals, one for the gateway, one for guardrails. Future AGI is the recommended pick when the per-eval cost wall and the missing operational surface hit at the same time, and the result has to live on one Apache 2.0 plane: ai-evaluation for 50+ Turing-backed evaluators with error localization, traceAI for span-attached scores across 50+ AI surfaces in four languages, the Agent Command Center for 100+ providers and 18+ inline guardrails at ~29k req/s and P99 21 ms with guardrails on (t3.xlarge), and agent-opt to feed failing traces back into versioned prompts that a CI gate can enforce. SOC 2 Type II, HIPAA, GDPR, and CCPA per futureagi.com/trust; ISO 27001 in active audit. Start free with generous limits; usage-based after that. Pricing.

Sources

Future AGI pricing · Future AGI GitHub · traceAI · ai-evaluation · Agent Command Center docs · Galileo pricing · Galileo Luna · Galileo docs · Langfuse pricing · LangSmith pricing · Phoenix docs · Braintrust pricing · Helicone pricing

Read next

Future AGI vs Galileo for LLM evaluation · Langfuse Alternatives · Braintrust Alternatives · LangSmith Alternatives · Arize AI Alternatives · Datadog LLM Alternatives