Overview
AIGP governs consequential AI actions, preserves bounded execution evidence, and helps teams investigate outcomes. Your application still runs where it does today.
AIGP is an open-source control plane for AI systems and agents. It helps establish authority for consequential actions, preserve attributable execution evidence, and investigate whether evidence influenced an outcome. It does not run your models, execute your business operations, or replace your deployment tools.
The governance lifecycle
For a protected action, the path is: trusted delegation β authorization β runtime enforcement β execution receipt β recovery when needed. Replay eligibility, controlled replay, and Causal Audit are a separate, eligibility-gated investigation pathβnot a required step for every agent action.
Authorization says whether the runtime may attempt one exact operation. A receipt is the runtime's bounded attestation of what it reports happened; it is not independent proof of an external mutation. A replay manifest asks whether enough isolated, versioned evidence exists to attempt a replay.
Latest Release
The current release expands the control plane with governed evaluation inputs, runtime evidence, and safe execution-level review. It adds:
- Managed, immutable prompt and model versions alongside observed runtime assets.
- Managed dataset lifecycle controls and consistent-dataset candidate comparisons.
- Tenant-scoped Runtime Connections and validated provider/model capability profiles.
- Candidate execution evidence, per-item evaluation results, cancellation, and progress visibility.
- A first-class Policy Engine with version lifecycle, simulation, condition traces, and explainable decisions.
- Agents Runtime evidence for externally run agents, including ordered execution timelines and deterministic operational findings.
- Trusted delegation, runtime action authorization, execution receipts, and recovery semantics for protected external operations.
- Causal Audit for safe, isolated checks of whether approved tool evidence materially affected a measured outcome.
Start with Asset Catalogs, the Evaluation Engine, and the Policy Engine for the detailed contracts and operational boundaries.
Architectural Planes
The system is organized into independent planes. Each plane owns a single responsibility and communicates only through explicit contracts:
- Audit Plane β captures workflow and node-level execution records for reconstruction and investigation.
- Replay Plane β reconstructs historical executions from persisted audit state. It replays ordered Agent Runtime events, keeping action sequence, failures and recovery inspectable. Unsupported conclusions fail closed.
- Evaluation Plane β turns workflow outputs into evaluation results using pluggable providers. It compares models and agent scaffolds under versioned conditions, with item-level metrics and immutable runner provenance.
- Job Execution Plane β records and executes long-running governance work with durable lifecycle tracking.
- Persistence Plane β stores governed artifacts through replaceable repository contracts.
- Asset Plane β catalogs versioned prompts, models, datasets, and evaluation providers with explicit ownership and ontology-backed lineage.
- History Plane β retrieves and organizes evaluations into history views, trends, and comparisons.
- Governance Plane β analyzes change over time, calculates drift, and produces governance-oriented artifacts.
- Policy Engine β evaluates versioned, structured rules against captured evidence and persists explainable governance outcomes.
- Agents Runtime β records bounded evidence from externally run agents and identifies deterministic operational conditions for review.
- Causal Audit β uses an approved, isolated replay to measure whether specific tool evidence materially affected an eligible outcome.
- Governance Ontology Plane β semantic graph describing relationships between governed assets.
- Settings Control Plane β typed configuration with SYSTEM, ORGANIZATION and PROJECT scopes.
See the architecture overview for a full breakdown of each plane and how they interact.
Policy Engine
The Policy Engine turns evidence into repeatable governance decisions. Policies are versioned and target governed entities such as experiment candidates, prompt versions, and model versions. Their rules have explicit priorities, conditions, effects, and reasons; the resulting decision preserves the matching rule, condition trace, evidence, explanation, and audit context.
Read the Policy Engine guide to understand rule authoring, simulation, lifecycle, outcome precedence, and decision review.
Interfaces
Every governance operation is available over a versioned REST API and as an auditable MCP tool. The MCP server exposes governed read and controlled-write operations to agents, while the REST APIs serve consoles, CLIs and service-to-service integrations.
Extensibility
AIGP exposes a versioned extension surface for independently released integrations. Plugins can add routes, providers, lifecycle hooks, and event subscribers through declared contracts; they do not modify AIGP source or depend on internal services.
This keeps the OSS control plane authoritative while allowing future commercial or organization-specific packages to evolve independently. Read the Extensibility guide for plugin lifecycle, compatibility, and operational rules.
Where to start
- Begin with Getting Started.
- Want the mental model? Read the Architecture overview.
- Building an integration? Start with the Extensibility guide.
- Ready to run something? Try the governed replay walkthrough for a complete API-driven product path, or the observed asset ingestion tutorial.
- Connecting an agent? Start with Observe Agent Runtime, then read Causal Audit when safe controlled replays are available.
