Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/xcoder-es/governance-layer/llms.txt

Use this file to discover all available pages before exploring further.

The Governance Layer is an architectural framework that adds a deliberative governance tier to AI systems. Rather than optimizing a single objective, a governed AI routes every decision through a Neural Parliament of seven specialized members, enforces pre-committed action restrictions via Ulysses Contracts, and maintains a stable Identity Layer that resists manipulation. The full reference implementation is written in Python and ships with a CLI, Streamlit dashboard, and formal verification tools.

Quickstart

Install the library and run your first governance cycle in under five minutes.

Architecture

Understand the four-layer stack: Speaker → Parliament → Contracts → Identity → TEE.

Core Framework

Deep-dive into the Neural Parliament, Ulysses Contracts, and Identity Layer.

API Reference

Full Python API — types, state machines, enforcement, and identity primitives.

​
What is the Governance Layer?

Modern AI systems are powerful optimizers, but optimization alone is not sufficient for safe, autonomous operation. The Governance Layer proposes that intelligence requires two distinct capabilities:
  1. Optimizing decisions — what to do
  2. Governing the decision-making process — which objectives should apply, which values take precedence, and whether to voluntarily restrict future choices
This repository provides both the formal theory (in book/) and a complete reference implementation across three interconnected layers.

Neural Parliament

Seven specialized members deliberate via weighted voting, vetoes, and proposal budgets.

Ulysses Contracts

Pre-committed action restrictions enforced by procedural inertia, monitors, and timelocks.

Identity Layer

Four-tier mutability model protecting core values from drift or manipulation.

​
Get Started

1

Install dependencies

Clone the repository and install with uv or pip:
git clone https://github.com/xcoder-es/governance-layer.git
cd governance-layer
pip install -e .
2

Run the speaker demo

Verify the installation by running the Neural Parliament speaker test:
python -m src.governance.runner speaker
3

Run all experiments

Execute all four governance scenarios with baseline comparisons:
python -m src.governance.runner all --baselines --steps 1000 --seeds 20
4

Explore the dashboard

Launch the Streamlit dashboard to visualize parliament decisions and benchmark results:
streamlit run src/governance/dashboard/app.py

​
Project Status

Maturity: Pre-alpha research prototype. The theoretical framework has undergone five rounds of adversarial review by an independent expert panel. The reference implementation is under active construction. Claims about security, formal verification, and production readiness are aspirational.

Running Experiments

Run benchmark scenarios and compare governance strategies against baselines.

Formal Predictions

Verify 12 testable predictions from the theoretical framework via the CLI.

CLI Reference

Full reference for all runner subcommands, flags, and output formats.

Contributing

Guidelines for contributing to the framework theory and implementation.

Build docs developers (and LLMs) love

Get started for freeTalk to us