Future AGI: One Apache 2.0 Platform That Replaces Your Whole AI Agent Stack
Editorial note: Star, fork, and version counts in this article are snapshots as of April 26, 2026 and will move as the project ships. All install steps, gateway benchmarks, and architectural claims are drawn from the public Future AGI repository; verify against the latest README before deploying anything to your own infrastructure. The repository explicitly warns this is a nightly release for early testing, and we treat it as one.
By Harry Richter, Marketing Technology Analyst — covering self-hosted AI infrastructure and open-source agent tooling. Previous reviews on this site include Stash, the Postgres-backed MCP memory layer, and Optimeleon, the AI CRO tool.
Most coverage of LLM observability in 2026 reads off the same script. Langfuse is good for tracing. Braintrust is good for evals. Helicone is good as a gateway. Guardrails AI is good for protection. Each comparison piece picks two or three of those tools, sets them next to each other, and stops at the boundary of its own category. What gets quietly skipped is the experience of actually running all four at once in production: four dashboards, four data schemas, no shared trace ID, no auto-promotion of a failing prod span into a regression test, and a janky integration between a guardrail block and the prompt that should be iterated on next.
This post walks through Future AGI, a brand-new, Apache 2.0, open-source platform that landed on GitHub on April 23, 2026 and claims to collapse all of that into one self-hostable deployment. We cover what it actually is, what it replaces in your stack, the install path, the gateway numbers, where it sits after January's ClickHouse–Langfuse acquisition, and where it is honestly not ready yet.
TL;DR: Future AGI (github.com/future-agi/future-agi, Apache 2.0, launched April 23, 2026) is the first open-source platform to bundle the six tools an AI-agent team usually stitches together — tracing, evaluation, simulation, guardrails, an OpenAI-compatible gateway, and prompt optimization — into a single self-hostable deployment. Its Go-based gateway claims roughly 29k req/s on a t3.xlarge with P99 at or below 21 ms with guardrails on, and the entire stack is OpenTelemetry-native. The catch: it is a nightly release for early testing, with 484 stars and 73 forks at the time of this review, so production teams should pilot before they migrate.
What Is Future AGI, and Who Built It?
Future AGI is an open-source platform from the team behind futureagi.com that bundles six AI-agent tools into one self-hostable deployment: Simulate (multi-turn personas, including voice), Evaluate (metrics under one evaluate() call), Protect (built-in scanners plus vendor adapters), Monitor (OpenTelemetry tracing across major frameworks), Agent Command Center (an OpenAI-compatible gateway with multi-provider routing), and Optimize (prompt-optimization algorithms). The public GitHub repository future-agi/future-agi was created on April 23, 2026 and reached 484 stars, 73 forks, and 26 open issues within its first three days. The license is Apache 2.0 and the SDKs ship as ai-evaluation on PyPI and @traceai/fi-core on npm. (Source: Future AGI repository, README.)
The team already runs a managed product at app.futureagi.com with SOC 2 Type II and HIPAA on the cloud tier, and the new repository is the open-core, self-host-first version of that same platform. The README is unusually direct about its current state, opening with a banner that reads "Nightly release for early testing. Expect rough edges. Stable version coming out soon." That honesty is worth taking seriously: this is a product being built in the open, not a launch announcement dressed up as a v1.
The structural framing in the README is also worth pausing on. Most of the project's competitors describe themselves by category — "an LLM observability platform," "an evaluation framework," "a guardrails toolkit." Future AGI describes itself by loop: "simulate → evaluate → protect → monitor → optimize," with the explicit claim that the data from each stage feeds back into the others. That single feedback-loop framing is the entire bet, and it is what the rest of this review is really evaluating.
What Does Future AGI Actually Replace in Your Stack?
The platform's pitch is that one deployment replaces a stack of four to six tools that AI-agent teams typically run separately: Langfuse or Arize Phoenix for tracing, Braintrust or DeepEval for evaluations, Helicone or Portkey for the LLM gateway, Guardrails AI or NVIDIA NeMo Guardrails for protection, plus an in-house simulator and an in-house prompt-optimization loop. Every layer talks OpenTelemetry OTLP for traces and OpenAI-compatible HTTP for the gateway, so you can swap individual pieces in or out without changing instrumentation. (Source: Future AGI repository, README.)
The structural argument matters more than the feature checklist. When evals, traces, simulations, and guardrails live in different tools, each one's data is unusable as input to the others. You cannot auto-promote a failed production trace into a regression dataset. You cannot feed a guardrail block back into a prompt-optimization run. You cannot replay a simulator conversation through your live evaluators without writing glue code. Future AGI's defining bet is that closing that loop in one schema is worth more than picking the best individual tool at each layer. That is genuinely contrarian in 2026, because the rest of the market has spent two years arguing the opposite.
The Six Pillars: What Each One Absorbs
The README enumerates six pillars and the third-party tool each one is designed to displace. Simulate runs thousands of multi-turn conversations against realistic personas and adversarial inputs, with text and voice support via LiveKit, VAPI, Retell, and Pipecat — replacing in-house testing rigs that most teams write by hand. Evaluate exposes 50+ metrics under one evaluate() call covering groundedness, hallucination, tool-use correctness, PII, tone, and custom rubrics, mixing LLM-as-judge with heuristic and ML scorers. Protect ships 18 built-in scanners (PII, jailbreak, prompt injection, and more) plus 15 vendor adapters for Lakera, Presidio, Llama Guard, and others, and runs inline in the gateway or as a standalone SDK.
Monitor is the OpenTelemetry-native tracing layer with 50+ framework instrumentors (LangChain, LlamaIndex, CrewAI, DSPy, and more), surfacing span graphs, latency, token cost, and live dashboards with no per-framework configuration. Agent Command Center is the OpenAI-compatible gateway with 100+ providers, 15 routing strategies, semantic caching, virtual keys, and MCP and A2A support — the layer most teams currently fill with LiteLLM Proxy or Helicone. Optimize bundles six prompt-optimization algorithms (GEPA, PromptWizard, ProTeGi, Bayesian, Meta-Prompt, Random) and treats production traces as training data so a failing prod call becomes the input to the next prompt iteration. (Source: Future AGI repository, README.)
The Agent Command Center: Concrete, Reproducible Numbers
The Agent Command Center deserves a separate note because the published numbers are unusually concrete. The Go-based gateway reports roughly 9.9 nanosecond weighted routing decisions, near 29,000 RPS on a t3.xlarge, and a P99 latency at or below 21 milliseconds with guardrails enabled. Every claim is reproducible from the benchmark harness committed to the repo at futureagi/agentcc-gateway. That overhead floor is well under most teams' tolerance for inline guardrail enforcement, which has historically been the reason guardrails ran out-of-band as a separate service hop.
How Fast Can You Self-Host Future AGI?
Self-hosting is a one-command Docker Compose deploy. Clone the repository, copy futureagi/.env.example to futureagi/.env, run docker compose up -d, and open the dashboard at http://localhost:3031. Kubernetes deploys today via plain manifests in deploy/; the Helm chart is in progress. Air-gapped and on-prem deploys are supported with no phone-home. Under the hood, the stack brings up Postgres, ClickHouse, Redis, and RabbitMQ — heavier than a single-purpose tool's footprint, but the price of bundling six pillars in one place.
git clone https://github.com/future-agi/future-agi.git
cd future-agi
cp futureagi/.env.example futureagi/.env
docker compose up -d
# Dashboard at http://localhost:3031Instrumenting your first agent on the Python side is genuinely shorter than the equivalent in Langfuse — two lines of registration plus an instrumentor for whichever client SDK you already use. The instrumentor is OpenTelemetry under the hood, so any existing OTel collector configuration on your platform team's side will work without changes:
from fi_instrumentation import register
from traceai_openai import OpenAIInstrumentor
register(project_name="my-agent")
OpenAIInstrumentor().instrument()
# Existing OpenAI calls are now traced.
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": query}],
)An evaluate() call against any of the platform's metrics is similarly compact. The same SDK exposes the eval surface as the instrumentation surface, so you do not learn two libraries to do tracing and grading on the same span:
from ai_evaluation import evaluate
result = evaluate(
metric="groundedness",
inputs={"question": query, "answer": response.choices[0].message.content},
context={"source_document": doc_text},
)
print(result.score, result.explanation)Hitting the Agent Command Center gateway from any OpenAI-compatible client is a configuration change, not a code change. Point the SDK's base_url at the local gateway, supply a virtual key the dashboard issued, and the platform handles routing across providers, semantic caching, and inline Protect scanners on every call:
curl http://localhost:3031/v1/chat/completions \
-H "Authorization: Bearer $FAGI_VIRTUAL_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"gpt-4o","messages":[{"role":"user","content":"hello"}]}'First-time install friction will vary. The most likely sticking points are port 3031 conflicting with another local dashboard, an env var gap that surfaces only after the first docker compose logs -f, and the OTel instrumentor needing a process restart (not just a hot reload) to pick up the OpenAI client cleanly. (For a different take on getting AI tooling to do real work in a real workflow, see our review of Stash, the self-hosted memory layer, and our coverage of Claude in stateful workflows.)
Where Does Future AGI Sit After the ClickHouse–Langfuse Deal?
The market context for this launch is unusually loaded. ClickHouse acquired Langfuse on January 16, 2026, with the announcement noting that Langfuse ended 2025 with more than 20,000 GitHub stars and over 26 million SDK installs per month, and that the company served more than 2,000 paying customers including 19 of the Fortune 50 and 63 of the Fortune 500. ClickHouse simultaneously raised a $400M Series D led by Dragoneer at a $15B valuation, framing the deal as an entry into the market for monitoring non-deterministic AI systems. (Source: ClickHouse, "ClickHouse welcomes Langfuse".)
The acquisition pushed every other open-source player in the category into one of two responses: get acquired, or differentiate hard. Differentiating on tracing alone is now structurally difficult — you are competing with a tool that has 26 million monthly SDK installs and a $15B-valued ClickHouse-backed roadmap behind it. Differentiating on the bundle, on the other hand, is wide open. No one else in the open-source quadrant covers tracing, evals, simulations, guardrails, gateway, and prompt optimization in one Apache-2.0 deployment. That is the lane Future AGI has chosen to compete in, and the timing of the launch (three months after the acquisition closed) is unlikely to be coincidence.
| Project | License | OTel-native | Pillars covered | Position |
|---|---|---|---|---|
| Future AGI | Apache 2.0 | Yes (every layer) | Trace · Eval · Sim · Protect · Gateway · Optimize | All-in-one bundle |
| Langfuse (post-ClickHouse) | MIT | Yes | Trace · Eval · Prompts | Tracing-first specialist |
| Arize Phoenix | Source-available | Yes | Trace · Eval · Datasets | Tracing + RAG eval |
| Helicone | Apache 2.0 (core) | Partial | Gateway · Light observability | Gateway-first |
| Braintrust | Closed-core, self-host option | No | Eval · Datasets | Eval-first |
| NeMo Guardrails | Apache 2.0 | No | Protect | Protection-only |
The honest read of that table is that Future AGI is not really a Langfuse competitor in the head-to-head sense. Langfuse, post-ClickHouse, is now the safe enterprise default for tracing — backed by a $15B-valued company with millions of monthly installs and a thousand-plus paying customers. Future AGI is the bet that you would rather have one schema and one feedback loop than the safest specialist at every layer. Those are different products for different buyers, and the "X versus Y" framing flattens the actual choice.
Trade-offs and When to Pilot vs. Wait
Future AGI is young in a way the README is up-front about. The public repository is three days old at the time of this review. There is no stable v1 tag yet — the maintainers describe one as "coming out soon." There is no third-party validation of the gateway benchmark numbers; the harness is committed to the repo and reproducible, but no one outside the team has yet posted independent results on a fresh t3.xlarge. The Helm chart for production-grade Kubernetes deploys is in progress rather than shipped, so a Kubernetes install today means working with the plain manifests in deploy/. And the operational footprint is real: Postgres plus ClickHouse plus Redis plus RabbitMQ is four backing services to keep alive, versus the leanest Langfuse self-host's one.
Star count is the bluntest maturity comparison and worth stating plainly. Future AGI sits at 484 GitHub stars three days into its public life; Langfuse closed 2025 above 20,000 stars with 26 million monthly SDK installs and over 2,000 paying customers. (Source: ClickHouse, "ClickHouse welcomes Langfuse".) The architectural ambition is bigger; the production mileage is not yet there. Treat this as a bet on the next two years, not on next week.
The pilot rule of thumb that falls out of all of the above: pilot now if you are already paying for two or more of {Langfuse, Braintrust, Helicone, Guardrails AI} and the operational cost of stitching them is real, or if you are greenfield with a strong data-residency constraint that rules out cloud-managed options. Wait for the v1 stable tag and at least one independent benchmark of the gateway numbers before you migrate a workload that has an SLA attached to it. Three days of public repository history, however well-architected, is not enough mileage to bet a SOC 2 audit on. (For a parallel bet on a brand-new self-hosted infrastructure project, also from April 2026, our companion piece on an open-source text-to-CAD harness covers similar pilot-versus-wait trade-offs.)
Frequently Asked Questions
What is Future AGI?
Future AGI is an open-source, Apache 2.0 platform from the team behind futureagi.com that bundles six AI-agent tools — tracing, evaluations, simulations, guardrails, an OpenAI-compatible gateway, and prompt optimization — into one self-hostable deployment. The public repository at github.com/future-agi/future-agi went live on April 23, 2026 and reached 484 stars in its first three days.
Is Future AGI a Langfuse alternative?
Yes, but with an important caveat: the two are not really head-to-head. Future AGI overlaps with Langfuse on tracing and evals, but it also bundles a Go-based gateway, a guardrails layer with eighteen scanners, a multi-turn simulator, and a prompt-optimization loop in the same deployment. The honest framing is all-in-one platform versus tracing-first specialist — different products for different buyers.
Is Future AGI production-ready in April 2026?
Not yet, and the project says so itself. The repository carries a "Nightly release for early testing. Expect rough edges" banner, and the maintainers describe the stable release as "coming out soon." The right move today is piloting on a non-critical agent. Wait for the v1 tag and at least one independent benchmark of the gateway before staking a production SLA on it.
What does the Agent Command Center gateway do that LiteLLM does not?
Both are OpenAI-compatible gateways with multi-provider routing. What sets the Agent Command Center apart in its published spec is inline guardrail enforcement with P99 at or below 21 ms, semantic caching, virtual keys for per-team budgets, and a benchmarked ~29k RPS on a t3.xlarge with the harness committed to the repo for anyone to reproduce.
The Verdict
Future AGI is the cleanest all-in-one open-source bet in the AI-agent reliability category as of April 2026. Its differentiator is closing the simulate → evaluate → protect → monitor → optimize loop in one Apache-2.0, self-hostable schema — something a stitched stack of Langfuse plus Braintrust plus Helicone plus Guardrails AI structurally cannot do. The gateway numbers are concrete and reproducible, the OpenTelemetry-native design means you can swap any individual layer in or out, and the timing of the launch (three months after the ClickHouse–Langfuse deal closed) is well placed to absorb the part of the market that does not want to commit to a single specialist for the next decade.
The maturity caveats are equally honest. Three days of public history, no stable tag, no independent benchmark validation, and four backing services to keep alive. If the architectural bet pays off, this is the project to watch in the second half of 2026; if you need production mileage today, it is a pilot, not a migration. Clone the repository, run docker compose up -d, instrument one non-critical agent (we have written about running real agentic workflows in production elsewhere on this site), and run a single eval and a single Protect scanner end-to-end — and if you do, share what broke, because the field needs first-hand install reports far more than it needs another README paraphrase.
Member discussion