⚠�� 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.

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

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.

Run the whole platform on your own machine in three steps. Rather not run anything? Try Cloud free.

You need Docker Desktop or Docker Engine with Compose v2.24 or newer, and for the default Standalone setup 2 vCPUs and 4 GB of memory given to Docker.

1. Install

git clone https://github.com/future-agi/future-agi.git
cd future-agi
./bin/install          # Windows (PowerShell): .\bin\install.ps1

The installer checks your machine, writes this install's secrets to .env, downloads the images (about 800 MB) and waits until everything answers. The first boot sets up the database and takes a few minutes; http://localhost:3000 shows its progress meanwhile.

2. Sign in and copy your keys

Open http://localhost:3000, create your account (or sign in with the one the installer made), then copy the API key and secret key from Keys in the sidebar.

3. Send your first trace

pip install fi-instrumentation-otel
export FI_API_KEY="<your API key>" FI_SECRET_KEY="<your secret key>" FI_BASE_URL="http://localhost:4318"

from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType

tracer_provider = register(project_name="my-first-project", project_type=ProjectType.OBSERVE)
with tracer_provider.get_tracer("quickstart").start_as_current_span("hello-future-agi") as span:
    span.set_attribute("input.value", "Hello, Future AGI")
tracer_provider.force_flush()

Open Tracing in the sidebar: my-first-project holds your first span. http://localhost:4318 is this install's trace collector; it listens on this machine only.

Choose before you add data: there is no supported way to move a Standalone install's data to Distributed or Helm later (Switching).

• Configure: every variable in .env is described in the configuration reference. Nothing is required for a local install; add LLM provider keys, a public URL or email when you need them.
• Manage: docker compose logs -f app (Distributed: backend); stop with docker compose down or ./bin/uninstall (both keep your data); upgrade with git pull && ./bin/install; remove everything, data included, with ./bin/uninstall --purge.
• Develop: on a branch other than main, add --from-source to build the images from your checkout; ./bin/dev runs it with hot reload (Local development).
• More: the self-hosting guide, INSTALLATION.md (every option and troubleshooting) and deploy/README.md (production).

Swap the hand-made span for an instrumentor to trace a real app, here OpenAI (pip install traceai-openai). Against your own install, keep the FI_* variables from step 3 set.

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

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 →}

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

Every image, tag and size: Container images. Every setting: Configuration reference.

Every arrow is an open, documented interface: OpenTelemetry OTLP for traces, OpenAI-compatible HTTP for the gateway, Postgres / ClickHouse SQL for storage. Drop in your own stack at any layer.

Runtime: Python 3.11+ (Django 5.1 + Channels) · Go 1.25+ (gateway), 1.24+ (trace collector) · React 18 + Vite · Node 22.18+. Data: PostgreSQL (metadata) · ClickHouse (spans + time-series) · Redis (state, live updates) · Temporal (jobs).

Future AGI is an open-source ecosystem — each SDK is independently usable, independently packaged, Apache/MIT-licensed.

_{Full integrations catalog →}

_{Based on publicly-documented features as of April 2026. Corrections welcome — open a PR.}

• Customer Support: Ship support AI that customers actually trust
• Voice Agents: Test, evaluate, and improve voice AI end-to-end
• Internal Tools: AI copilots your whole org can rely on
• RAG & Search: Every answer grounded, every citation verified
• Autonomous Agents: Multi-step agents you can actually trust in production
• Computer-Use Agents (CUA): Agents that click with confidence
• Coding Agents: AI that writes code you can actually ship

Vote on the public roadmap → · GitHub Discussions · Releases · Changelog

We love contributions — bug fixes, new evaluators, framework integrations, docs, examples, anything.

1. Browse good first issue
2. Read the Contributing Guide
3. Say hi on Discord or Discussions
4. Sign the CLA on your first PR (automatic bot)

Self-hosted Future AGI sends deployment telemetry, on by default, so we can count installs and size release testing: one registration with the email addresses and email domains of the install's owner, admin and staff/superuser accounts, then usage counts on a schedule. No trace data, no prompts, no completions, no datasets, no API keys, ever.

To opt out, install with ./bin/install --no-telemetry, or set FUTURE_AGI_TELEMETRY_DISABLED=true in .env (deploy/.env.production for the production overlay, config.telemetry=false for Helm) and run docker compose up -d. Opting out still sends one registration, without email addresses; block api.futureagi.com to send nothing. Everything else that could leave your install (HubSpot, Slack, Mixpanel, PostHog, reCAPTCHA, Sentry, Mailgun) is off until you set its key.

Telemetry and outbound connections has the exact payloads, what the opt-out still sends, every setting, and every outbound connection, with what an install that allows no outbound traffic must also set.

Future AGI is licensed under the Apache License 2.0. See LICENSE and NOTICE.

You own your evaluation logic and your data. Inspect every evaluator, every prompt, every trace — no black-box scoring, no vendor lock-in.