Deterministic execution governance for AI and automated systems.

AI can propose anything. Waveframe determines whether the proposed action is allowed to execute.

We stop bad AI actions in one function call.

Waveframe is an integrated governance and enforcement platform that turns organizational authority into deterministic controls applied before sensitive actions reach production.

Policy, SOP, or authority source
                ↓
        Ledger Workspace
                ↓
        Waveframe Ledger
 normalize → diagnose → review → publish
                ↓
      Versioned authority bundle
                ↓
        Waveframe Cloud
 distribute authority + preserve evidence
                ↓
        Waveframe Guard
                ↓
            CRI-CORE
                ↓
          ALLOW / BLOCK
                ↓
        Production system
                ↓
 Evidence → Cloud → Guard Inspector

• Ledger Workspace gives governance teams a collaborative surface for authoring, review, approval, lifecycle, and publication.
• Waveframe Ledger converts governed source material into deterministic, reviewable, publishable authority.
• Waveframe Cloud distributes immutable authority and preserves durable execution evidence.
• Waveframe Guard gives developers a local-first runtime enforcement boundary.
• CRI-CORE deterministically decides whether a proposed action is admissible.
• Guard Inspector explains decisions, authority, receipts, replay, and continuity to operators and auditors.

Guard is the developer adoption entry point. Ledger Workspace is the governance and enterprise expansion surface. The commercial product is the integrated Waveframe platform, not any repository in isolation.

pip install waveframe-guard

from waveframe_guard import Guard

guard = Guard.local(workspace=".guard-local")

@guard.protect(authority="[email protected]")
def protected_action(execution_request):
    return perform_sensitive_action(execution_request)

Guard resolves and verifies published authority, constructs the governed proposal, invokes deterministic enforcement, blocks inadmissible execution, and preserves decision evidence.

Runtime enforcement remains local-first. Cloud unavailability does not silently remove the execution boundary.

1. A governance team starts with an existing policy, procedure, delegation-of-authority document, or other authority source.
2. Ledger Workspace guides normalization, diagnostics, review, approval, and publication.
3. Waveframe Ledger publishes a deterministic authority_bundle.v1 with a stable identity, explicit version, lineage, and cryptographic hashes.
4. Waveframe Cloud stores and distributes the published authority to approved environments.
5. An application, agent, automation, or user proposes an action through Waveframe Guard.
6. Guard binds the action, actor, authority, artifacts, and runtime context into a canonical proposal.
7. CRI-CORE returns the kernel-owned commit_allowed decision and complete stage trace.
8. Guard invokes the protected function only when execution is allowed.
9. Decision evidence is written locally, preserved to Cloud, and made inspectable and replayable through Guard Inspector.

Waveframe is model-agnostic. It governs proposed actions rather than depending on how those actions were generated.

These repositories provide the inspectable local developer path and deterministic protocol foundation.

The hosted platform creates operational value around the open deterministic foundation without moving the runtime execution decision into Cloud.

Waveframe's institutional governance and methodology remain separate from runtime product responsibilities.

These sources define governance expectations. Runtime products operationalize and enforce published authority without redefining it.

• Enforcement occurs before the production mutation.
• commit_allowed is owned by CRI-CORE, not reconstructed by callers.
• Guard never compiles natural-language policy during runtime enforcement.
• Runtime authority references are explicit and versioned.
• Published authority is bound by identity, version, lineage, and cryptographic hash.
• Blocked actions do not reach the protected execution function.
• Local enforcement continues during Cloud unavailability.
• Cloud distributes authority and preserves evidence but does not decide runtime admissibility.
• Inspector explains recorded outcomes but does not rewrite enforcement semantics.

An AI system proposes reallocating $2 million between cost centers.

Proposal received
      ↓
Authority resolved and verified
      ↓
Required CFO approval missing
      ↓
commit_allowed = False
      ↓
Protected transfer function is not invoked
      ↓
Evidence preserved for inspection and replay

The defining property is not that Waveframe generated an alert. The financial mutation never occurred.

Version compatibility and dependency requirements are maintained at waveframelabs.org/compatibility.html.

• Waveframe Labs
• Organization repositories
• ORCID
• [email protected]