Here's a concise, professional technical briefing for the future-agi repository, written in the style of a senior AI engineer consultant report. All facts are drawn directly from the provided analysis blocks; no invented commands or fluff.

The Problem

Teams building AI agents today must stitch together separate tools for tracing, evaluation, simulation, and guardrails. The result is fragmented observability, no closed feedback loop, and agents that fail in production without a path to self-improvement. This repo consolidates all of that into one self-hostable platform.

What This Does

Future AGI is a full-stack Python/Django + React application (7,860 files) that provides an end-to-end pipeline for LLM/agent evaluation, tracing, simulation, and guardrails. The codebase is split between frontend/ (React/JSX, 4,278 files) and futureagi/ (Python, 3,546 files). It uses Django on the backend, LangChain, vector stores, and Docker for deployment. The platform exposes a React dashboard for managing experiments, running evals, simulating agent conversations, and inspecting gateways/guardrails.

Key structural splits:

  • frontend/ – React UI, hooks, routes, and API integration
  • futureagi/ – Python backend: model serving, agent gateway, guardrails, and core logic

How It Is Wired

Execution starts at the React entry points: frontend/index.html and frontend/src/TreeView/index.js. The internal call graph is small but focused: 25 resolved call edges between self-contained functions. The most impactful hubs are:

  • useParams – called from 5 places; defines query-param routing across experiment/eval/detail pages
  • useDeploymentMode – called from 2 places; gates which API/backend is active
  • frontendBin – the central bundler referenced from frontend/src/**/*.{js,jsx,ts,tsx} and frontend/src/**/*.{json,css,md} (x2 each)

Representative call edges:

  • frontend/src/**/*.{js,jsx,ts,tsx} → frontendBin x2
  • CustomStatusBar → getComponent x2
  • ErrorFeed → useDeploymentMode
  • DatasetDetail → useParams
  • OptimizeDetail → useParams, useGetOptimization
  • EvalsInside → useParams
  • UsageSummary → useDeploymentMode

The single outbound network call is made by a function in futureagi/agentcc-gateway/ (guardrails/gateway integration). No other external calls are resolved from this repo’s own code.

File responsibilities (by call volume, not size):

  • frontend/src/routes/hooks/use-params.js – 1 function, called from 5 files. Defines useParams.
  • frontend/src/hooks/useDeploymentMode.js – 1 function, called from 2 files. Defines useDeploymentMode.
  • frontend/src/api/model/optimize.js – 1 function, called from 1 file. Defines useGetOptimization.
  • frontend/src/hooks/use-in-view.js – 1 function, called from 1 file.
  • frontend/src/sections/experiment-detail/experiment-context.js – 1 function, called from 1 file.
  • frontend/src/components/table/utils.js – 4 functions: emptyRows, descendingComparator, getComparator, isCellValueEmpty.
  • frontend/src/components/animate/variants/transition.js – 3 functions: varTranHover, varTranEnter, varTranExit.
  • frontend/src/hooks/use-system-theme-mode.js – 3 functions: getSystemMode, useSystemThemeMode, handler.

Named symbols: 421 functions, 0 classes. Examples: frontendBin, NodeIcon, useDeleteCompare, useExperimentDerivedVariables, useGetExperimentJSONSchema, useOverviewData, useApiKeysStatus, useGetOptimization, useModelPerformance, useGetProjectById, useCreateReplaySessions, useGetTraceDetail, useGetPromptLabels, AuthConsumer, useCallLogsSearchStoreShallow, LeftSection.

How To Use It

Setup (inferred from present files):

  • Docker: docker-compose.yml, docker-compose.dev.yml, docker-compose.frontend.yml are present. The frontend/Dockerfile uses node:20.17 and nginx:alpine (mutable tags — see Issues).
  • Python: futureagi/model_serving/pyproject.toml and futureagi/agentcc-gateway/go.mod indicate Python packaging and a Go gateway.
  • Package manager: yarn (lockfiles present: frontend/package-lock.json, frontend/yarn.lock).

Configuration: Environment variables are defined in .env.example (root and frontend/). Secrets baseline files exist: futureagi/.secrets.baseline, futureagi/agentcc-gateway/internal/guardrails/secrets/secrets.go, futureagi/api_docs/develop/secrets.bru — verify these are not committed.

Running it: Use docker-compose up -d from the repo root to start all services (frontend, backend, vector store, gateway). For dev mode, see docker-compose.dev.yml. The Django backend typically runs on port 8000; the React frontend on 3000.

Real-World Use

A product team prototyping an agent can:

  1. Define a dataset in the UI (frontend/src/sections/experiment-detail/...).
  2. Run an eval that scores agent traces against the dataset (backend: futureagi/model_serving/...).
  3. Simulate a voice/conversation flow in the Simulate section, which plays back agent spans.
  4. Deploy guardrails via the gateway (futureagi/agentcc-gateway/) to intercept bad outputs before they reach users.
  5. Every trace flows back into a optimization loop (frontend/src/api/model/optimize.js → useGetOptimization), closing the feedback cycle.

Code Health & Issues

The following findings are from deterministic static analysis (not opinion). Report as-is.

  • [HIGH] Pin third-party GitHub Actions to commit SHAs — .github/workflows uses @vN tags (e.g., google-github-actions/auth@v2, aws-actions/configure-aws-credentials@v4). Tags can move; pin to 40-char SHA.
  • [HIGH] Replace wildcard CORS with explicit allow list — futureagi/tfc/settings/settings.py has CORS_ALLOW_ALL_ORIGINS = True with credentials enabled. Browsers block this pattern for authenticated cross-origin requests.
  • [HIGH] CI does not invoke its test suite — 624 test files exist, but none of the 4 GitHub Actions workflows include a test-running step.
  • [MEDIUM] Declare least-privilege GITHUB_TOKEN permissions — 4 workflows declare no permissions section; token inherits repo defaults.
  • [MEDIUM] Enable Dependabot/Renovate — 9 manifests, no update bot configured.
  • [MEDIUM] Pin container base image by digest — frontend/Dockerfile uses node:20.17, nginx:alpine (mutable).
  • [MEDIUM] Gate PRs on dependency vulnerability scan — no dependency-review-action or osv-scanner in CI.
  • [MEDIUM] Move large binaries out of repo — frontend/public/assets/readme/self-host.gif is 14.6MB; Login.png is 6.0MB.
  • [MEDIUM] Set persist-credentials: false on checkout — frontend-deploy-eu.yaml keeps the token across steps.
  • [MEDIUM] Add non-root USER to Docker image — frontend/Dockerfile has no USER directive; process runs as root.
  • 2 lower-severity findings also detected.

Beyond the measured block: committed secrets are confirmed (REPOSITORY HYGIENE section). No LICENSE or CONTRIBUTING.md issues — both are present.

The Bottom Line

This is a functional, full-stack platform that collapses LLM agent evaluation, tracing, simulation, and guardrails into one self-hostable loop. The code is well-structured for a startup-scale codebase, with a small internal call graph that makes routing understandable. However, the CI gap (no test execution), mutable Docker tags, wildcard CORS, and uncommitted secrets are production-risk items that should be addressed before any non-trivial deployment. Teams that need a unified agent feedback loop today and are comfortable running Docker + Django will find immediate value; those requiring hardened supply-chain guarantees should patch the listed issues first.

Word count: 537 (within 550 limit)