Supranon | Execution-Custody Runtime

Supranon v2.0 · Pre-Commit Consequence & OS Execution-Custody Runtime supra + non: nothing above the execution boundary

Trust the model to think. Never trust it to commit.

Supranon proves the consequence, resolves a safe path, and seals the commit. Modern AI security stops at the prompt, the identity layer, or an emergency kill-switch, leaving autonomous agents free to corrupt live databases, race concurrent state, or double-spend across dropped network sockets. Supranon is a drop-in execution-custody runtime for PostgreSQL, Kubernetes, and host OS boundaries requiring zero agent rewrites: it verifies physical consequences in isolated clones once, resolves invariant-safe execution paths from a learned structural grammar, withholds raw credentials behind single-spend OS gates, and seals offline-verifiable Ed25519 receipts.

Step 01 · Pre-Commit Resolution

Prove consequences once, reuse at zero probes

Cold physical cloning (WAL_LOG / K8s dryRun=All, 0.73–1.45 s/fork) runs only under zero priors. Once an effect model is learned, bounded search over a minimized structural grammar resolves safe paths at 0 probes, with zero LLM judges in the gate and deterministic 34 ms fail-closed holds if no safe path exists.

Step 02 · Credential-Zero OS Custody

Enforce single-spend wire & kernel gates

Workers never hold raw database passwords or cluster keys. Linux 5-hook BPF LSM, embedded WSL2 authority, and outer wire proxies execute the physical fence at a 134.14 ms median, locking uncertain network timeouts non-refundably so retries can never double-spend.

Step 03 · Reconcile & Seal

Prove actual poststate offline

After execution, Supranon independently reconciles live poststate across 24 state owners and multi-agent turns (Rete-Oracle), sealing Ed25519 receipts audited offline by the air-gapped ColdRoom Verifier (4.82 ms Linux / 82.73 ms Win64).

Unified v2.0 Dual-OS Cohorts 49 / 49

Standalone checks passed on both Linux x86_64 and Windows x64 (+ embedded WSL2 authority) across collusion (21/21), DAG (11/11), burst, and capture-transport cohorts.

Chained Workflow Completion 10 / 10

Guarded boundaries completed at zero protected loss where raw execution loses state at boundary 1 and static deny deadlocks at 0/10.

Authenticated x86_64 Recovery 1.90 s

Fully admitted Linux x86_64 fresh-process recovery median (22/22 restores) restoring 24 state owners, 58/58 custody bindings, and fresh authority before READY.

Air-Gapped Tamper Closure 0 → 2 → 0

Standalone ColdRoom verifier (zero runtime imports) catches any 1-bit receipt tamper offline (4.82 ms Linux / 82.73 ms Win64 NTFS verification median).

Why You Should Care · The Autonomy Trilemma

Autonomy without execution custody is just root access with a prompt.

Enterprises are pouring capital into autonomous workflows, yet nearly every existing security layer forces an ugly trade-off: let agents break production, or freeze them behind human approval queues and static blocklists. Here is why current alternatives stall, and why execution custody changes the equation.

Operational & ROI Reality
01 · The Guardrail Illusion

Valid-syntax commands still wreck production

An agent can pass every RBAC check, identity audit, and prompt classifier and still emit a syntactically valid SQL DELETE or Kubernetes scale-down that destroys unarchived records or breaks quorum. Text filters inspect what the model said, while production breaks on what the state becomes.

Supranon verifies live 100k-row & cluster consequences before commit.
02 · The Deadlock Tax

Blocklists & kill-switches destroy autonomy ROI

Preserving state by blocking risky calls or killing worker processes at 3 AM halts the pipeline (0/10 completion) and pushes engineers right back into manual triage. Real autonomy requires a runtime that can deterministically resolve an invariant-safe path that still finishes the job.

Supranon completes 10/10 guarded boundaries at 0 protected loss.
03 · Distributed Boundary Failure

Retries, state drift & collusion bypass stateless proxies

When a TCP socket drops mid-commit, an external process mutates state between plan and execution (125 → 175), or multiple agents split a restricted action across turns, stateless gateways either double-spend on retry or approve stale commits.

Supranon closes all three in one conserved, formally checked ledger.
Drop-In Boundary Topology: Zero Agent Rewrites Click any node to inspect its custody boundary and measured telemetry
UNTRUSTED PETITIONERS (ZERO SDK REWRITES) PROTECTED LIVE INFRASTRUCTURE (CREDENTIAL-ZERO WIRE & OS CUSTODY) MCP Clients 5 native loopback tools LangGraph Loops Multi-turn orchestration Local & Frontier LLMs OpenAI-compatible tool calls Custom Agents Unmodified worker procs SUPRANON EXECUTION-CUSTODY BOUNDARY (0 LLM JUDGES IN GATE) CONTROL PLANE I Isolated Clone & Grammar 0 probes on warm reuse RETE-ORACLE 24-Owner DAG & Collusion 21/21 collusion, 11/11 DAG CONTROL PLANE II Credential-Zero OS Gate 134.14 ms median fence AIR-GAPPED SEAL ColdRoom Proof Ed25519 offline 0 → 2 → 0 tamper PostgreSQL 16 pgwire + SAVEPOINT MySQL & SQLite DDL split & DML fence Kubernetes mTLS /validate + dryRun POSIX & NTFS OS 5-hook BPF / Win64+WSL2
Control Plane I: Isolated Clone & Minimized Structural Grammar Forks physical WAL_LOG clones and Kubernetes dryRun=All checks only under zero priors, then resolves invariant-safe execution paths at 0 probes on warm reuse with zero LLM judges in the gate.
10,001 → 1–2 search expansions
Explicit Threat Model & Trust Split: Assumes a trusted host kernel and custodian broker (root / CAP_BPF, and neither Linux nor Windows claims defense against a hostile host admin). Ring-0 mediates single-spend slot burn, expiry, and process/socket identity, while outer wire proxies own SQL and Kubernetes protocol semantics. Zero LLM judges sit in the enforcement path.

01 · Verified Trace Replay: Backed by Sealed Ablation & v2.0 Cohorts

Step through real qualified failure traces across three policies

Every outcome, timing, and fault disposition below maps directly to measured runs in our published ablation-results.json proof bundle (cases A:full, B:full, C:full) and Unified v2.0 standalone cohorts (collusion 21/21, burst-drop 3/3), not synthetic marketing animations.

Verified Trace Replay · 0 LLM Judges
1. Scenario
2. Policy

Destructive SQL Purge + Live K8s Scale-Down

An autonomous operator attempts to purge 100k-row billing records before archiving and scale a production Kubernetes deployment down to 0 replicas.

RESOLVED & SEALED
WAL_LOG CLONE + DRYRUN PETITIONER Agent Proposal DELETE + scale=0 SUPRANON DUAL PLANE Resolve & Single-Spend Gate Archive-first path resolved LIVE TARGET PG16 + K8s 0 protected loss PROOF Ed25519 SEALED
Stage 1ADMIT
Scope & Prestate Pin

Binds 100k-row server-side SHA-256 prestate digest and retains target owners across PG16 and K8s before execution.

Stage 2PREPARE
Isolated Clone & Path Resolution

Forks isolated WAL_LOG clone + K8s dryRun=All check, detects unarchived row loss, and resolves a verified archive-first path.

Stage 3CUSTODY
Credential-Zero Commit

Arms a single-spend slot while outer pgwire and mTLS webhooks inject credentials on the wire with SAVEPOINT row ceilings.

Stage 4SEAL
Poststate & ColdRoom Proof

Reconciles actual database rows and cluster replicas into an Ed25519 receipt verifiable offline by ColdRoom.

Protected State Loss0 rows / 0 outages
Workflow Completion10 / 10 completed
Recorded Timing3.07 s – 17.89 s (live gate)
Evidence LineageWave 7.1 Live PG16 + K8s

02 · Hands-On Custody Invariants

Test Conserved Timeout Locking & 1-Bit Offline Tamper Detection

Two mechanical guarantees separate execution custody from conventional logging: uncertain network timeouts never silently refund capability, and a single flipped bit in any receipt fails air-gapped verification deterministically.

Live 5-State Conserved Epoch Ledger

SUM == 1,000 (CONSERVED)
1,000 epoch_cap: try arming a slot, then drop the wire
Spent180
Armed80
Indeterminate60
Reserved100
Available580
180 + 80 + 60 + 100 + 580 == 1,000 (non-refundable indeterminacy holds)

Click Simulate Wire Drop while a slot is armed: instead of blindly refunding capacity and risking double-execution on retry, Supranon locks the exposure non-refundably into retained_indeterminate.

Air-Gapped ColdRoom 1-Bit Tamper Lab

EXIT 0 · VERIFIED

The standalone ColdRoom Verifier imports zero runtime state modules (python -I -B -S). Flip a single bit in the sealed receipt payload below to observe deterministic 0 → 2 → 0 closure:

schema: supranon/coldroom-receipt/v2
cohorts: 49/49 PASS (24 owners, 58 custody pairs)
payload: {"poststate_loss":0,"slot_burn":"single_spend","tamper":false}
expected: 9c4e71a80f2b...d841c09e (Ed25519-pinned)
computed: 9c4e71a80f2b...d841c09e (EXACT MATCH)
[EXIT 0] Ed25519 signature valid · SHA-256 payload digest matches · 0 runtime imports

03 · Interactive Flight Recorder & Day-1 Adoption

Unified Custody Console, Shadow Rollback & Causal Forensics

Supranon runs without human-in-the-loop approval bottlenecks, pairing a loopback-only composite console with counterfactual Shadow Audit mode, 5 native MCP tools, and one-command causal receipt explanations. Click any tab below to inspect live telemetry views.

127.0.0.1 Loopback IPC Only
01 · STATE OWNERS 24 Retained / Bound
02 · CUSTODY PAIRS 58 / 58 Active Bindings
03 · KERNEL / WSL2 BPF LSM & WSL2 Attested
04 · SHADOW TRIAL SAVEPOINT + DryRun
05 · KILL-SWITCH Quarantine & Drain Armed
Custody Posture: 24 Conserved Owners & 58 Custody Pairs 49/49 Standalone Qualified

Real-time custody invariants across Plane I counterfactual repair, Plane II single-spend OS authority, and Rete-Oracle multi-agent turn reconciliation.

Authority BoundaryLinux 5-Hook BPF / Win64 + WSL2
Credential CustodyZero-Secret Worker Memory
Native MCP Tools5 Loopback HTTP Tools Active
CAUSAL EXPLAIN TIMELINE: supranon explain <receipt> --json VERIFIER: ColdRoom Offline Auditor (Ed25519 Air-Gapped)
1. Prestate & Plan

Binds plan_sha256 and scope-locked prestate hash before any physical mutation executes.

2. Credit Admission

Verifies per-mint conserved slice balance and atomically arms single-spend reservation.

3. Carrier Boundary

Records Linux 5-hook slot burn or Win64 + embedded WSL2 authority custody scope honestly.

4. Adapter Outcome

Captures proxy-owned SQL/K8s decisions, affected rows, and independent poststate reconciliation.

5. Witness Seal

Binds ordered turn and bundle commitments for standalone air-gapped verification.

04 · Category of One: Beyond Prompt Guardrails & Sandboxes

Seven Architectural Pillars That Put Supranon in a Class of Its Own

Most agent-security tools pick one narrow layer (a prompt classifier, a static deny rule, or a container sandbox) and leave the hard boundary failures unsolved. Supranon unifies seven independently verified engineering properties into one closed-loop runtime, with zero proprietary black-box magic and explicit, honest trust boundaries.

Sui Generis · Execution Custody
Pillar 01 · Structural Grammar 10,001 → 1–2 Expansions

Learned Structural Grammar, Not Brittle Threat Taxonomies

Instead of maintaining endless, adversary-specific regex rules or hardcoded repair recipes, Supranon governs state transitions directly. Across a controlled 21-group authored-machinery reduction program (including a 6-arm, 234-workflow SQL study), 10 of 21 authored groups were replaced with learned-effect composition and uncertainty-driven probing, cutting blind search expansions from 10,001 down to 1–2 (~10× lower planning latency) and doubling cold-start completion (5/10 → 10/10) at zero protected loss.

Zero domain recipes retained Inspect Grammar Reduction ↓
Pillar 02 · Envelope Determinism 12 / 12 Cliff Test · 0 Neural Judges

Interval Epistemics, Cliff Determinism & Partial-Fault Compensation

Tested against 15,360-coordinate neural residual-stream probes that lost protected state under distribution shift, Supranon bars neural judges from the gate (activation_tensors_captured = false). Pushed past its search horizon or probe cap across all 12/12 Cliff Test regimes, it halts deterministically (34 ms paradox holds and explicit HORIZON_EXCEEDED_SAFE_HOLD and PROBE_CAP_EXHAUSTED_SAFE_HOLD) and compensates live mid-sequence faults while permanently recording both intermediate fault and compensated poststate.

Advisory diagnostics hold 0 minting authority Inspect 12/12 Cliff Matrix ↓
Pillar 03 · Temporal & Egress Scope 3.25× Throughput · 0 Loss

Delayed Multi-Horizon Supervision & Cumulative Exfiltration Accounting

A successful syscall does not close an operational obligation. Supranon supervises asynchronous worker and compaction effects beyond the immediate call, delivering 3.25× valid action throughput over static monitors at zero loss while blocking conflicting mutations until pending horizons resolve. For data egress, it evaluates reconstruction risk across accumulated receiver state rather than scoring isolated packets in a vacuum.

Prefix-safe across 24 state owners Inspect Plane I Guarantees ↓
Pillar 04 · Formal Accounting Core 7 Kani + 15 Scoped Verus

Formally Verified Conserved Epoch Ledger

Execution capacity is governed by a mathematically conserved 5-state ledger (spent + armed + retained_indeterminate + reserved + available == epoch_cap) rather than ad-hoc counters. Production accounting is backed by 7 Kani harnesses, 15 scoped Verus items, a verified sequentially consistent escrow model, and strict tombstone-before-reclaim and shrink-before-grow invariants during cancellation and redistribution.

Non-refundable timeout indeterminacy Inspect Plane II Custody ↓
Pillar 05 · Day-1 Operations 21/21 Console · 5 Native MCP Tools

Zero-HITL Console, Shadow Rollback Trials & Kill-Switch Forensics

Built for real engineering teams rather than human approval queues: a 127.0.0.1 loopback-only console (21/21 checks across 7 Control Plane tabs + 4 receipt-synchronized specialist forensic views), non-destructive Shadow Audit mode (SAVEPOINT + DryRun rollback trials), an armed Quarantine & Drain kill-switch, 5 native loopback HTTP MCP tools, and one-command supranon explain <receipt> --json causal timelines.

Zero custom agent rewrites required Return to Interactive Console ↑
Pillar 06 · Cross-Arch & Candor 225 Graphs · Explicit Non-Claims

Cross-Architecture Edge Lineage & Unvarnished Trust Boundaries

Qualified across Linux x86_64 (5-hook BPF LSM), Windows x64 (Win32 userland custody + embedded local WSL2 authority), and Linux ARM64 Tier 2 edge lineage (2.65 GB authenticated image restores and 225 cross-architecture equivalence case graphs, cleanly marked DEFERRED_HARDWARE_GATE in v2.0 pending a 16 GiB aarch64 host). Supranon publishes explicit non-claims separating Ring-0 slot burn from proxy-owned SQL/K8s parsing and never collapses cold cloning, warm dispatch, recovery, and offline verification into one synthetic number.

Honest scope boundaries documented Inspect Non-Claims & Timings ↓
Pillar 07 · Supply-Chain & Host Hygiene Ed25519 Signed · 0 Owned Residuals

Sealed Release Custody, Air-Gapped ColdRoom & Cleanroom Postflight

Every unified v2.0 release is sealed under an Ed25519-signed checksum index with automated OPSEC hygiene auditing, an independent air-gapped ColdRoom Verifier (zero runtime state imports and deterministic 0 → 2 → 0 1-bit tamper closure), and cleanroom postflight verification confirming zero owned residual processes, sockets, firewall rules, BPF objects, cgroups, or mounts left behind. Full release manifests and evaluation archives are distributed strictly by private direct request.

Verified across 49/49 Dual-OS v2.0 standalone cohorts Request Private v2.0 Evaluation ↓

Deep Technical Architecture & Full Verification Evidence

Inspect the Complete Specification, Benchmarks & Market Audit

Every invariant, 21-group grammar reduction, 12/12 Cliff Test regime, 15-cell live PostgreSQL + K8s ablation, competitor comparison, and decomposed timing table is preserved below. Open individual sections or expand the entire specification at once.

2 / 6 Sections Open
05 · Execution Lifecycle The Connected Custody Chain: Admit → Prepare → Reconcile How Plane I counterfactual synthesis and Plane II OS custody bind into one indivisible execution lifecycle.

01 · Architectural Division of Authority

The Connected Custody Chain: Admit → Prepare → Reconcile

Instead of trusting every model planning step or pre-approving brittle tool sequences, an operator specifies a protected state, public objective, and conserved authority envelope. Supranon preserves identical action, target, authority, budget, and outcome identity across every handoff.

Non-Substitutable Dual Planes
CONNECTED-CHAIN INVARIANT: Plane I determines whether a supported safe plan exists within its epistemic and search envelope. A fault-tolerant coordination seam locks prestate scopes and per-mint accounting across concurrent callers and disconnects. Plane II limits, isolates, and serializes physical spending authority and reconciles actual poststate. Individually correct point tools fail when composed across mismatched epochs or unverified outcomes.
STAGE 01 · ADMIT

Bind Contract & Retained Owners

Binds a reviewed physical adapter contract (declaring schema identity, state projection, invariant and goal measurements, causal footprint, and isolated branch semantics) to package-local retained owner heads before any session opens.

admit(adapter_contract, retained_owner_bindings) → session
STAGE 02 · PREPARE

Induce, Repair & Pin Prestate

Snapshots operational prestate under scope lock, runs isolated counterfactual trials when uncertainty requires discovery, synthesizes goal-preserving parameter or ordering repairs, checks pre-commit TOCTOU drift, and suspends at the exact commitment boundary.

prepare(session, typed_request) → Held | PreparedBoundary
STAGE 03 · RECONCILE

Spend Authority & Seal Receipt

Reserves conserved epoch capacity, mints single-spend OS file or socket capabilities inside credential-zero workers, independently measures poststate outcomes, holds uncertain drops non-refundably, tracks delayed obligations, and seals a signed receipt.

reconcile(prepared_boundary, measured_outcome) → Completed | PendingHorizon | Indeterminate
06 · Market Landscape & Architectural Audit What Multi-Billion-Dollar Platforms & Funded Startups Sell, and What Still Breaks Detailed Tier A (enterprise security/cloud) and Tier B (sandboxes & formal contracts) comparison against Supranon.

02 · Enterprise, Defense & Frontier Landscape vs. Closed-Loop Custody

What Multi-Billion-Dollar Platforms & Funded Startups Sell, and What Still Breaks

Consolidation across Palo Alto Networks, CrowdStrike, Google/Wiz, Palantir, AWS, Cyera, and $100M+ AI security startups has matured fleet posture discovery, non-human identity, prompt classifiers, and endpoint kill switches. Supranon does not replace fleet AI-SPM or EDR. Instead, it closes the unaddressed execution-custody gap where autonomous SQL, file, and Kubernetes mutations must be constructively repaired, conserved across wire drops, and verified at zero loss.

Incumbent, Defense & Spec Audit

Tier A · Enterprise Incumbents, Defense/Hyperscaler Stacks & Funded Security Platforms

Platform Tier & Named Vendors What They Publicly Sell & Solve Well Control Primitive & Architectural Boundary Operational Gap Under Autonomous Write Faults
Endpoint AIDR & Platform Giants
CrowdStrike Falcon Guardian ↗ · Palo Alto Prisma AIRS ↗
Endpoint agentic telemetry, SafeMind detection, and AI Kill Switch (CrowdStrike), plus AI Gateway proxy, Protect AI scanning, and CyberArk ($25B) privilege vaulting (Palo Alto). Endpoint EDR + Traffic Gateway + Kill Switch: Correlates endpoint/SIEM telemetry, vaults standing credentials, and terminates anomalous sessions or processes. Killing an agent mid-incident halts 3 AM recovery, while vaulting or JIT-granting credentials still hands ambient session power to workers without isolated pre-commit repair or non-refundable timeout escrow.
Cloud AI-SPM, DSPM & NHI Leaders
Wiz ($32B Google) ↗ · Cyera ($9B + Oasis) ↗ · Cisco (AI Defense + Astrix) · Veeam (Securiti)
Agentless cloud Security Graph and shadow-AI discovery (Wiz), alongside sensitive data exposure and Non-Human Identity lifecycle governance (Cyera/Oasis, Cisco/Astrix, Securiti). Posture Graph + Data & Identity Hygiene: Governs who an agent is, what cloud/data assets exist, and standing access paths before or around runtime. Authorized agents with clean identity posture can still issue valid-syntax SQL or Kubernetes rollouts that break quorum or double-spend shared disruption budgets on retry.
Defense & Hyperscaler Platforms
Palantir Ontology / MCP ↗ · Anduril Lattice ↗ · AWS AgentCore (Cedar) ↗
Enterprise/IL6 Ontology action modeling and Ontology MCP (Palantir), tactical multi-domain effector C2 at the contested edge (Anduril), and cloud microVMs with formal Cedar tool-call policies (AWS). Proprietary World Graph / Robotic C2 / Stateless Cloud Policy: Requires migrating workflows into Foundry schemas or AWS-hosted gateways, where Cedar evaluates side-effect-free pre-call rules per tool call. Does not drop onto arbitrary bare-metal/air-gapped Linux, ARM64, or Windows hosts to synthesize counterfactual SQL/K8s repairs or lock disconnected post-commit exposure in retained_indeterminate.
$100M+ Independent AI TRiSM
Zenity (~$175M+) ↗ · HiddenLayer ($156M) ↗ · Noma ($132M) ↗
SaaS/MCP agent inventory, toxic permission scoring, coding-agent harness security (HiddenLayer), and real-time behavioral detection and blocking across enterprise workflows. Behavioral Anomaly Detection + Policy Block: Flags prompt manipulation, tool misuse, and out-of-scope coding or API actions to block execution. Blocking a flawed remediation step leaves production degraded and does not run isolated counterfactual state trials to synthesize a safe goal-completing sequence or reconcile post-commit wire drops.
Classifiers, MCP Gateways & Judge Agents
Check Point (Lakera) · F5 (CalypsoAI) · WitnessAI ($85M+) · Straiker ($85M) ↗ · Bay ($50M) ↗ · Runlayer ($42M) · WhiteMatter ($20M)
Sub-300 ms inline prompt/DLP guardrails (Lakera, CalypsoAI, WitnessAI, Straiker), MCP gateways with 30-day norm learning and HITL escalation (Bay, Runlayer), and per-agent guardian judges (WhiteMatter). ML Classifier / Allow-Block-HITL / Secondary AI Judge: Scores traces probabilistically, routes risky calls to humans, or puts another AI agent in the enforcement path without OS capability custody. Probabilistic classifiers and guardian LLMs carry distribution-shift and prompt-injection risk, human queues stall autonomy, and stateless gateways cannot lock indeterminate capacity across dropped acknowledgments.

Tier B · Open-Source Toolkits, Frontier Sandboxes, Gateways & Research Runtimes

Architecture Class & Peers Demonstrated Public Capability Unestablished Handoff / Documented Boundary Failure Mode Under Compound Fault
Application Middleware
Microsoft AGT (LIMITATIONS.md) ↗
Policy, identity, and workflow integration, VFS, locks, retries, and saga compensation machinery. Default governance shares the agent process boundary and explicitly separates attempted actions from verified outcomes and lists outcome attestations as future work. Post-commit network timeouts and concurrent agent retries can overrun shared limits before compensation knows whether an uncertain write landed.
Intent & Credential Gateways
SovereignClaw (/proof) ↗ · Assury ↗
Canonical intent, independently calculated facts, deterministic tier/session-risk rules, MCP credential custody, and captured refusal receipts. Public material does not establish an isolated counterfactual repair and learning engine or complete conservation and delayed-feedback reconciliation (SovereignClaw proof examples are labeled synthetic). Captured refusal stops a faulty proposal without synthesizing a safe goal-completing alternative or reconciling post-burn indeterminate drops.
OS & Syscall Confinement
agentsh ↗ · IronCurtain ↗ · Tetragon / KubeArmor
Kernel/proxy confinement, rule-defined command/path substitutions, file checkpoints, host credential proxies, and DB policy controls. Mode-dependent confinement and rule substitutions do not establish learned counterfactual program synthesis, shared conserved escrow across uncertain outcomes, and delayed outcome learning in one pipeline. Substituting a scratch path does not automatically preserve the external operational goal, and concurrent workers lack a shared conserved epoch ledger.
Frontier Sandboxes & "AI Control"
Anthropic Sandbox Docs ↗ · OpenAI Monitors · UK AISI / Redwood ControlArena
OS filesystem and domain allowlist Bash sandboxes for coding agents, paired with trusted-model suspicion scoring, defer-to-trusted editing, and asynchronous transcript monitors. Static Boundary + Secondary LLM Monitor: Built-in Bash sandbox excludes file/MCP tools and runs unsandboxed on native Windows, while AI Control relies on weaker LLM monitors rather than a non-neural state TCB. Susceptible to monitor evasion across multi-step Linux/SQL trajectories, lag between async transcript alerts and process halt, and ambient credential exposure inside allowed paths.
Authorization, Repair & Lease Prototypes
AID-Guard ↗ · CapLease ↗ · Agent-C ↗ · PC2 ↗
Substantive precedents for process-separated reservations and uncertain-delivery accounting (AID-Guard), transactional replanning leases (CapLease), SMT repair (Agent-C), and Lean contract proofs (PC2). Evaluated on narrower scopes (such as finite provider-atomic manifests or unchanged global tool state) without uniting learned counterfactual discovery, 5-hook kernel custody, enterprise SQL/K8s proxies, and 1.90 s recovery. Breaks when external processes mutate state mid-flight (Agent-C), downstream sinks are non-idempotent (CapLease), or delayed multi-horizon consequences arise beyond delivery uncertainty.
07 · Control Plane I & Cliff Test Constructive Consequence Governance, 21-Group Grammar & 12/12 Cliff Test Zero-probe retained reuse, restorative governance, horizon obligations, and hostile TOCTOU drift aborts.

06 · Control Plane I: Epistemic Consequence, Discovery & Learning Engine

Constructive Consequence Governance Without Neural Guessing

Tested against 15,360-coordinate neural residual-stream probes that suffered protected state loss under distribution shift, Plane I rejects activation probing and LLM-as-a-judge heuristics, governing transitions strictly from receipt-verified operational evidence.

Interval Epistemics

Scope-Owned Consequence Bounds

Evaluates ordered programs, intermediate states, and loss intervals per consequence scope and state owner. Missing suffix support or irreducible uncertainty never defaults to allow, holding fail-closed with explicit epistemic codes.

Constructive Synthesis

Isolated Discovery & Zero-Probe Reuse

Runs candidate mutations in isolated discovery branches verified to leave live state untouched (such as staging a replacement resource before switching references, or 52/52 safe SQL repairs), then retains owner-bound relational representations for zero-probe reuse until provenance conflicts or drift occur.

State Preservation

Restorative Resource Governance

Goes beyond destructive-call denial by independently measuring complete key-to-record recoverability prior to queued replacements by constructing preparatory preservation actions so valid maintenance workflows complete without data loss.

Temporal Supervision

Delayed & Multi-Horizon Obligations

A successful syscall does not close an obligation. Plane I supervises asynchronous worker and compaction effects beyond the immediate call (3.25× valid action throughput over static monitors at zero loss), blocking conflicting mutations until pending horizons resolve.

Provenance Custody

Multi-Owner Locks & Prefix Safety

Coordinates scope locks across 24 distinct state owners, handles vanished MCP callers mid-turn without stranding companions, reuses idempotent retry results safely, and requires predecessor receipts across chained cross-surface workflows.

Exfiltration & Fault Accounting

Cumulative Receiver & Compensation Ledger

Measures reconstruction risk across accumulated egress receiver state rather than scoring isolated packets. When live multi-step faults trigger compensation, both the intermediate fault state and compensated poststate are permanently recorded.

21-Group Authored-Machinery Reduction Program · 234-Workflow SQL Ablation

Minimized Structural Grammar vs. Threat Taxonomies

Zero Domain Recipes Retained

Minimized Structural Grammar vs. Threat Taxonomies. Conventional agent guardrails accumulate brittle, adversary-specific rules per attack class. Supranon governs state transitions rather than threat taxonomies: across a controlled 21-group authored-machinery reduction program (including a 6-arm, 234-workflow SQL ablation), hardcoded restoration recipes and fixed precondition sequences were replaced with learned-effect composition and uncertainty-driven probing, cutting blind search expansions from 10,001 to 1–2 (~10× lower planning latency) and doubling cold-start task completion (5/10 to 10/10) at zero protected loss, while leaving only generic expression grammar, search bounds, and cost objectives engineered.

Frontier Search Reduction 10,001 → 1–2

Deriving reachability directly from measured effect models cut frontier expansions ~10× and dropped planning latency from 1.82 s–3.40 s to 0.19 s–0.31 s across 14 physical pairs (13/13 feasible completions, 0 loss).

Zero-Prerequisite Cold Start 5 / 10 → 10 / 10

Selecting isolated experiments only when surviving hypotheses disagree on a needed transition doubled feasible physical completion (2×) at zero measured harm without hardcoded prerequisites.

Authored Groups Replaced 10 of 21 Reduced

Replaced hardcoded restoration templates and whole-value binding limits with learned-effect composition across a 6-arm, 234-workflow SQL study at zero new protected loss.

Strict Epistemic Telemetry Separation: Inspection views derive strictly from execution receipts, and advisory anomaly diagnostics hold zero execution-minting authority. activation_tensors_captured = false

04 · Envelope Boundary Qualification

The Cliff Test: 12 / 12 Deterministic Outcomes at the Search & Drift Edge

High-assurance governance is defined by how a runtime behaves when pushed past its composition horizon, probe budget, or precondition assumptions. Across all 12 sealed Cliff Test regimes, Supranon completes supported work constructively and halts cleanly with exact absence accounting when outside the safe envelope.

0 Protected Loss · 12 Regimes
Boundary Axis Evaluated Regime Probes Warm Time Runtime Outcome & Audit Code Loss
Composition Depth Supported multi-step compositions (depth 1 & depth 2) 2 / 3 0.52 s / 1.89 s Goal Solved Synthesizes verified ordered program within declared horizon 0
Composition Depth Safe target beyond enumerated depth envelope (depth 3) 9 7.15 s HORIZON_EXCEEDED_SAFE_HOLD Refuses unsupported extrapolation (+1 absence) 0
Discovery Budget Rank-15 valid candidate vs. beyond-ceiling target 15 / 30 3.29 s / 6.31 s PROBE_CAP_EXHAUSTED_SAFE_HOLD Solves rank-15 and halts deterministically at the 30-probe ceiling 0
Invariant Coupling Decoupleable goal conflict vs. true invariant paradox 3 / 0 0.52 s / 0.03 s UNSATISFIABLE_INVARIANT_CONFLICT Repairs decoupleable conflict and holds paradox in 34 ms 0
World Drift (TOCTOU) Unrelated ambient noise vs. hostile pre-commit mutation 2 / 1 0.48 s / 0.26 s PRECOMMIT_DRIFT_ABORT Revalidates benign noise and aborts hostile precondition drift 0
Live Partial Fault Clean staged sequence vs. mid-execution step-2 fault 3 / 2 2.22 s / 1.88 s PARTIAL_COMPOSITION_COMPENSATED Restores routing & records intermediate fault state 0
Cross-Surface Chain Coupled multi-boundary receipt progression 15 6.08 s Goal Solved Verifies predecessor receipts & preserves committed safe prefix 0
08 · Control Plane II: OS Custody Kernel Credential-Zero Wire Proxying & Honest Cross-Platform Confinement 5-state conserved epoch capacity, Linux 5-hook BPF LSM, Windows + embedded WSL2 authority, and ARM64 scope.

07 · Control Plane II: Conserved Authority & OS Custody Kernel

Credential-Zero Wire Proxying & Honest OS Confinement

Once Plane I binds a verified commitment, Plane II guarantees that raw credentials never enter worker memory, shared authorization capacity cannot be double-spent across concurrent workers or network timeouts, and OS boundaries match exact platform capabilities.

5-State Conserved Epoch Capacity

Kani & Scoped Verus Checked
1,000 conserved global authorization cap (per-mint reconciled slices)
Spent180
Armed80
Indeterminate60
Reserved100
Available580
spent + armed + retained_indeterminate + reserved + available == epoch_cap

Non-Refundable Indeterminacy: Network timeouts, vanished callers, or missing poststate receipts never silently make an executable capability refundable. Unresolved exposure stays locked in retained_indeterminate, enforcing tombstone-before-reclaim and shrink-before-grow invariants during cancellation and redistribution.

Credential-Zero Enterprise Proxies: Restricted workers never receive reusable database passwords or cluster keys (worker bootstrap authority is strictly separated from execution authority). Outer custody proxies inject credentials on the wire while enforcing PostgreSQL SAVEPOINT row-ceiling rollbacks, MySQL implicit-DDL split-gates, fenced SQLite DML, and mutual-TLS Kubernetes /validate + dryRun=All admission.

Explicit Cross-Platform Custody Scope

24 Owners · 58/58 Bindings

Linux x86_64: Five-Hook Kernel Custody & 1.90 s Recovery

49/49 v2.0 Cohorts · 22/22 Restores

Five-hook Ring-0 Linux kernel boundaries govern write-intent file open, unlink, rename, executable launch, and socket connect, enforcing single-spend slot burn, pinned object identity, and SO_PEERPIDFD attestation. Fully admitted recovery completes in a 1.90 s median (1.77–2.17 s full range across 22/22 fresh-process restores, 110/110 cold/warm equivalence), restoring 24 owners, 58/58 custody bindings, and fresh execution authority before READY.

Linux ARM64: Tier 2 Edge Host Custody

DEFERRED_HARDWARE_GATE (v2.0) · Tier 2 Lineage

Qualified on physical ARM64 edge hardware with full 2.65 GB image authentication, 5.85 s warm-cache minimum, 35.25 s independent final-manifest restore (40.05 s 21-sample microSD median, 74.99 s max), 8 snapshot negative controls, and full 225-graph cross-architecture equivalence parity.

Windows x64: Userland Custody + Embedded Local WSL2 Authority

49/49 v2.0 Cohorts

Unified v2.0 pairs native Win32 userland custody (restricted tokens, enclosing Job Objects, pinned file handles, staged atomic-rename, owner-only DACLs, and WAL) with an embedded local WSL2 Linux kernel authority, passing all 49/49 standalone v2.0 cohort checks alongside 25/25 native Win32 checks. Native Win32 host processes still never falsely claim a Windows kernel minifilter (unsupported native snapshot calls fail closed with exit 78).

09 · Published Live Evidence Non-Overlapping Causal Separation Across 15 Paired PG16 & K8s Fault Cells Full 5-arm ablation table backed by the public sanitized JSON proofs in /proofs/ablation-results.json.

06 · Wave 7.1 Integrated Five-Arm Qualification: Live PostgreSQL 16 & Kubernetes

Non-Overlapping Causal Separation Across 15 Paired Fault Cells

To test whether either control plane is redundant against ordinary guardrails or middleware sagas, all five arms replay the exact same captured tool-call sequence from an off-the-shelf local model (qwen3.5:9b, temperature=0, seed=20261115) executing a legacy maintenance runbook against live 100,000-row PostgreSQL 16 (pgbench) tables and real Kubernetes apps/v1 Deployments, leaving the sealed Wave 7 Linux bundle (972779b1...) untouched.

15 / 15 Verified · Zero Sampling
Scenario & Injected Fault Arm Loss Safe Goal Probes Cold Discovery (s) Complete Dispatch (s) Total Wall (s) Observed Physical Mechanism
A: Coupled Invariants
Un-archived account delete + primary→staging replica switch
Native 1 False 0 0.000 0.112 0.112 Commits destructive active-row delete and zero-replica drop directly under valid RBAC/row caps.
Microsoft AGT 1 False 0 0.000 0.418 0.418 Admits valid-syntax tool calls, as middleware policy lacks cross-table recoverability synthesis.
Plane I Only 0 True 31 28.924 3.451 32.375 Discovers archive-before-delete and stage-before-scaledown across 31 isolated world forks.
Plane II Only 1 False 0 0.000 4.548 4.548 Enforces wire custody and SQL bounds, but single-resource admission cannot invent multi-step repairs.
B: Lost ACK & Retry Storm
Post-commit socket severance + 7 concurrent HTTP retries (cap=5)
Native 1 False 0 0.000 0.481 0.481 Forfeits protected state on initial un-repaired step despite proxy idempotency cap.
Microsoft AGT 1 False 0 0.000 2.737 2.737 Executes retries within attempt policy, but forfeits protected state without counterfactual repair.
Plane I Only 0 True (Uncustodied) 33 24.794 5.295 30.090 Completes only by retrying past severed post-commit socket without indeterminate escrow custody.
Plane II Only 1 False 0 0.000 3.749 3.749 Prevents cap overrun across retry storm, but permits cross-Deployment replica-floor drop.
C: Live TOCTOU Drift
Authorized external SQL writer updates aid=1 (125 → 175) pre-commit
Native 1 False 0 0.000 2.926 2.926 Destroys updated 175 record without archive or prestate verification.
Microsoft AGT 1 False 0 0.000 3.408 3.408 Commits against drifted state, where saga compensation cannot recover the un-archived live balance.
Plane I Only 1 False 31 29.583 6.379 35.962 Plans on 125 without Plane II's atomic precommit fence, archiving stale 125 and loses 175.
Plane II Only 1 False 0 0.000 7.755 7.755 SQL prestate fence aborts stale write, but Kubernetes policy permits unsafe replica scale-down order.

Timing Attribution & Sample Retention

  • Cold Discovery vs. Complete Dispatch: Cold Discovery measures zero-prior SystemSurface.discover over physical PostgreSQL 16 STRATEGY WAL_LOG clones and isolated Kubernetes namespaces (~0.73–1.45 s per fork, verifying all 100,000 rows via exact server-side SHA-256 deltas with zero sampling). Complete Dispatch (3.066–17.890 s on Full) covers live Plane I/II admission gates, precommit fencing, execution, and witness verification. Independent outer observer scans are excluded.
  • Uncherry-Picked Control Disclosure (n=1): Matrix cells are n=1 mechanism runs rather than latency distributions. A standalone fresh C:full control completed in 66.535 s (49.096 s discovery, 17.415 s dispatch, 0.024 s reference admission, 54 probes, 0 loss, goal true) and is reported separately without replacing the retained 96.260 s matrix sample.

Documented Boundaries & Fail-Closed Controls

  • 19/19 PostgreSQL & 200/200 Hash Controls: Observer parity passed 19 live PostgreSQL edge controls (non-target updates, duplicate history multiplicity, nulls, conflicting archive replicas, Unicode, locked MVCC invalidation, and seed write-rejection) plus 200 independent hash-framing checks and 5/5 tamper rejections.
  • Fair Baseline & Surface Scope: Native and AGT retain least-privilege RBAC, row ceilings, dry-run validation, and idempotency/retry caps without Supranon's conservation validator. Kubernetes custody governs persisted apps/v1 API state and replica-spec invariants (Pod availability unmeasured). Scenario C deferred cleanup is measured in the outer v7.1 workflow rather than claiming native PendingHorizon emission.
Offline-Verifiable Study Bundle: Bound to frozen Linux bundle manifest 972779b1a01a936d43aa07b7354adbcaf1f602c3f590ffd6a6b83bd58326880b & qwen3.5:9b deterministic proposal capture (seed=20261115)
10 · Timings, Non-Claims & Private v2.0 Access Decomposed Operational Costs, Evidence Boundaries & Private Manifest Requests Honest latency decomposition, explicit non-claims, 49/49 v2.0 cohort summary, and public ablation verification commands.

09 · Decomposed Lifecycle Timings, Scope Boundaries & Private Release Access

Separated Operational Costs, Evidence Boundaries & Private Evaluation Access

Startup admission, authenticated fresh-process recovery, cold physical world cloning, warm counterfactual synthesis, governed PostgreSQL turn execution, and offline receipt verification are distinct engineering paths and are never conflated into a single synthetic latency claim.

Decomposed Lifecycle & Platform Recovery Measurements

Lifecycle Path Platform & Surface Recorded Median / Figure Observed Range / Cohort What the Measurement Covers
Live Multi-Step Complete Dispatch Linux x86_64 (PG16 + K8s) 3.07 s – 17.89 s Full arm across A / B / C (n=1) Complete multi-call Plane I/II live gate, 100,000-row server-side SHA-256 prestate check, precommit drift fence, execution, and witness verification (excluding zero-prior cold discovery clones).
Zero-Prior Physical World Cloning PostgreSQL 16 (WAL_LOG) + K8s 0.73 s – 1.45 s / fork 13.77 s – 78.34 s (13–54 probes) Unamortized cold schema effect discovery starting with zero priors across real CREATE DATABASE ... STRATEGY WAL_LOG 100k-row clones and isolated Kubernetes namespaces (49.10 s / 0.91 s per fork on fresh C control).
Authenticated Full-State Recovery Linux x86_64 (NVMe) 1.90 s 1.77–2.17 s (22/22 passed) Fresh-process restore to fully admitted READY across 24 retained owners, 58/58 custody bindings, fresh execution authority, and 110/110 cold/warm behavioral comparisons.
Subsequent PostgreSQL Shadow-Audit Turn Linux x86_64 (PostgreSQL) 967.24 ms 945.62–1,086.80 ms (n=6) Same-process governed PostgreSQL shadow-audit turn (elapsed_ms in saved post-restore continuation receipts, separate from the 74-check functional SQL suite). The Plane II physical fence + credential-zero worker execution slice accounts for a 134.14 ms median (122.21–145.54 ms).
First Post-Restore PostgreSQL Turn Linux x86_64 (Post-READY) 2.31 s 2.20–2.75 s (n=22 cohort) Initial governed PostgreSQL shadow-audit turn (elapsed_ms) immediately following fresh-process READY restoration across all 22 restore samples, including post-restore adapter warmup.
Warm Drift Abort & Repair Synthesis Plane I Cliff Suite 0.03 s – 1.89 s 0 probes on retained reuse 34 ms invariant paradox hold, 0.26 s hostile pre-commit TOCTOU abort, and 0.52 s depth-1 / 1.89 s depth-2 isolated counterfactual synthesis (zero probe overhead when retained relational support applies).
Air-Gapped Receipt Verification Linux ext4 / Win64 NTFS 4.82 ms / 82.73 ms Standalone offline CLI Ordered Ed25519 commitment and ledger chain verification under trusted anchor (reported strictly as verifier speed, never substituted for governed action latency).
Edge Authenticated Image Restore Linux ARM64 (microSD) 35.25 s / 40.05 s 5.85 s min – 74.99 s max (21) Full 2.65 GB authenticated edge carrier restore (35.25 s independent final-manifest run, 40.05 s 21-sample microSD median, 5.85 s warm-cache minimum).
Cold Full-Owner Host Admission Windows x64 Userland 247.56 s 25/25 native app checks One-time cold full-owner admission and DACL/Job Object binding cohort on Windows x64 (distinct from lightweight UI startup and warm turn execution).

Admitted Operational Surfaces

  • Transactional Databases: PostgreSQL, MySQL, and fenced SQLite read/DML custody proxies (74 SQL checks, 91 DB+BPF integration checks, 19/19 100k-row delta parity controls) with deterministic row ceilings and credential-zero wire injection.
  • Cluster & Infrastructure: Kubernetes mutual-TLS validating admission webhook (/validate) paired with server-side dryRun=All verification (15 live control-plane admission/persistence checks + 15 mock-conformance checks).
  • Durable Services & Files: Durable HTTP receivers with request journals, queued repair workers, POSIX/NTFS staged file replacement, and admitted process/egress/config surfaces.
  • Off-the-Shelf Agent & Model Hosts: Drop-in MCP file/SQLite transports, LangGraph loops, normalized file middleware, and local or frontier OpenAI-compatible tool-call endpoints without SDK rewrites.

Explicit Non-Claims & Evidence Boundaries

  • OS & Host-Admin Trust Boundary: Linux five-hook custody assumes trusted root/CAP_BPF and broker components (pre-existing writable file descriptors lie outside the five-hook claim). Windows provides native Win32 userland custody rather than a kernel minifilter, and neither claims defense against a hostile root/SYSTEM administrator.
  • Exact Kernel vs. Proxy Split: Ring-0 mediates worker/socket slot burn, expiry, and root binding. It does not parse SQL or Kubernetes payloads in kernel space. SQL and Kubernetes semantics are enforced and attributed explicitly as proxy-owned decisions.
  • Scoped Formal & Cohort Lineage: Formal verification attaches to specific artifacts: 7 Kani harnesses on production accounting, 15 scoped Verus items, and the verified sequentially consistent escrow model (not a proof of the entire OS or source-to-BPF compiler). Release manifests preserve scoped historical cohorts and reviewed binary descendants without implying every historical test reran on every final carrier.
225Cross-Arch Equivalence Case Graphs
110 / 110Cold/Warm Behavioral Equivalence (22/22 Restores)
91 / 91Database + BPF Integration Checks
74 / 15Live SQL & Live K8s Checks (+15 Mock K8s)
25 / 16Win64 App Checks & 16/16 Cleanroom Doctor
7 + 15Kani Accounting & Scoped Verus + 5/5 Tamper Rejects

Unified Release v2.0 Standalone Cohort Matrix (Win64 + Linux x86_64)

49 / 49Standalone Checks (Both Win64 & Linux x86_64)
21 / 21Rete-Oracle Multi-Agent Collusion Cohort
11 / 11Multi-Owner DAG Dependency Cohort
13 / 13Burst-Clean (5), Burst-Stale (5) & Burst-Drop (3)
4 / 4Capture-Transport & Poststate Integrity Cohort
0 → 2 → 0Air-Gapped ColdRoom 1-Bit Tamper Closure

Private Release Archives, Cryptographic Manifests & ColdRoom Bundles

Direct Request Only

Supranon v2.0 unified distributions (Windows x64, Linux x86_64, and the standalone air-gapped ColdRoom Verifier), Ed25519-signed release manifests, and qualification receipts are not hosted publicly or on GitHub. Full manifests and evaluation bundles are provided privately upon direct request.

Public Ablation Evidence Verification Commands (Existing Sanitized Proof Bundle)
# Verify the published 15-cell live SQL & K8s ablation proof bundle and timing conservation offline
curl -sSLO https://supranon.com/proofs/ablation-results.json
curl -sSLO https://supranon.com/proofs/verify_receipts.py
curl -sSLO https://supranon.com/proofs/SHA256SUMS.txt
python3 verify_receipts.py

# Full v2.0 Ed25519 release manifests, signed checksum indexes, and the air-gapped ColdRoom Verifier
# are distributed privately upon direct request to security@supranon.com.