Building deterministic execution-governance infrastructure for AI and automated systems.

Waveframe Labs develops systems that decide whether a proposed action is allowed to execute before it reaches production systems.

Most governance systems:

• monitor behavior
• generate warnings
• or audit after execution

Waveframe focuses on something else:

deterministic admissibility at the execution boundary

Governance Source
        ↓
Governance-Ledger
        ↓
Contract Compiler
        ↓
Compiled Authority Contract
        ↓
Proposal Normalizer
        ↓
Canonical Proposal
        ↓
CRI-CORE
        ↓
COMMIT ALLOWED / BLOCKED
        ↓
Waveframe Guard
        ↓
Production System

Waveframe Cloud provides:

• authority distribution
• registry infrastructure
• durable audit ingestion
• and receipt verification

pip install waveframe-guard

Waveframe Guard wraps runtime execution and enforces governance locally before actions execute.

from pathlib import Path

from waveframe_guard import install_guard, guard

install_guard(
    actor={"id": "user-1", "type": "human", "role": "intern"},
    contract_path=Path("contracts") / "finance-policy-1.0.0.contract.json"
)

@guard
def transfer(amount):
    print(f"Transferred ${amount}")

transfer(100)

Execution blocked: required role not satisfied: manager

Turns governed source text into deterministic, reviewable governance authority.

Provides:

• governance normalization
• semantic diagnostics
• publication gating
• lineage verification
• deterministic publication artifacts

Compiles governance policy into deterministic compiled contract artifacts.

pip install cricore-contract-compiler

Compiled contracts define:

• authority requirements
• approvals
• invariants
• artifact requirements
• execution constraints

Builds canonical CRI-CORE proposal objects from:

• actor identity
• mutation requests
• contract references
• governance artifacts

pip install cricore-proposal-normalizer

Deterministic execution-boundary enforcement kernel.

pip install cricore

CRI-CORE evaluates:

• compiled contracts
• canonical proposals
• runtime context

and returns:

commit_allowed = True | False

If False, the action must not execute.

CRI-CORE does not:

• generate actions
• orchestrate workflows
• persist logs
• interpret governance meaning

It only determines:

whether a proposed action is admissible at execution time.

Developer-facing runtime enforcement SDK.

Guard:

• loads published contracts
• wraps execution
• evaluates admissibility
• blocks invalid actions locally
• continues enforcement during Cloud outages

pip install waveframe-guard

Authority distribution and durable evidence infrastructure.

Cloud provides:

• contract registry distribution
• immutable authority artifacts
• audit ingestion
• durable receipts
• organizational authority coordination

Cloud does not:

• evaluate admissibility
• execute actions
• normalize governance

An AI proposes reallocating $2M between cost centers.

Without enforcement: → execution proceeds immediately

With Waveframe: → proposal evaluated against authority contract → missing approval detected → COMMIT BLOCKED

The action never executes.

Local enforcement remains operational even if Cloud is unavailable.

Version compatibility and dependency requirements are documented at:

https://waveframelabs.org/compatibility.html

Repositories in this organization demonstrate:

• governed financial mutations
• execution-boundary enforcement
• role separation enforcement
• approval threshold enforcement
• admissibility replay
• runtime governance blocking

Each demo answers one question:

does the proposed action execute or not?

Website — https://waveframelabs.org ORCID — https://orcid.org/0009-0006-6043-9295 Contact — swright@waveframelabs.org