[opensourcedex]

future-agi is a free, open source monitoring & observability project written in Python and released under Apache-2.0. It has 2,031 GitHub stars, 628 forks and 889 open issues, and was last pushed 9 hours ago. On this registry it ranks #83 of 97 tracked projects in Monitoring & Observability, with 5 head-to-head comparisons available. It gained 22 stars over the last 3 tracked days.

What is future-agi?

What it is

Future AGI is an open-source platform for evaluating, observing, and improving large language model and AI agent applications. It lives in the LLM operations ecosystem, where teams need tracing, evaluations, simulations, datasets, gateway routing, guardrails, and optimization in one Apache 2.0 project.

The concrete problem it addresses is fragmented production tooling for AI agents. Most AI agents fail in production, and teams often stitch together separate evaluation, observability, and guardrail systems that do not close the feedback loop. Future AGI is designed to let teams simulate edge cases before launch, evaluate production behavior, protect users in real time, and turn traces into signal for the next version.

Key capabilities

  • The platform provides OpenTelemetry-native tracing for large language model and AI agent applications, with 50+ framework instrumentors.
  • It includes evaluations, datasets, simulations, and optimization as parts of one lifecycle: simulate, evaluate, protect, monitor, and optimize.
  • It exposes a Go-based AI gateway with ~9.9 ns weighted routing, ~29 k req/s on t3.xlarge, and P99 ≤ 21 ms with guardrails on.
  • It supports Python and TypeScript instrumentation, including fi_instrumentation register and traceai_openai OpenAIInstrumentor, so existing OpenAI calls can be traced after registration.
  • It is self-hostable with an Apache 2.0 core, and the README states that every evaluator, prompt, and trace is inspectable rather than black-box scored.
  • It supports OpenTelemetry and OpenAI-compatible HTTP integration, allowing teams to drop in their own stack at selected layers.

Who uses it and how

  • Teams building AI agents use it to trace model calls, run evaluations, and collect production behavior as feedback for later versions.
  • Teams preparing an agent for launch use it to simulate edge cases before deployment and to protect users in real time with guardrails.
  • Teams that need data control use the self-hosted Docker stack, while teams that prefer a managed option use the free Cloud tier.
  • Engineering teams integrate it into existing Python or TypeScript services by registering a project and instrumenting an OpenAI-compatible client.

Getting started

The README describes a hosted Cloud option with no install and a free tier, plus pip install ai-evaluation for Python usage. For self-hosting, users clone https://github.com/future-agi/future-agi.git, run ./bin/install on macOS, Linux, or WSL, run .\bin\install.ps1 on Windows, and open http://localhost:3000.

When to use it — and when not to

Future AGI is useful when a team wants one open-source platform instead of combining tools such as Langfuse, Braintrust, Helicone, Guardrails AI, and a custom simulator. A self-hoster must operate Docker Desktop or Docker Engine with Docker Compose, generate secrets and pin image versions for production, and run property catalog backfill after upgrades that contain traces. The README marks the current release as nightly and warns that rough edges are expected, so teams needing a stable production package may wait for the stable version.

project readme (upstream, from github) — read inline

⚠️ Nightly release for early testing. Expect rough edges. Stable version coming out soon — please open an issue if you hit anything.

AI Agents hallucinate. Fix it faster.

The open-source platform for shipping self-improving AI agents. Evaluations, tracing, simulations, guardrails, gateway, optimization. Everything runs on one platform and one feedback loop, from first prototype to live deployment.

Apache 2.0 License PyPI npm Discord

Try Cloud (Free) · Self-Host · Docs · Blog · Discord · Discussions

Why Future AGI?

Most AI agents fail in production, and teams end up stitching together evals, observability, and guardrails that never close the loop. Future AGI collapses all of it into one platform and one feedback loop. Simulate edge cases before launch, evaluate what happens in production, protect users in real time, and turn every trace into signal for the next version. The result: agents that don't just get monitored, they self-improve.

All-in-one

No more stitching Langfuse + Braintrust + Helicone + Guardrails AI + a custom simulator. One platform covers the lifecycle: simulate → evaluate → protect → monitor → optimize, with data flowing back as a loop.

Open & self-hostable

Apache 2.0 core. Every evaluator, every prompt, every trace is inspectable — no black-box scoring. Self-host for data sovereignty or use our managed Cloud. Drop in your own stack at any layer via OTel / OpenAI-compatible HTTP.

Built for production

Go-based gateway with ~9.9 ns weighted routing, ~29 k req/s on t3.xlarge, P99 ≤ 21 ms with guardrails on. OpenTelemetry-native traces. 50+ framework instrumentors. Every claim reproducible via the committed benchmark harness.

🚀 Quickstart (60 seconds)

Two ways, depending on how much you want to install:

The self-host path requires Docker Desktop or Docker Engine with Docker Compose available before running the installer.

Cloud (fastest) Self-host (Docker)

No install. Free tier.

# Sign up free:
#   app.futureagi.com

pip install ai-evaluation

SOC 2 Type II · HIPAA · data stays in your region.

One command, full stack. Published images, no source build.

# 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

Open http://localhost:3000. For production, use ./deploy/setup.sh to generate required secrets and pin the image version.

When upgrading an installation that already contains traces, initialize any inactive unified property catalogs explicitly after the new stack is healthy:

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

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

Ordinary restarts never start a historical scan. The command uses the exact image already selected by Docker Compose (it does not pull a branch, source, or image), skips already-active workspaces, and resumes through the catalog's durable ledger. It is bounded to active workspaces and projects admitted by the self-hosted supervisor and to its rolling 366-day source window.

Instrument your first agent

Python

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

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 }],
});

Full docs → · Cookbooks → · API reference →

Core features

Six pillars. Each one replaces a tool you probably have.

🧪 Simulate

Thousands of multi-turn conversations against realistic personas, adversarial inputs, and edge cases. Text and voice (LiveKit, VAPI, Retell, Pipecat).

Docs →

📊 Evaluate

50+ metrics under one evaluate() call: groundedness, hallucination, tool-use correctness, PII, tone, custom rubrics. LLM-as-judge + heuristic + ML.

Docs →

🛡️ Protect

18 built-in scanners (PII, jailbreak, injection, …) + 15 vendor adapters (Lakera, Presidio, Llama Guard, …). Inline in gateway or standalone SDK.

Docs →

👁️ Monitor

OpenTelemetry-native tracing across 50+ frameworks (LangChain, LlamaIndex, CrewAI, DSPy…). Span graphs, latency, token cost, live dashboards. Zero-config.

Docs →

🎛️ Agent Command Center

OpenAI-compatible gateway. 100+ providers, 15 routing strategies, semantic caching, virtual keys, MCP, A2A. ~29k req/s, P99 ≤ 21ms with guardrails on.

readme truncated — read the full docs on github

Frequently asked questions

Is future-agi free to use?

future-agi is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does future-agi do?

Open-source, end-to-end platform for evaluating, observing, and improving LLM and AI agent applications. Tracing · Evals · Simulations · Datasets · Gateway · Gu

What is future-agi written in?

future-agi is primarily written in Python. Its source is publicly available at https://github.com/future-agi/future-agi, and it has 2,031 GitHub stars.