MPRD is FCIS (Formal Correctness by Construction) applied to AI.
MPRD is a blueprint for turning raw intelligence into lawful power without ever needing to understand or trust the intelligence itself. It operates on a simple, invariant-preserving principle:
- Models Propose: An untrusted, imperative optimizer generates arbitrary candidate actions.
- Rules Decide: A trusted, pure, deterministic decision procedure accepts or rejects proposals based solely on formal policy and verifiable evidence.
Steam is raw power. Uncontained, it dissipates uselessly into the air. But channel it through a piston, and it moves locomotives across continents. Wind is the same: formless and fleeting until caught by a sail, where it becomes the force that carried civilizations across oceans.
Intelligence is no different.
An AI model generates immense creative potential: ideas, strategies, solutions. But without structure, that potential is either wasted or dangerous. MPRD is the engine that harnesses this force. Every action that executes has passed through a governor that enforces what is allowed. Not by hope, not by training, not by alignment theater. By architecture.
The model cannot execute. The executor cannot act without a valid token. The token cannot be minted unless the rules allow it. This is the piston. This is the sail. This is how raw intelligence becomes useful work.
┌─────────────────────────────────────────────────────────────┐
│ The MPRD Engine │
├─────────────────────────────────────────────────────────────┤
│ │
│ ╭──────────╮ ╭──────────╮ ╭──────────╮ │
│ │ Steam │ ───▶ │ Piston │ ───▶ │ Motion │ │
│ │ (AI) │ │ (Rules) │ │ (Action) │ │
│ ╰──────────╯ ╰──────────╯ ╰──────────╯ │
│ │
│ Proposes Governs Executes │
│ (unbounded) (bounded) (only if allowed) │
│ │
└─────────────────────────────────────────────────────────────┘
∀ executed_action: Allowed(policy, state, action) = true
This isn't a goal. It's a guarantee. The architecture enforces it:
- Proposer cannot execute: zero direct capability, like steam without a cylinder
- Executor is the ONLY path to action: single, guarded channel
- No token, no execution: the piston won't move without pressure
- Tokens only mint for allowed actions: the governor controls the valve
- ZK attestation: third parties can verify without trusting the operator
- Lean 4 proof bundle (fast to build):
proofs/lean/(runcd proofs/lean && lake build) - Policy Algebra (ROBDD certification rail): semantic hashes/diffs + Tau-gate equivalence checks (see
docs/POLICY_CERTIFICATION.md). - Neuro-symbolic disaster-loop preprint:
docs/whitepapers/NEURO_SYMBOLIC_DISASTER_LOOP.pdf(source and case-study bundle live beside the PDF).
MPRD treats model output as untrusted and high-entropy: the model can propose anything, but cannot execute. A deterministic governance layer canonicalizes state/candidates, commits to them (hashes/IDs/epochs/nonces/limits), and produces a small, versioned proof-carrying transcript (token + receipt/journal) that can cross hostile networks. Verifiers then fail-closed check that transcript against allowlisted code (image IDs from a trusted registry/manifest) and that it matches the token commitments. The executor performs side effects only for the single committed action and only once (anti-replay), turning untrusted proposals into verifiable, permissioned execution.
| Layer | Role | Capability |
|---|---|---|
| Proposer (Model) | The Steam | Generates ideas, cannot act |
| Governor (Tau) | The Piston | Decides what's allowed, issues tokens |
| Executor | The Motion | Acts only with valid tokens |
| Mode | Trust | Use Case |
|---|---|---|
| A (Local) | Operator | Internal testing only |
| B-Full (Risc0) | Trustless | Production default, ZK proofs |
| B-Lite (MPB) | Computational | Experimental, internal only |
| C (Private) | Trustless + Private | Privacy-required scenarios |
MPRD/
├── crates/
│ ├── mprd-core/ # Core types, selector, orchestrator
│ ├── mprd-zk/ # ZK infrastructure, governance profiles
│ ├── mprd-adapters/ # External system adapters
│ ├── mprd-proof/ # Proof generation utilities
│ ├── mprd-cli/ # Command-line interface
│ └── mprd-risc0-shared/ # Shared Risc0 types
├── methods/ # Risc0 guest methods
├── policies/ # Tau governance specifications
│ └── governance/
│ └── canonical/ # Production-ready governance specs
├── proofs/ # Proof artifacts (Lean / verification scripts)
└── docs/ # Documentation
use mprd_zk::{GovernanceProfile, UpdateKind, GovernanceGateInput};
// Create hybrid governance (separate app/safety committees)
let profile = GovernanceProfile::hybrid(
2, app_members, // 2-of-N app committee
3, safety_members, // 3-of-N safety committee
"chain_id", "app_id",
)?;
// Check authorization
let input = profile.check_authorization(
UpdateKind::PolicyTweak,
&app_signatures,
&safety_signatures,
link_ok,
);
// Validate (mirrors Tau spec logic)
let accepted = GovernanceProfile::would_accept(&input);Production-ready governance specifications in policies/governance/canonical/:
| Spec | Purpose |
|---|---|
mprd_governance_gate.tau |
Main governance gate (sbf-only) |
mprd_committee_quorum.tau |
M-of-N committee voting |
mprd_timelock.tau |
Two-phase commit with delay |
mprd_escalation.tau |
Risk-tiered authorization |
mprd_conviction.tau |
Time-weighted voting |
# Build all crates
cargo build
# Run tests
cargo test
# Run with ZK proofs (requires Risc0)
cargo build --release| Topic | Description |
|---|---|
| SDK Quickstart | Get started in 5 minutes |
| Policy Algebra | How to write Tau governance specs |
| Production Readiness | Pre-deployment checklist |
| Security Hardening | Security best practices |
| MPRD Security Whitepaper (PDF) | Community draft: intelligence–agency separation, executor boundary, and verification rails |
| Testing Guide | Testing strategies and commands |
| CEO Menu Modes | Algorithmic tokenomics controller |
| CEO Simplex POR (Whitepaper PDF) | Guarded simplex transfers, constant-time independence oracle, and certified commutation + trace swap + canonicalization invariance results |
| ZK Production | ZK proof deployment guide |
# Run all tests
cargo test
# Run governance tests
cargo test -p mprd-zk -- governance
# Run Tau interpreter tests
cargo test -p mprd-zk --test tau_interpreter_output_testsThe operator console keeps a local decision history on disk. Retention can be controlled at runtime:
MPRD_OPERATOR_DECISION_RETENTION_DAYS(default30,0disables time-based pruning)MPRD_OPERATOR_DECISION_MAX(default10000,0disables size cap)
Settings are persisted in the operator store (settings.json) and can be updated live via POST /api/settings.
You can trigger an immediate prune via POST /api/settings/prune.
See LICENSE file for details.
Note: This repository does not include IDNI/Tau licensed code. The external/ directory is gitignored and must be populated separately with appropriate licenses.