FairMind

Open-source agentic AI governance. Agents do the governance work; a person decides at every gate.

Website | Docs | Status | Quickstart | Contributing | Discussions

What FairMind does

FairMind governs AI systems, including LLM applications and AI agents, by running governance as workflows. Each workflow is a chain of steps: collect, check, suggest, ask a person, act, verify, file evidence. An agent drafts the work steps, FairMind runs the evaluations, and a person approves or rejects at each gate. Every step lands on a hash-chained ledger, so the record of who decided what, and on which evidence, can be checked later.

One workflow run counts toward every framework it maps to. Run an AI risk assessment once and it is evidence for ISO/IEC 42001, NIST AI RMF, the EU AI Act and the other frameworks whose requirements it meets.

FairMind helps a team get ready for review and shows an auditor the evidence. It does not certify compliance, and it never approves a release on its own.

Related MCP server: swt3-mcp

Current status

Alpha, November 2026. The main path works end to end: discover systems, run workflows and evaluations, gate a release, hand an auditor a verifiable pack. 86 of the 90 catalogue workflows are still marked proposed until organisations run them in practice.

Works today

Partly done

Not built yet

• Automatic workflow starts. The catalogue lists schedules and triggers, but a person starts every run.

• Sandboxed evaluation workers. Engines run inside the backend process. Uploaded model files are inspected, never loaded or executed.

• Signed-evidence control plane (Assurance V2). Signed evidence, issuer keys, trust policies and four-eyes review are built and tested but off by default. See docs/STATUS.md.

• Runtime guardrails. FairMind assesses systems; it does not sit in the request path.

• Certification. No compliance certificate, automatic approval or "FairMind Verified" claim.

How a workflow runs

• Requested changes go through a revise step; the fourth round escalates.

• When someone decides on their own proposal, the run warns and the ledger records selfReview: true.

• Every run reports chainValid, so tampering with the ledger shows.

The four pillars

Evaluations

Each evaluation has a metric and a pass rule from the catalogue. A run returns passed, failed or insufficient (the inputs cannot support a verdict), the metrics behind it and the detail per row or probe.

On uploaded files. Data drift, data poisoning, train-test leakage, personal data, RAG knowledge-base poisoning, label quality, task accuracy, calibration, out-of-distribution detection, multilingual parity, counterfactual flip rate, membership inference, verbatim reproduction, secrets in prompts and config, tool poisoning, model file and dependency scanning, runaway agent loops, cost against budget and more. No file engine makes a network call.

Against your live AI system. Connect an OpenAI-compatible endpoint or any HTTP endpoint. FairMind sends probes and judges the answers with your own model: prompt injection, jailbreaks, system prompt leakage, harmful content, PII leakage, RAG faithfulness, robustness to typos and distractors, and uneven treatment between groups. Probes come from your CSV, or your model writes them from the system's intended use. Behaviour tests run as background jobs.

On your agent platform's configuration. Connect Claude Managed Agents read-only, or upload an exported config or an MCP config. FairMind checks for high-risk tools that do not ask first, unrestricted network egress, poisoned agent memory, shadow MCP servers, MCP servers without credentials, and secrets in agent fields. A section the export leaves out counts as not read, so a check never passes on missing data.

From stored runs. Fairness runs (disparate impact, demographic parity, equal opportunity, equalized odds, calibration, each with a bootstrap interval and a permutation p-value), monitoring snapshots and environmental assessments feed five more evaluations.

Frameworks

51 frameworks are in the catalogue. Among them:

• AI management and risk: ISO/IEC 42001, ISO/IEC 42005, ISO/IEC 23894, NIST AI RMF, NIST AI 600-1

• Agents and LLM security: AIUC-1, OWASP Top 10 for LLM Applications, OWASP Top 10 for Agentic Applications, OWASP MCP Top 10, CSA AI Controls Matrix, CSA MAESTRO, MITRE ATLAS, Google SAIF

• Law and regulation: EU AI Act, Council of Europe AI Convention, Korea AI Basic Act, Colorado and Texas AI acts, NYC Local Law 144, California SB 53

• Guidelines: OECD AI Principles, G7 Hiroshima Process, Singapore's frameworks for agentic and generative AI, Japan's AI Guidelines for Business, sector guidance for finance and health

A framework mapping organises evidence. It is not legal advice or a conformity decision. The full catalogue lives in pack_catalogue_data/catalogue.json.

Release gate in CI and coding agents

Mint an API key at POST /api/v1/auth/api-keys.

pipx install ./apps/cli
export FAIRMIND_API_URL=https://your-fairmind-host
export FAIRMIND_API_KEY=...

fairmind gate --system <id>      # exit 0 go, 2 conditional go, 1 no go
fairmind test --system <id> --file predictions.csv --outcome repaid --prediction approved --attributes gender,region
fairmind monitor --system <id> --file recent.csv --attributes gender,region
fairmind verify pack.json        # offline, no network

- uses: adhit-r/fairmind/.github/actions/fairmind-gate@main
  with:
    system: ${{ vars.FAIRMIND_SYSTEM_ID }}
    api-url: ${{ vars.FAIRMIND_API_URL }}
    api-key: ${{ secrets.FAIRMIND_API_KEY }}

The Python SDK wraps the same calls, and the MCP server gives Claude Code and other MCP clients nine tools: list_systems, release_gate, clause_map, run_fairness_test, record_monitoring_snapshot, attest_check, list_evaluations, describe_evaluation and run_evaluation. Guides: release gate in CI, SDK and MCP, inspection packs.

Quickstart

You need Python 3.11+, uv, Node.js 20+, npm, and an empty PostgreSQL 14+ database (local, Docker or Neon).

git clone https://github.com/adhit-r/fairmind.git
cd fairmind

Backend, in one terminal:

cd apps/backend
cp config/env.example .env           # set DATABASE_URL and SECRET_KEY
uv sync
uv run python scripts/setup_db.py    # schema plus reference data; safe to re-run
uv run uvicorn api.main:app --reload --port 8000

Frontend, in another:

cd apps/frontend
echo "BACKEND_INTERNAL_URL=http://localhost:8000" > .env.local
npm install
npm run dev

Open http://localhost:1111, register, and sign in. API docs are at http://localhost:8000/docs. uv run python scripts/setup_db.py verify checks a database without changing it.

SECRET_KEY also derives the key that encrypts stored model-provider and platform keys, so rotating it means entering those keys again.

Repository layout

Tests

cd apps/backend && FAIRMIND_TEST_POSTGRES_URL=postgresql://... uv run pytest
cd apps/frontend && npm run test

Backend tests need a throwaway PostgreSQL 14 server; each test gets its own temporary database. CI runs the backend suite, the frontend type-check and unit tests, and the CLI, SDK and MCP tests.

OECD.AI Catalogue

FairMind is listed in the OECD.AI Catalogue of Tools & Metrics for Trustworthy AI as an open-source technical toolkit for governance, compliance and risk management, covering design, validation, deployment and monitoring. The catalogue lists tools from their authors; the OECD does not vet or endorse them.

Contributing

Contributions are welcome, from typo fixes to new evaluation engines. Start with CONTRIBUTING.md, then pick a good first issue. The 48 evaluations without an engine are a good place to start. Questions go to Discussions. Please follow the Code of Conduct.

Security

Do not report vulnerabilities in public issues. See SECURITY.md.

Citing FairMind

Metadata is in CITATION.cff. Concept DOI: 10.5281/zenodo.23982915.

License

Created and maintained by Axonome. MIT licence; see LICENSE.