Architecture

AIGP Overview

AI Governance Platform (AIGP) provides a control plane for AI systems. It records governed AI assets, evaluates AI configurations, persists execution evidence, reconstructs history, analyzes quality change, ranks experiment candidates, and produces recommendations. It does not own prompt deployment, model deployment, infrastructure orchestration, or CI/CD execution.

The architecture keeps frameworks and infrastructure at the edge. Runtime systems can call into AIGP, but AIGP is not the runtime itself.

Architectural Planes

The system is organized into independent planes. Each plane owns a single responsibility and communicates only through explicit contracts.

Audit Plane

The Audit Plane captures workflow and node-level execution records. It stores the evidence required to understand what happened during an AI workflow and to reconstruct that workflow later.

Replay Plane

The Replay Plane reconstructs historical workflow executions from persisted audit state. Replay exists to support investigation, debugging, and governance review rather than to rerun live traffic.

Replay consumes ordered Agent Runtime events—not downstream ontology projections—so action sequence, failures and recovery remain inspectable. Unsupported conclusions fail closed.

Evaluation Plane

The Evaluation Plane turns workflow outputs into evaluation results. Providers such as TruLens sit here behind provider contracts. Evaluation exists to create governance evidence, not to be the platform boundary.

Compare models and agent scaffolds under versioned runner, task, scoring and execution conditions. Results retain item-level metrics and immutable runner provenance.

Evaluation providers—including Inspect AI and TruLens—remain optional adapters behind provider-neutral contracts. Provider-specific types do not enter the governance domain.

Job Execution Plane

The Job Execution Plane records and executes long-running governance work such as evaluation, experiment, replay, and drift analysis jobs. It owns AIGP job semantics such as idempotent submission, queued/running/succeeded/failed states, worker leases, retry attempts, cancellation, and immutable result references. It is not a workflow engine.

Persistence Plane

The Persistence Plane stores governed artifacts and evidence through repository contracts. Each repository type is backed by a factory class that selects the concrete implementation based on runtime configuration. SQLite is the current durable reference implementation. The architecture treats storage as replaceable.

Asset Plane

The Asset Plane catalogs versioned prompts, models, datasets, and evaluation providers. It distinguishes managed dataset/provider records from prompt/model identities observed in runtime or evaluation evidence. Dataset metadata is relational; immutable dataset bytes are stored through an S3-compatible artifact contract. Asset versions project into the ontology so experiments, evaluation runs, replay, policies, and decisions can be traced to their exact governed inputs.

History Plane

The History Plane retrieves persisted evaluations and organizes them into history views, trends, summaries, and comparisons. It provides the longitudinal view needed for governance decisions.

Governance Plane

The Governance Plane analyzes change over time. It compares evaluations, calculates drift, and produces governance-oriented artifacts from historical data. This plane interprets evidence; it does not execute deployments. Governed outcomes are represented by the GovernanceDecision domain model.

Policy Engine

The Policy Engine evaluates active, versioned policy rules against captured evidence. Rules are structured, priority-ordered, and deterministic; their matching outcome, condition trace, reason, policy version, and evidence references are persisted with the governance decision. It is a decision control plane, not an AI runtime or deployment system. See Policy Engine for the rule model and lifecycle.

Agents Runtime and Causal Audit

Agents Runtime is an evidence surface for agents that run outside the control plane. It stores bounded, tenant-scoped execution records and ordered operational events so people can review what happened without moving the agent or its private reasoning into the platform. Deterministic detectors can identify repeatable conditions such as an unusual tool failure rate.

Causal Audit composes the Audit and Replay planes for one eligible execution. It applies a versioned, approved change to tool evidence in a safe isolated replay owned by the original runtime, then persists the measured outcome difference and replay lineage. It never changes the source execution. See Agents Runtime and Causal Audit for the detailed contracts and boundaries.

Governance Ontology Plane

The Governance Ontology Plane provides a semantic graph describing relationships between governed assets. It is the authoritative business model of AIGP; all storage models, APIs, graph projections, UI views, and AI reasoning are derived representations.

Settings Control Plane

The Settings Control Plane is a typed configuration resource with explicit SYSTEM, ORGANIZATION, and PROJECT scopes. Effective configuration follows environment > project > organization > system > default. Each scoped update uses compare-and-set with an expected version.

End-to-End Data Flow

The core experiment governance flow is:

Experiment
  → Experiment Candidate
  → Evaluation Run
  → Evaluation Result
  → Evaluation History
  → Comparison / Drift
  → Ranking
  → Leaderboard
  → Recommendation

Replaceable Components

AI Governance Control Plane keeps provider and storage choices behind contracts:

• Evaluation providers are pluggable.
• Repository implementations are pluggable, selected via factory classes.
• SQLite is a current durable backend, not the architectural center.
• REST, CLI, SDK, or MCP adapters can sit above services and framework-neutral APIs.

Open-Core Extensions

AIGP remains the authoritative control plane. It can be consumed as a versioned dependency by separately released plugins that add or replace declared capabilities through stable contracts. The core never imports or conditionally detects a specific enterprise package.

The supported extension surface includes provider resolution, composition-based decorators, ordered lifecycle hooks, versioned domain events, and controlled REST route contributions. Provider replacement and route replacement are explicit; duplicate ownership fails startup.

See Extensibility for the public contracts, Python package entry-point setup, compatibility requirements, and runtime diagnostics.

REST APIs

The current REST control plane exposes:

• /health and /ready for service checks
• /api/v1/providers for provider discovery
• /api/v1/prompts, /api/v1/models, /api/v1/datasets for registry reads, observations, and dataset upload
• /api/v1/evaluations for synchronous evaluation submission and persisted result reads
• /api/v1/experiments for experiment creation, candidates, runs, candidate comparisons, and leaderboards
• /api/v1/governance for comparison, drift analysis, and report lookup
• /api/v1/jobs for async governance job submission, status lookup, listing, cancellation, retry, and result references
• /api/v1/settings for typed configuration management
• /api/v1/decisions for governance decision evaluation and retrieval
• /api/v1/policies and /api/v1/policy-schema for policy authoring, lifecycle, and simulation
• /api/v1/agent-executions for bounded external agent-execution evidence and event timelines
• /api/v1/agents-runtime for runtime findings, intervention policies, and Causal Audit

Non-Goals

The architecture intentionally does not make AIGP responsible for:

• Prompt deployment
• Model deployment
• Prompt authoring and model serving
• Dataset labeling and data-engineering workflows
• Runtime promotion
• Infrastructure management
• Web-server ownership
• CI/CD orchestration

Those systems can consume AIGP recommendations, but they remain outside the platform boundary.