TL;DR

Future AGI is an Apache-2.0 platform that tries to replace four or five separate LLMOps tools at once: tracing, evaluation, guardrails, an LLM gateway, agent simulation, and prompt optimization — all self-hostable, all in one Docker Compose stack.

  • Repo: future-agi/future-agi — 1,944 stars, 583 forks, Python, Apache 2.0, created April 23, 2026.
  • Activity: genuinely busy. ~4,849 commits in 52 weeks, 66 contributors, 1,690 merged PRs, and v1.35.0 shipped September 4, 2026.
  • The pitch in one line: stop stitching Langfuse + Braintrust + Helicone + Guardrails AI together and run one feedback loop instead.
  • The catch: the README itself opens with a nightly-release warning — “Expect rough edges.” There are 294 open issues, no official Kubernetes/Helm support yet, and the self-hosted build phones home with admin email addresses unless you opt out.
  • Verdict: the most ambitious open-source LLMOps scope I’ve reviewed this year, and the least settled. Great for a team that wants one stack and can tolerate churn. Wrong choice if you just need a span viewer.

Quick Reference

ItemDetail
Repogithub.com/future-agi/future-agi
LicenseApache License 2.0
Latest releasev1.35.0 (September 4, 2026)
LanguagePython (Django 5.1) + Go 1.23 gateway + React 18
DatastoresPostgreSQL, ClickHouse, Redis, RabbitMQ + Temporal
Installgit clone + ./bin/install (Docker Compose)
Local UIhttp://localhost:3000
Python SDKpip install ai-evaluation
TS SDKnpm i @traceai/fi-core
Managed optionCloud free tier at app.futureagi.com

What Future AGI Actually Is

Most LLM observability tools pick a lane. Langfuse is tracing plus prompt management. Phoenix is an OpenTelemetry span viewer with evals bolted on. Helicone is a proxy that happens to log. Guardrails AI does input/output validation and nothing else.

Future AGI’s bet is that those lanes are artificial — that the interesting product is the loop between them. Production traces should become eval datasets. Eval failures should become simulation scenarios. Simulation results should feed a prompt optimizer. The optimizer’s output should go back out through the gateway.

That’s a real architectural argument, and it’s the reason this repo is worth looking at even if you don’t deploy it. Whether the loop actually closes in practice is the open question, and I’ll get to that.

The system ships as six pillars:

PillarWhat it doesReplaces
SimulateMulti-turn conversations against generated personas, adversarial inputs, edge cases. Text and voice (LiveKit, VAPI, Retell, Pipecat).Custom simulator scripts
Evaluate50+ metrics behind one evaluate() call — groundedness, hallucination, tool-use correctness, PII, tone, custom rubrics. LLM-as-judge + heuristic + ML.Braintrust, Ragas
Protect18 built-in scanners (PII, jailbreak, injection) plus 15 vendor adapters (Lakera, Presidio, Llama Guard).Guardrails AI
ObserveOpenTelemetry-native tracing across 50+ frameworks. Span graphs, latency, token cost.Langfuse, Phoenix
GatewayOpenAI-compatible Go proxy. 100+ providers, 15 routing strategies, semantic caching, virtual keys, MCP, A2A.Helicone, LiteLLM, Portkey
OptimizeSix prompt-optimization algorithms: GEPA, PromptWizard, ProTeGi, Bayesian, Meta-Prompt, Random.Nothing mainstream

The last row is the genuinely differentiated one. Agent simulation and automated prompt optimization are not standard features in this category — Langfuse, Phoenix, Braintrust, and Helicone don’t ship either.

Getting It Running

Self-hosting needs Docker Desktop or Docker Engine with Compose available first. Then it’s one command:

# macOS / Linux / WSL
git clone https://github.com/future-agi/future-agi.git
cd future-agi
./bin/install
# Windows PowerShell
git clone https://github.com/future-agi/future-agi.git
cd future-agi
.\bin\install.ps1

The installer pulls published images rather than building from source, which keeps first-run time reasonable. The UI comes up at http://localhost:3000.

For anything beyond a laptop trial, use the production path instead — it generates secrets and pins image tags rather than tracking latest:

./deploy/setup.sh

Pinning matters more than usual here. At the current release cadence — five releases in the first four days of September — an unpinned latest is a moving target under your production traffic.

One upgrade gotcha worth knowing before you hit it. If you’re upgrading an install that already holds traces, you need to explicitly initialize inactive property catalogs after the new stack is healthy:

# macOS / Linux / WSL
./bin/property-catalog-backfill --execute

# Windows PowerShell
.\bin\property-catalog-backfill.ps1 -Execute

To the project’s credit, ordinary restarts never trigger a historical scan, the command reuses the image Compose already selected, it skips already-active workspaces, and it resumes through a durable ledger. That’s a carefully-built migration path, not an afterthought.

Instrumenting Your App

This is the part that will decide whether you adopt it, and it’s genuinely low-friction. Tracing is two lines before your existing code — no call-site rewrites:

from fi_instrumentation import register
from traceai_openai import OpenAIInstrumentor

register(project_name="my-agent")
OpenAIInstrumentor().instrument()

# Your existing OpenAI code is now traced.
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": query}],
)

TypeScript is the same shape:

import { register } from "@traceai/fi-core";
import { OpenAIInstrumentation } from "@traceai/openai";

register({ projectName: "my-agent" });
new OpenAIInstrumentation().instrument();

// Your existing OpenAI code is now traced.
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: query }],
});

Because instrumentation is OpenTelemetry-native, the lock-in risk on the tracing layer specifically is low. Your spans are OTLP. If Future AGI doesn’t work out, you point the exporter somewhere else. The SDKs are also split into independently packaged, independently usable repos — traceAI for instrumentation, ai-evaluation for metrics, agent-opt for optimization, agent-simulate for voice simulation. You can adopt one piece without the platform, which is a materially better deal than an all-or-nothing install.

Framework coverage is broad: LangChain, LangGraph, LlamaIndex, CrewAI, AutoGen, PydanticAI, DSPy, Haystack, Instructor, LiteLLM, plus 100+ model providers including self-hosted Ollama, vLLM, and LM Studio.

The Gateway and Its Benchmarks

The Agent Command Center is a Go gateway claiming ~29,000 req/s on a t3.xlarge, P99 ≤ 21 ms with guardrails enabled, and ~9.9 ns weighted routing overhead.

Those numbers are plausible for a Go proxy doing header-level routing, and the project publishes a committed benchmark harness so you can reproduce them. That’s better practice than most vendors manage — a reproducible harness beats a marketing chart.

Two caveats. First, these are vendor-run benchmarks on vendor-chosen hardware; a t3.xlarge is a modest instance, so the throughput figure is more impressive than the box, but your routing rules and guardrail scanner mix will move P99 substantially. Second, guardrail latency is highly dependent on which scanners you enable — an ML-based jailbreak classifier is not the same cost as a regex PII match. Run the harness on your own config before quoting the P99 anywhere it matters.

How It Compares

The README ships a comparison table against Langfuse, Phoenix, Braintrust, and Helicone. It’s vendor-authored — Future AGI wrote a table in which Future AGI wins — and it’s dated “as of April 2026,” which is five months stale in a category that ships weekly. Treat it as a feature checklist to verify, not as a finding.

Here’s the number the table omits, and it’s the one that matters most for an infrastructure dependency:

ProjectStarsLicenseLanguage
Langfuse34,286(custom/MIT core)TypeScript
Arize Phoenix11,354(custom)Python
Helicone6,134Apache 2.0TypeScript
Future AGI1,944Apache 2.0Python

Future AGI has roughly 6% of Langfuse’s community. For a tool you’re putting in the request path of a production agent, ecosystem size is a real input: Stack Overflow answers, third-party integrations, battle-tested edge cases, and the odds the project is still maintained in three years all scale with it.

Where Future AGI legitimately leads is breadth under one license. Braintrust is not open source in the way the others are. Helicone and Langfuse have no simulation or optimization layer. Phoenix has no gateway. If you actually want all six pillars self-hosted under Apache 2.0, this is currently the only option — the comparison isn’t rigged so much as it’s asking a question only one product answers.

The honest framing: Future AGI competes on scope, not on maturity.

Honest Limitations

It calls itself a nightly. The README’s first line is a warning that this is an early-testing release with rough edges and a stable version “coming out soon.” Believe it.

The stack is heavy. PostgreSQL and ClickHouse and Redis and RabbitMQ and Temporal, fronting Django, a Go service, and a React app. That’s six stateful components before you’ve traced a single span. Langfuse self-hosts on Postgres and ClickHouse. If you’re a small team without platform engineering capacity, this is a real operational tax — and Temporal in particular is not a casual dependency.

No Kubernetes or Helm yet. Docker Compose on a VM is the supported production path today; official manifests and Helm charts are listed as coming soon. For orgs that deploy exclusively via Helm, that’s a hard blocker right now.

Default telemetry collects admin email addresses. On first boot the self-hosted instance registers instance ID, version, deployment type, and the email addresses and domains of active admin users, then sends periodic anonymous usage heartbeats. You can set FUTURE_AGI_TELEMETRY_DISABLED=1 to opt out — but even disabled, it still sends one minimal census ping (instance ID, version, deployment type, no emails). The project documents this clearly and says no traces, prompts, or API keys are ever sent, which is the right disclosure. It’s still a surprising default for a tool marketed on data sovereignty, and if you’re self-hosting for compliance reasons, set that variable in your .env on day one:

# .env (or deploy/.env.production for the production overlay)
FUTURE_AGI_TELEMETRY_DISABLED=1

294 open issues against a repo that’s under five months old. High velocity cuts both ways.

The open-source/cloud boundary needs watching. The commercial product is the same brand, and the repo is where the free tier funnel lives. Nothing about the Apache 2.0 grant is ambiguous today, but “open core drifts” is the default outcome in this category — Braintrust and Phoenix both carry non-standard licenses for a reason.

Who Should Use It

Use Future AGI if: you’re building agents where correctness is the hard problem, not throughput — RAG with citation verification, voice agents, customer support, computer-use agents. You want evals, guardrails, and simulation under one roof, you have the ops capacity for a six-service stack, and you’re comfortable pinning versions and reading changelogs.

Skip it if: you want a span viewer (use Phoenix), you want the largest ecosystem and the safest bet (use Langfuse), you have one LLM call per request and want zero friction (use Helicone), or you need Helm charts today.

Middle path, and the one I’d actually recommend for most teams: adopt traceAI or ai-evaluation standalone. They’re separately packaged, OTel-native, and Apache/MIT licensed. You get the evaluation depth without betting your infrastructure on a four-month-old platform, and you can graduate to the full stack later if the loop proves out.

FAQ

Is Future AGI actually open source, or open core? The repo is Apache 2.0, including the evaluators, the gateway, and the simulation engine — genuinely permissive, not source-available. A managed cloud exists alongside it with SOC 2 Type II and HIPAA claims. As of September 2026 there’s no visible feature gating in the OSS build, but as with any commercially-backed project, verify the license on the specific components you depend on before you commit.

Can I self-host it fully air-gapped? Yes. The docs list air-gapped/on-prem as supported with no phone-home. Set FUTURE_AGI_TELEMETRY_DISABLED=1, and block egress at the edge if you need full silence — the census ping still fires once otherwise.

How does it compare to Langfuse for pure tracing? Langfuse is more mature, has ~17x the community, and is lighter to operate. If tracing and prompt management are all you need, Langfuse is the better tool. Future AGI’s advantage only materializes when you also want evals, guardrails, gateway, and simulation in the same system.

Do I have to use the gateway to get tracing? No. The instrumentation SDKs work independently — register() plus an instrumentor traces your existing client calls with no proxy in the path. The gateway is optional and separately useful if you want provider routing and semantic caching.

What are GEPA and ProTeGi? They’re published prompt-optimization algorithms. Future AGI’s agent-opt package implements six of them (GEPA, PromptWizard, ProTeGi, Bayesian, Meta-Prompt, Random), using production traces as training data. This is the most experimental pillar — treat automated prompt rewriting as something to evaluate carefully, not enable blindly against a live agent.

Is it production-ready? The project says stable is “coming soon” and labels current builds nightly. Real teams are clearly running it — the release cadence and closed-PR count suggest active production users — but I would not put a four-month-old, self-declared-nightly platform in the synchronous request path of a critical system without pinned images, a rollback plan, and a load test of your own.

Sources

Star counts, issue counts, and release dates were pulled from the GitHub API on September 7, 2026 and will drift.