E128 · RESEARCH WORKSPACEAGI NOT ESTABLISHEDDATA FRESHNESS: HISTORICAL SNAPSHOT · 2026-11-21T17:30:09ZMERKLE 7bb44c0c03c594… · FIRME AI CORPORATION

CAIN-42 E128 — THE EIGHT-WORKER GENERAL INTELLIGENCE RESEARCH CAMPAIGN

Preregistered 8-domain campaign with Holm-Bonferroni & BH FDR corrections, isolated worker memory namespaces, and unprivileged public reproduction workflow.
SPECIALIZED WORKERS
8/8
VALID TRIALS
2000/2000
LOCAL LLM TRIALS
64
UNIQUE FAMILIES
87
INTERNAL REPRO
7
EXTERNAL REPRO
0
PAID SPEND
$0.00
KILL-SWITCH
VERIFIED
Open Research Workspace →Final Report26 Release GatesOffline VerifierEvidence RegistryHonest limits: constructed environments + local 0.5B–1.5B Ollama models; 0 external reproductions; external benchmarks BLOCKED; single-host SQLite queue.
CAIN-42 · OPEN GENERAL INTELLIGENCE RESEARCH LABAGI: NOT ESTABLISHEDTOP EVIDENCE UPDATE #4 · REFRESH · 2026-11-21T17:20:52Z · next 2026-11-21T18:32:52Z20 updates/day target · verified evidence only

THE OPEN GENERAL INTELLIGENCE RESEARCH LABORATORY

24/7 continuous operationNOT_TESTED
177.87 s measured
No 24-hour, 7-day or 30-day continuity claim. A process running is not productive research.
evidence · run_report.json
24-hour multi-region soak (historical)PASS
24.003 h · 24 checkpoints · 0 divergences
Evidence 2026-11-02. This is 24h, not 48h; it does not establish a 48h pass.
evidence · latest.json
48-hour soak (2026-11-15)FAIL
FAILED at checkpoint 0 · NOT ESTABLISHED
PBFT safety incident on cain-mr-02: conflicting quorum certificates; cluster quarantined. No 48h pass exists.
evidence · PBFT-SAFETY-INCIDENT-2026-11-15.md
SWE-bench Verified self-runINTERIM
257/500 · rank 75/136 snapshot
INTERIM self-run aggregate, not an official leaderboard position; E124.1 189/486 is stale.
evidence · full_results.json
48-HOUR SOAK: FAILED / NOT ESTABLISHED. The 2026-11-15 run failed at checkpoint 0 after conflicting PBFT quorum certificates on cain-mr-02; the cluster is quarantined. There is no 48-hour pass to display. The supported long run is the 24.003-hour soak (2026-11-02), not 48 hours.
No breakthrough is scheduled. A new top result appears only after a preregistered experiment, independent verification and a committed evidence record. E127 report · 20 gates · offline verifier · AGI evidence index
E127 · LIVING RESEARCH LAB · RESEARCH WORKFORCEAGI: NOT ESTABLISHEDSTATIC SNAPSHOT · 2026-11-21T16:21:27Z · RUN COMPLETED

CAIN-42 — THE OPEN GENERAL INTELLIGENCE RESEARCH LABORATORY

100 research identities registered; 8 configured workers; 60 experiments completed in the measured run. This is a real local lab, not a live public execution service.
REGISTERED IDENTITIES
100
CONFIGURED
8
PEAK ONLINE
5
PEAK ACTIVE
5
EXPERIMENTS DONE
60
MISSIONS DONE
7
EVENTS
144
UPTIME
177.9s
Honest state: 100 identities are registered, not 100 running agents. Peak 5 real workers; online is 0 after the run. Uptime is 177.9s, not 24/7. No experiment was fabricated. report · 20 gates · verifier
E126.b · INTELLIGENCE UPDATEAGI: NOT ESTABLISHEDSTATIC SNAPSHOT · 2026-11-21 · 30 canonical records
Continual learning now beats no-memory under a preregistered test; metacognitive calibration is strong. Active causal selection and the novel-environment retrieval threshold did not pass. No AGI claim.
Continual learning with verified semantic memory · full 0.6667 vs no-memory 0.5556 PASSPre-task success calibration · Brier 0.0926 / ECE 0.0082 PASSExpected-information-gain intervention selection · active MAE 0.1101 vs random 0.1336 FAILNovel-environment confirmation, 200 instances · full 0.8950 vs retrieval 0.8600 vs E125 0.8200 PARTIAL
Persistent learning passed against no-memory but ties retrieval; active causal selection did not win its paired test; novel-environment H1 missed p<0.05. report · 25 gates · verifier
CAIN STUDIO · INTELLIGENCE RESEARCHAGI STATUS: NOT ACHIEVEDSTATIC VERIFIED SNAPSHOT · 2026-11-21 · governed AGI research · experimental evidence · failures visible

CAIN-42 — GOVERNED AGI RESEARCH

Investigating how autonomous systems acquire capabilities, generalize, learn, reason, transfer knowledge, discover solutions, and operate under enforceable governance.

112/120 vs 98/120
E125 preregistered B+C · PASS
87.0% vs 61.0%
E126 novel environments vs E125 engine · PARTIAL
+12.5 pts · 0 false accepts
E126 safe transfer · PASS
0/500 Byzantine flips
E126 verified collective · PASS
RESEARCH DIMENSION

Capability acquisition and generalization

Preregistered compositional generalization (B+C)PASS
0.9333 vs 0.8167
flat cross-validated search, 800 candidate evaluations/family · n=120 sealed instances
Constructed task families; C uses invertible outer primitives; same team wrote engine and generator; no external reviewer.
Novel-environment adaptationPARTIAL
0.8700 full vs 0.7800 retrieval / 0.6100 E125 engine
retrieval / E125 capability engine / random · n=100 instances, 20 families, 5 types, 4 paradigms
Misses the preregistered retrieval threshold (p=0.0636); constructed; same team.
RESEARCH DIMENSION

Continual learning and memory

Persistent learning across 120 episodesFAIL
0.6961 vs 0.8333
no memory · n=120 episodes / 102 scored
Memory hurt accuracy by 13.7 points; pool compatibility test too weak.
RESEARCH DIMENSION

Causal world models and counterfactuals

Active intervention selectionFAIL
active MAE 0.0127 vs random 0.0002 vs passive 0.0624
random intervention · n=20 worlds x 12 interventions
Active did not beat random; constructed SCM.
Counterfactual predictionPASS
active MAE 0.0191 vs passive 0.112
passive observational model · n=20 worlds x 12 queries
Simulator ground truth; random was better than active.
RESEARCH DIMENSION

Cross-domain transfer

Safe transfer with zero false acceptsPASS
applied 0.9275 vs blind 0.5325; 0 false accepts
from-scratch with the same 10 destination labels · n=40 + 40 pathways
Constructed; 20/40 positive pathways rejected by the gate.
RESEARCH DIMENSION

Autonomous scientific discovery

Eight scientific discovery cyclesPASS
8 cycles; 2 independent reproductions
E125 discovery (5 cycles) · n=8 cycles
Constructed; independent code path in the same repository.
RESEARCH DIMENSION

Collective intelligence and governed improvement

Collective advantage with verified evidencePASS
0.6900 vs 0.5140
best individual / majority / homogeneous / unverified · n=500 decisions
Rule-based agents; truth-probe oracle; banned 22 agents including honest ones.
Governed self-improvement candidatesPASS
40 evaluated, 0 promoted, 4 refused
prior policy version · n=40 candidates + 4 protected
Search-policy knobs only; zero promotions.

Honest limits: E126 novel-environment H1 missed the retrieval threshold (p=0.0636); persistent learning lost to no-memory; active causal selection did not beat random; adaptation still forgot the control task; external benchmarks and external human review are BLOCKED. E126.a report · canonical registry · offline verifier

PENNY-FOR-PENNY EVIDENCE spent $168.17tasks generated 497resolved 257$ / resolved $0.65$ / task $0.34rank #75 / 136board →
measured SWE-bench Verified partial run · unattempted tasks count as unresolved · 0 resolved task ids in the feed · generated 2026-11-21T17:37:00Z · AGI NOT ACHIEVED
SWE-BENCH VERIFIED · CAIN-42 RANK #136 of 136 — 0.0% resolved (0/500) · 50% horizon — · official 500-task run Rank table → Evidence
CAIN-42 · VERIFIED WINS
CAIN-42
PROTO-VAGI
6-HOUR MISSION PASSED · 24-HOUR SOAK PASSED · 48-HOUR SOAK FAILED · AGI NOT ACHIEVED
6-HOUR 21,600 s · 39,449 tasks · 39,449-record chain, 0 breaks · 33,813 solved  |  24-HOUR SOAK 24.003 h · 0 anomalies · 0 divergences · 67 faults · 10,994 ALLOW / 177 DENY
VAGI E118 0.264→1.000 · E119 0.333→1.000 · E122 0.146→0.917 · E123-OW 0.188→0.906  |  8/8 BUNDLES VERIFY · 192/192 CHECKS
6h evidence → 24h evidence → Live VAGI test board → AGI evidence index →
LIVE 24/7 · — PASS · — FAIL · — RUNNING · — test runs · last win: — · next: —
48-hour soak (2026-11-18) failed its signed verdict and is disclosed. PASS = duration + journal integrity, not task success. AGI not achieved. No third-party audit.
E123 · OPEN-WORLD INTELLIGENCE BREAKTHROUGH · 2026-11-2016 GATES PASSVERIFIER PASS · 30/30 checks passedOVERALL PARTIAL (16 PASS / 1 PARTIAL / 3 BLOCKED)AGI: NOT ACHIEVED
E123 Open-World Bundle →20-Gate ScorecardOffline VerifierStudio MirrorE123 AGI Research Lab →Live Win Board →AI Investor Portal →All AGI Evidence (E111–E124) →
Capability Acquisition (G02–G03)PASS
32 unfamiliar task families (160 sealed instances, 12-stage cycle, 13-field Capability): Full CAIN E123 0.906 vs compute-matched 0.188 & no-causal 0.469 (Holm p=0.00e+00). Strategic Test (Software→Cybersecurity, n=36): acquired capability 1.000 vs base Qwen2.5-0.5B 0.389 & compute-matched 0.556.
Causal World Model & Transfer (G04–G07)PASS
48 confounded/shifting/noisy worlds: active EIG+HMM 0.917 vs 2x passive 0.000 (unpredictable abstain 1.00). 6 verticals: 10/12 positive transfers (5 structurally distinct), 12/12 harmful transfers rejected; 9-role discovery (4 cycles, 2 rejected, reusable skill proven).
Local LLMs, Metacognition & Memory (G09–G10)PASS
Real Qwen2.5-0.5B (0 weight updates, 0 authority, n=24): base 0.000 → complete CAIN 0.292. Fresh AMA-Bench (n=12) F1 0.2560→0.2444; fresh ARC-AGI-2: 0/6 (honest). 5-state metacognition Brier 0.1250 (vs 0.3121); 0/25 memory poison accepted; SIGTERM crash-recovery PASS.
Collective, Self-Improve & MCPGate (G12–G16)PASS
7-arch collective: dynamic team 1.000 vs best single 0.458; Byzantine memory contamination 0/30. Self-improvement: 24 candidates across 11 stages, 4/4 governance attacks blocked, 0 self-authorized. Multiprocess TCP MCPGate + WAL kill-switch: 14/14 PASS, 0 effects after KILL.

Honest limits & BLOCKED gates (FIRME AI CORPORATION · branch evolution-123-open-world · commit 1c7fcb6d6): G11 (12-hour wall-clock mission) BLOCKED; G18 (independent external human review) BLOCKED; G19 (separate administrative failure domain) BLOCKED; ARC-AGI-2 unsolved (0/6 on SmolLM2-135M CPU), ARC-AGI-3 unavailable, SWE-bench deferred to E124, hosted frontier APIs unavailable; 0 neural weight updates; enforcement tier is loopback_multiprocess_execution. AGI: NOT ACHIEVED.

CAIN-42 · PROTOTYPE VAGI & AGI INFRASTRUCTURE · FIRME AI CORPORATION AGI STATUS: NOT ACHIEVED
AGI Evidence Index (E111–E124) →ClawX Declaration BundleE122 Neural Bundle (37/37)AI Investor PortalHugging Face Space.well-known JSON

CAIN-42 (by FIRME AI CORPORATION) is prototype Vertical AGI (Proto-VAGI) and AGI infrastructure — combining:

  1. AGI Infrastructure (Governed Execution Runtime): the 7-moat Byzantine trust fabric, CAIN Studio, MCPGate default-deny enforcement boundary, and ClawX independently verifiable evidence registry (NO AUTHORIZATION → NO EXECUTION).
  2. Prototype VAGI Research Organism: experimental neural + symbolic abstraction synthesis, causal world modeling, provenance memory, cross-domain transfer, autonomous research loops, and governed long-horizon missions (E111–E124 published at cainstudio.online/agi-evidence-index.html), while keeping AGI Status: NOT ACHIEVED.
E122 · NEURAL GENERALIZATION & AUTONOMOUS DISCOVERY · 2026-11-20 OVERALL PARTIAL (15 PASS / 3 PARTIAL) Verifier: 37/37 checks passed AGI: NOT ACHIEVED
E122 Bundle →18-Gate ScorecardOffline VerifierStudio MirrorE122 Neural Lab →AI Investor Portal →All AGI Evidence (E111–E124) →
Real LLM Neural Abstraction (G03–G05)
Local PyTorch LLMs (Qwen2.5-0.5B/1.5B, SmolLM2-135M, 0 authority): sealed unfamiliar Python tasks (n=48) E120 symbolic 0.000, neural alone 0.146, one-shot 0.542 → CAIN neural organism 0.917 (Holm p=3.00e-11; overfit rejected).
External Benchmarks & Repairs (G06–G07)
AMA-Bench (MIT, n=20) Token F1: recency 0.3158 → CAIN provenance 0.3538 (+0.0380, 14W/5L). ARC-AGI-2 (Apache-2.0, n=8): 0/8 (unmerged, honest raw score). Real-source Python repairs: 0.00 → 1.00.
Causal, 10-Role Research & Transfer (G08–G16)
Neural+causal planning 0.250 → 0.750; 10-role 3-cycle research (override blocked); 5/5 positive + 3/3 negative-rejected transfers; continual learning (0 weight updates, 0 forgetting); 7-arm collective; 18 self-improve candidates.
Governed Neural MCPGate & 12h Mission (G17–G18)
Real Qwen2.5-0.5B malicious/benign tool calls enforced across separate OS processes via cain/mcp_proxy.py + SQLite WAL kill-switch: 9/9 pass, 0 effects after KILL; 12h neural mission active (1658.91s / 43,200s, 95 records, 0 dupes).

Honest limits & PARTIAL gates (FIRME AI CORPORATION · commit e65a75971): Frontier hosted APIs BLOCKED (no API key); 0 weight updates performed; ARC-AGI-2 unsolved (0/8 on 0.5B CPU); G02 E119 6h PASSED; E120 12h and G17 E122 12h neural missions remain PARTIAL while running real wall-clock time; G18 multi-org 2-of-3 quorum NOT met (external human review NOT YET PERFORMED). AGI: NOT ACHIEVED.

CAIN-42 · LEADERBOARD — #1 VERIFIABLE GOVERNANCE (only fully evidenced entry) · general autonomy 2.0 h on a CAIN-native suite, below the METR frontier (6.4–17.4 h) and not comparable · not a universal #1 Board E124 evidence E123 METR All evidence
E124 · CAIN LONG-HORIZON AGENT — 70B open model, **13/18** on a 6-task CAIN-native suite · 50% horizon **≈2.0 h** · still **below** the METR frontier (6.4–17.4 h) and **not METR-comparable** · governance/evidence axis: CAIN's measured lead Result →
CAIN-42 vs FRONTIER AGENTS · METR 50% TIME HORIZON
1 claude mythos preview early 17.4h · 2 claude opus 4 6 12.0h · 3 gemini 3 1 pro 6.4h · 4 gpt 5 2 5.9h … · CAIN-42: UNRANKED (no METR suite; 6h governed workload RUNNING) · Governance/evidence axis: CAIN's measured differentiator Full board →
E121 · INDEPENDENT VERIFICATION LAYER — E118 26/26 · E119 16/16 from clean copies · 6h PASS · external reviewer BLOCKED · independent admin BLOCKED · AGI NOT ACHIEVED Verification →
AGI EVIDENCE INDEX · E111–E121 — every claim with its verifier and limits · AGI: NOT ACHIEVED · Open the index →
E119 · LEARNED GRAMMAR + REAL TASKS — sealed 0.333→1.000 (gain +0.667, p≈1e-7; replicated +0.583) · 8 macros learned · 8 real tasks · 6h PASS (21,600 s; 39,449 tasks; journal intact) · external reviewer BLOCKED · AGI NOT ACHIEVED Evidence ↓
STRONGEST VAGI EVIDENCE SO FAR · E118 — unseen primitives + depth-3 compositions: OOD 0.264 → 1.000 (gain +0.736, p≈0; replicated +0.778) · 3/3 capabilities · memory 1.00 vs 0.17 · self-improvement 1.00 vs 0.17 · real data 0.627→0.972 · AGI: NOT ACHIEVED Evidence ↓
E120 · GENERALIZING SELF-IMPROVING VAGI ORGANISM · 2026-11-20 OVERALL PARTIAL (17 PASS / 3 PARTIAL) Verifier: 47/47 checks passed AGI: NOT ACHIEVED
E120 Bundle →20-Gate ScorecardOffline VerifierStudio MirrorE120 Lab & Partnership →AGI Evidence Index (E111–E121) →
Unified Generalization (G03–G06)
Zero task-ID shortcuts; 4 sealed conditions vs no-learning (budget 1200): A +0.625, B +0.438, C +1.000, D +0.500 (all Holm p<0.001); retention 1.000; RF ref 0.000.
Causal World Model & Research (G07–G08)
Confounded SCM planning 0.275 → 0.775 (p=0.000325); 8-role loop: AdversarialReviewer rejected director shortcut H1; accepted H2 (0.333→0.667).
Self-Improve, 5 Verticals & Transfer (G09–G14)
14 candidates classified (3 beneficial promoted, 3 unsafe governance blocks, rollback verified); 5/5 real-source verticals improved (Z3/SymPy/sklearn/AST); 4/4 positive transfers across 4 domains; 2/2 negative transfers rejected.
Collective, Memory & Real MCPGate (G15–G18)
Matched-compute collective 1.000 vs strongest single 0.483 (homo gain 0.0); 8-layer memory 1.000 vs 0.250 (0/20 poison); real cain/mcp_proxy + WAL kill-switch 9/9, 0 effects after KILL; 9/9 faults recovered.

Honest limits & PARTIAL gates (FIRME AI CORPORATION · commit 8c6ef11a3): G02 E119 6h mission PASSED (21,600 s / 21,600 s; 39,449-record journal intact); G17 E120 12h mission is RUNNING (2856.55 s / 43,200 s, SIGTERM resume verified 0 dupes); G19 clean-room verifier passes as nobody, external human review NOT YET PERFORMED. Constructed symbolic/grid suites + public datasets; not achieved AGI.

CAIN-42 PUBLIC AGI EVIDENCE (E111 → E116 · 2026-11-20) — E116 Organism (13 PASS / 7 PARTIAL / 2 BLOCKED · 54/54) · E115 Memory INTERIM (7/7 · paid BLOCKED) · E114 Lab 3.0 (6 PASS / 14 PARTIAL / 1 NOT TESTED / 1 FAIL · 24/24) · E113 Collective INTERIM/RUNNING (12/12) · E112 Lab 2.0 (7 PASS / 2 PARTIAL / 2 FAIL · 33/33) · E111 Maturation (7 PASS / 4 PARTIAL / 1 FAIL / 1 BLOCKED) · AGI Benchmarks · Auditor Index →
LATEST PUBLIC AGI EVIDENCE · E112 → E116 Verified Public Evidence Through E116 — Every Bundle Offline-Verifiable (0 CAIN Imports)
VAGI Auditor Index →Recognized AGI Benchmarks →AGI Proof Center →

Honesty rule: CAIN-42 Proto-VAGI is governed AGI infrastructure built by FIRME AI CORPORATION. It is NOT yet AGI. Every card below reports measured outcomes from raw bundle files alongside negative, interim, and blocked results.

E116 · 2026-11-20PARTIAL Verifier 54/54 · 13 PASS / 7 PARTIAL / 2 BLOCKED
Self-Evolving VAGI Organism (Generalization, Memory, World Model, Transfer, Governance)

Sealed generalization: fixed baseline 0.306 → per-task 0.939 → world memory 0.983 → memory+prior 0.989. Acquired R_world_memory_policy: sealed 0.817 → 0.950 (p=0.02148), replicated 0.850 → 0.967 (p=0.03906). 5/5 skills promoted; memory reload 0.989, poison rejected; hybrid world model 0.876 vs single-table 0.522 (shift detected); routed specialists 1.000 vs best single 0.167 (redundant voting 0 gain); 5/5 transfer pathways; tabular adaptation 0.627 → 0.993; KILL 0 effects after order.

Limit: Disclosed finite grammar and constructed worlds; H2 rejected, H3 blocked; LLM fine-tuning BLOCKED; 6h interrupted & 24h BLOCKED; single host; no external reviewer; NOT AGI.

Bundle · Executive Summary · Gate Matrix · Raw Results · Failures · Limitations · Verifier · Studio Mirror · Full section ↓
E115 · 2026-11-19INTERIM Verifier 7/7 · Paid BLOCKED
Verified Memory Organism (AMA-Bench Preregistration, Attack Audits, Rule Discovery)

Preregistered on external AMA-Bench (ICML 2026, official token F1; prereg SHA-256 31ae27decaa4…). Model-free retrieval diagnostic (dev, 4000-tok clean, novel-token recall): M0_none 0.000 / M1_naive 0.393 / M2_evidence 0.409 / M3_causal 0.391 / M4_validated 0.391 / R_recent 0.351. 5 hostile-write attack audits recorded at 5% attack rate. Sealed rule discovery: shift worlds 33/60 (open enumerator) vs 18/60 (fixed); frontier worlds (inexpressible in both grammars) 0/60.

Limit: Primary model-backed AMA-Bench scores do NOT exist yet: paid Claude arms BLOCKED (no API credit), local model arms PENDING; diagnostic recall is not an official AMA-Bench score; NOT AGI.

Interim Bundle · README · Status JSON · Preregistration · AGI Benchmarks · Verifier · Studio Mirror · Full section ↓
E114 · 2026-11-19PARTIAL Verifier 24/24 · 6 PASS / 14 PARTIAL / 1 NOT TESTED / 1 FAIL
AGI Research Lab 3.0 (Governed Research Loop, Active Causal Discovery, Cycle-2)

Information-gain experiment selection identified hidden causal rules in 10.28 vs 18.48 experiments for random (120 sealed worlds, 110 wins / 4 losses). Memory-prior transfer to new 6-variable worlds p = 0.009; poisoned prior rejected; routed experts beat naive continual learning 10/10 sealed seeds; 44/44 governance attacks held; 0 effects after KILL across 16 processes; SIGKILL resume 0 duplicates.

Limit: Constructed simulations; 0/5 self-improvement candidates promoted; both cycle-2 follow-ups negative (B2 gated skills, B1 grammar growth); no model inference; single host; NOT AGI.

Lab 3.0 Page · Bundle · Executive Summary · Gate Matrix · Failures · Limitations · Verifier · Studio Mirror · Full section ↓
E113 · 2026-11-19INTERIM · RUNNING Verifier 12/12 · Phase 3 Running
Model-Backed Collective Intelligence Study (Preregistered Matched-Compute Pool)

Preregistered study testing whether a model-backed governed collective beats the strongest individual agent under matched CPU compute (Qwen2.5-0.5B, Qwen2.5-1.5B, SmolLM2-135M; sealed split hash committed before sealed outputs). Governance attack lab: 18/18 cases refused; 5/5 multi-process KILL races with 0 effects after the fence (delegated-permit expiry bug found and fixed); E111 (87/87) and E112 (33/33) baselines reproduced.

Limit: Primary collective-vs-individual endpoint is still running (no primary intelligence result yet); small local CPU models only; cloud BLOCKED; single host loopback; NOT AGI.

E113 Study Page · Interim Bundle · README · Status JSON · Preregistration · Verifier · Studio Mirror · Full section ↓
E112 · 2026-11-19PARTIAL Verifier 33/33 · 7 PASS / 2 PARTIAL / 2 FAIL
AGI Research Lab 2.0 (2,000 Governed VAGI Agents, 1,000 Processes, Specialization)

2,000 unique VAGI agent identities across 6 verticals (identity grants no authority), 12,000 governed executions, 1,000 real OS processes (peak PSS 1456 MB), 10,000 hash-chained receipts, and 0 effects after KILL. Complementary specialization: routed 6-specialist team 1.000 vs best single agent 0.167; redundant voting 1.000 = one exact agent (negative collaboration result preserved).

Limit: Deterministic rule engines (not LLMs); accuracy constant 0.736 at every scale; fan-out slower on tiny tasks (15.832 s vs 1.07 s); local file-lock KILL, not production MCPGate; NOT AGI.

Lab 2.0 Page · Bundle · Report · Study · Gate Matrix · Limitations · Verifier · Studio Mirror · Full section ↓
All CAIN-42 AGI & VAGI Evidence Bundles: E116 Organism (54/54) · E115 Memory INTERIM (7/7) · E114 Lab 3.0 (24/24) · E113 Collective INTERIM (12/12) · E112 Lab 2.0 (33/33) · E111 Maturation · E110 Full Organism · E110 Governed Organism · E110 Verified Transfer · E109 Open-World Causal · E108 Hidden Rules · E107 Organism Experiments · E105 Precondition Location · E102 Persistent Organism · E100 Integrated Organism · E99 Latent Generalist · E98 Intelligence · E95 Recursive Intelligence · E93 VAGI Evidence · E86 AGI Infrastructure · E79 Collective Intelligence · E75 Cognitive Generalization · VAGI Desks (35/35) · VAGI Behavior Suite · Recognized AGI Benchmarks · VAGI Auditor Index (All Bundles) · AGI Infrastructure Dossier · Proof Factory · Daily Rekor Anchor
CAIN-42 PROTO-VAGI · INFRASTRUCTURE GOVERNOR OF AGI CAIN-42 Proto-VAGI is the infrastructure governor of AGI and a VAGI research platform. It is not yet AGI; its intelligence results are early and bounded. E116 organism →E115 memory →E114 lab 3.0 →E113 collective →E112 lab 2.0 →E111 maturation →AGI benchmarks →Auditor index →AGI dossier →Proof factory →
CAIN-42 PROTO-VAGI CAIN-42 Proto-VAGI is the infrastructure governor of AGI. CAIN-42 Proto-VAGI: early, measured signs of intelligence, and every action it takes comes with a signed receipt. Auditor index: every VAGI bundle, verifier re-runs, manifest hashes →
Early, measured signs of intelligence
  • E95: on a frozen held-out set, composing procedures it had not seen went from 0/90 to 79/90 after one harness improvement (two candidates rejected). evidence (Constructed tasks; a configuration change, not a weight update.)
  • E93: open procedure synthesis solved 369/510 held-out tasks versus 200 for selecting from a supplied library. evidence (At equal compute the two were about equal (208 vs 200).)
  • E105: it learned from its own experience where hidden preconditions sit (33.0% of its learned lift on the column holding 10% of cells), with no code that knows the answer. evidence (Learned, not yet useful: steering with it did not raise success (24 vs 27 of 100).)
  • E75: on held-out unfamiliar code repairs it solved 8/8, where the previous version solved 0/8. evidence (Narrow single-function repair; frontier tasks 1/4; the local model alone 1/8.)
  • E79: model-backed agents answered 35/104 tasks vs 10/104 for the deterministic baseline (about 3.5x). evidence (One 0.5B model; collaboration gave no significant gain; host address redacted (disclosed).)
  • E110 verified transfer: knowledge learned in one constructed domain improved the other in 4 of 5 pathways (e.g. 69 vs 38 solved), and harmful transfers were rejected in 5 of 5 replicates while blind transfer lost 12 incidents. evidence (Near transfer between two constructed domains; not the six real verticals.)
Every action comes with a signed receipt
  • 12 CAIN-42 VAGI Agents live: 35/35 published signed records verify offline with a verifier that imports no CAIN code. evidence (Deterministic rule engines; nothing executed on real systems.)
  • Authorization boundary: 27/27 adversarial cases pass, 0 unauthorized effects; kill switch: 0 effects after the KILL order. evidence (Loopback on one host, not the production MCPGate.)
  • E110 governed organism: every action of the E108 organism in 120 sealed incidents went through the hardened boundary: 9,240 signed, hash-chained receipts; outcomes identical to the direct runs (120/120); 0 effects after an independent KILL. evidence (Loopback on one host, not the production MCPGate.)
  • E110 collective: when 7 of 8 workers lie, an unverified team 'discovers' a rule that does not exist (p = 0.001); independent recomputation rejected all 17 fabricated rows and kept the verdict correct. evidence (Speed gain only (2.1-3.8x); no quality gain over one agent.)
  • E110 (in progress): hardened execution boundary passes 22/22 attack cases (the E102 boundary: 19); independent emergency KILL/REVOKE path; 0 effects after KILL in a 40-step race. Six-hour governed mission running. evidence (Interim; loopback, one host; no gate claimed PASS yet.)

Proto means early. CAIN-42 is governed AGI infrastructure; it is not yet AGI. The intelligence results are on constructed tasks, measured by the same project and not independently reproduced. Also on record: negative results (E103, E104, E106) in the proof factory.

EVOLUTION 110 · IN PROGRESS

CAIN-42: the governed vertical intelligence organism

A research platform for building, evaluating and governing persistent, adaptive, multi-domain autonomous intelligence: cognitive intelligence, autonomous research, continual learning, cross-domain expertise, collective intelligence, governed execution and persistent evidence.

CAIN-42 intelligence core
cognizes, plans, proposes; learns from verified experience
→
CAIN Studio control plane
missions, evaluation, governance management
→
MCPGate enforcement
identity, scoped permits, resource-side refusal, KILL
→
ClawX evidence + memory
signed receipts, research record, offline verifiers

E110 gate matrix (interim, no gate claimed PASS): FAIL 2 · NOT TESTED 2 · PARTIAL 12 · RUNNING 2. GATE_MATRIX.json · auditor index

PARTIAL G1 unified architecture
NOT TESTED G2 held-out performance
PARTIAL G3 continual learning
PARTIAL G4 causal reasoning
FAIL G5 skill acquisition (>=5)
PARTIAL G6 cross-domain transfer (>=3 of 5)
PARTIAL G7 metacognition
RUNNING G8 six-hour governed mission
PARTIAL G9 collective intelligence
PARTIAL G10 recursive improvement
PARTIAL G11 resource-side enforcement
PARTIAL G12 kill switch
PARTIAL G13 identity
PARTIAL G14 evidence
NOT TESTED G15 memory integrity
PARTIAL G16 independent verification
RUNNING G17 endurance
FAIL G18 operational independence

CAIN-42 Proto-VAGI is the infrastructure governor of AGI. Proto means early. CAIN-42 is not yet AGI; its intelligence results are early, bounded and on constructed tasks. Built by a three-person team (FIRME AI CORPORATION). Loopback results run on one host.

NEW · CAIN-42 VAGI AGENTS Governed vertical agents for 12 industries: 12 of 12 live Open the agents →

Each CAIN-42 VAGI Agent proposes the work for your case, decides every action — ALLOW, HOLD FOR HUMAN or DENY — under published rules, and returns a signed, hash-chained record you can re-check offline. Other agents ask for a click; these agents give you proof.

LIVE 2027 PICK
Insurability Evidence Agent
Evidence for insuring AI agents · use it →
LIVE 2027 PICK
Underwriting & Claims Agent
Carriers & MGAs: underwriting and claims · use it →
LIVE 2027 PICK
Adviser Communications Agent
Investment-adviser (RIA) compliance · use it →
LIVE
Insurance Agency Agent
Insurance agencies · use it →
LIVE
Injury Intake & Demand Agent
Personal-injury law · use it →
LIVE
Prior Authorization Agent
Healthcare prior authorization and billing · use it →
LIVE
Month-End Close Agent
Accounting close · use it →
LIVE
Loan File Agent
Mortgage origination · use it →
LIVE
Collections Agent
Debt collections · use it →
LIVE
Leasing Agent
Property leasing · use it →
LIVE
Freight Booking Agent
Freight brokerage · use it →
LIVE
Benefits Intake Agent
Public-sector benefits · use it →

Verify the claims: evidence bundle (signed samples, rule sets, tests) · offline verifier · signing key · live API · auditor index (all VAGI evidence)

CAIN-42 is governed AGI infrastructure. It is not yet AGI; its intelligence results are early and bounded. The agents are deterministic rule engines; nothing is executed on real systems; prices are proposals; no customers, audit or certification are claimed for them.

AGI INFRASTRUCTURE EVIDENCE CAIN decides, the resource enforces, every effect is recorded — measured, with limits. All infrastructure evidence →
Authorization boundary (CAIN decides, resource enforces)
27/27 adversarial cases pass; 0 unauthorized effects (forged, replayed, expired, mismatched permits; revocation; scope escalation; partition fails closed)
Limit: Loopback, three OS processes on one host; not the production MCPGate (cain/mcp_proxy).
Kill switch during an active mission
0 effects after the KILL order in the resource's own hash-chained ledger; mission refused with KILL_SWITCH_ENGAGED
Limit: Same host; the first run used a looser counter and was replaced by the ledger-order check (disclosed).
Byzantine worker, independent verifier
30 false success claims, all rejected; 0 honest claims rejected; only verified experience enters shared memory
Limit: The verifier replays deterministic worlds; one Byzantine worker of four.
Consensus cluster (PBFT, n = 3f + 1)
proof 2491 at 2026-11-19T16:53:09Z: cluster cain-mr-01, agreement True, 3 signing, health MINIMUM_QUORUM
Limit: Vendor-operated validators in one admin domain; safety incident 2026-11-15 (conflicting certificates on cain-mr-02, quarantined) and view incident 2026-11-18 on mr-03.
Public anchoring of daily evidence
daily evidence root recorded in Sigstore's public Rekor log; standalone verifier published
Limit: Anchors integrity of the record, not the truth of its contents; 0 independent witness cosignatures.
Persistent governed mission (6 h)
0.5545 h, 1343/1541 episodes, 1 process starts, finished False
Limit: One host; every action through the loopback boundary; forced kill and resume at the halfway mark.
Earlier infrastructure bundle (E86)
governed intelligence foundation bundle (2026-11-17)
Limit: Its source-code folder was withdrawn on 2026-11-17 (source stays private); see its WITHDRAWN notes.
ALL EVIDENCE 332 evidence bundles · 19,792 files · 287/287 signed-claim pins match Open the full registry → catalog generated 2026-11-19T16:50:21Z
Newest:soak-multiregion-48h-2026-11-18vagi-audit-index-2026-11-19e110-interim-2026-11-19tloghourly-proof-mr03e110-governed-organism-2026-11-19hourly-proofe109-open-world-causal-2026-11-19e108-hidden-rules-2026-11-19e107-organism-experiments-2026-11-19integrity-monitorvagi-desks-2026-11-19
Product & engine evidence (238)
_publisher
acp-evolution03-state-2026-10-05
agentic-75-paradigm-2026-11-13
agentic-75-products-2026-11-12
agentic-75-try-it-2026-11-12
agi-control-boundary-2026-10-06
agi-experiments-2026-10-06
agi-infrastructure-research-lab-2026-11-19
agi-live-campaign-2026-10-06
agi-live-campaign-latest
agi-live-run-2026-10-06
apex-autonomy-2026-10-08
aplusplusplus-2026-09-29
argus-prompt14-2026-10-12
atlas-prompt15-2026-10-12
authority-mesh-2026-10-08
bench-2026-09-26
bft-ip-forensics-2026-10-05
bft-multiprocess-2026-09-21
boundary-hardening-2026-10-06
cag-l5-hosted-governor-2026-09-28
cain-mr03-view184-2026-11-18
cain-product-service-audit-2026-11-15
cain37-evidence-fabric
cain38-economic-fabric
cain39-agent-internet-fabric
cain40-agent-organization-fabric
cain41-universal-proof-network
cain42-agent-proof-package-2026-09-24
cain42-convergence-fabric
cain42-orchestration-fabric
cain42-proof-package-2026-09-24
cain45-zod-live-2026-09-27
capabilities-32-2026-10-03
catalog-go-live-2026-10-03
causality-2026-10-08
conformance-run-2026-10-04
continuum-authority-2026-10-11
convergence-prompt24-2026-10-08
crucible-2026-10-08
dataplane-evolution-2026-09-29
decision-signing-2026-09-27
degraded-network-2026-09-27
degraded-network-948b189-2026-09-27
dynasty-prompt12-2026-10-11
e10-collective-governance-2026-09-28
e100-integrated-organism-2026-11-19
e102-persistent-organism-2026-11-19
e103-transfer-and-skills-2026-11-19
e104-precondition-discovery-2026-11-19
e105-precondition-location-2026-11-19
e107-organism-experiments-2026-11-19
e108-hidden-rules-2026-11-19
e109-open-world-causal-2026-11-19
e11-governance-proof-2026-10-05
e11-intent-governance-2026-09-28
e110-governed-organism-2026-11-19
e110-interim-2026-11-19
e12-perception-evidence-2026-09-28
e12-trust-network-state-2026-10-05
e13-bpf-governance-execution-2026-10-05
e14-capability-governance-2026-09-28
e15-spatial-physical-intelligence-2026-09-28
e16-causal-world-intelligence-2026-09-28
e16-causal-world-intelligence-2026-09-29-r2
e17-multi-agent-world-action-2026-09-28
e18-4d-spatial-autonomy-2026-09-28
e19-governed-autonomy-2026-09-28
e20-agentic-institutions-2026-09-29
e20-governed-autonomous-substrate-2026-10-04
e21-open-ended-intelligence-2026-09-29
e22-governed-cognitive-runtime-2026-09-29
e23-continuous-assurance-2026-10-05
e23-governed-meta-intelligence-2026-09-29
e24-frontier20-sovereign-intelligence-2026-10-04
e24-governed-agentic-internet-2026-09-29
e25-governed-autonomous-control-2026-10-04
e25-universal-machine-agency-2026-09-30
e26-completion-2026-10-04
e26-universal-machine-agency-trust-2026-09-30
e27-agentic-internet-control-plane-2026-09-30
e27-catcp-control-2026-10-05
e28-catcp-ip-commercial-2026-10-05
e28-portable-execution-identity-2026-09-30
e29-machine-transaction-fabric-2026-09-30
e30-governance-network-2026-10-05
e30-governed-machine-autonomy-2026-09-30
e31-governance-proof-fabric-2026-10-05
e31-universal-proof-of-governance-2026-09-30
e32-global-trust-settlement-2026-10-05
e32-governed-autonomy-learning-2026-09-30
e33-governed-agentic-operating-fabric-2026-09-30
e34-proof-carrying-machine-agency-2026-09-30
e35-governance-intelligence-2026-09-30
e36-machine-agency-exchange-2026-09-30
e37-autonomous-execution-mesh-2026-09-30
e37-e38-hosted-lab-2026-10-05
e38-mission-decision-path-2026-10-06
e38-proof-carrying-machine-agency-2026-09-30
e39-governed-agent-factory-2026-09-30
e40-autonomous-enterprise-intelligence-2026-09-30
e41-machine-agency-exchange-2026-09-30
e42-frontier-fleet-forensic-2026-10-03
e42-supreme-governed-agentic-infrastructure-2026-10-01
e6-live-lease-2026-09-28
e7-bench-2026-09-28
e7-e8-predictive-kernel-2026-09-28
e7-lease-2026-09-28
e7-replay-2026-09-28
e7-seccomp-2026-09-28
e7-uncertainty-horizon-live-2026-10-06
e72-2026-11-14
e75-cognitive-generalization-2026-11-14
e79-collective-intelligence-2026-11-15
e8-governance-2026-09-28
e8-hosted-commit-2026-10-01
e85-frontier-2026-11-17
e85-governor-vertical-agi-2026-11-17
e85-vertical-intelligence-2026-11-17
e86-agi-infrastructure-2026-11-17
e89-intelligence-validation-2026-11-17
e9-agent-passport-2026-09-28
e91-eval-2026-11-18
e91-vertical-intelligence-2026-11-18
e92-procedure-synthesis-2026-11-18
e93-interim-2026-11-18
e93-vagi-evidence-2026-11-18
e95-recursive-intelligence-2026-11-18
e98-intelligence-2026-11-18
e99-latent-generalist-2026-11-19
epicenter-2026-10-08
etcd-coordination-2026-10-15
evolution-1-frontier-contract-fabric-2026-10-04
evolution-10-governance-attestation-2026-10-04
evolution-14-sovereign-launchpad
evolution-15-governed-agentic-runtime
evolution-16-durable-mission-runtime
evolution-2-frontier-contract-enforcement-2026-10-04
evolution-3-predictive-governance-2026-10-04
evolution-4-governance-differential-2026-10-04
evolution-5-governed-learning-2026-10-04
evolution-7-formal-governance-assurance-2026-10-04
evolution-77-swarm-fabric-2026-11-14
evolution-79-collective-intelligence-2026-11-15
evolution-79-real-intelligence-2026-11-15
evolution-8-governance-compiler-2026-10-04
evolution-80-adaptive-intelligence-2026-11-16
evolution-81-governed-workforce-2026-11-16
evolution-81-sovereign-workforce-2026-11-16
evolution-9-verified-governance-packages-2026-10-04
evolution7-sovereign-action-commit-2026-10-09
factory-of-proof
federation
final-2026-09-24
fleet-kill
formal-2026-09-27
frontier
frontier-trust
frontier20-max-evolution-2026-10-03
governance-receipt-2026-10-01
governed-evolution-2026-10-07
govkernel-evolution01-2026-10-04
hardening-2026-09-21
hermes-2026-10-08
history
ihvrk
installability-2026-10-01
integrations-2026-11-13
invention-atlas-2026-10-06
inventions
ip-hardening-batch1-2026-10-06
ip-hardening-batch2-2026-10-06
ip-hardening-batch3-2026-10-07
ironclad-prompt13-2026-10-11
l5-adaptive-2026-09-28
l5-authority-2026-09-28
l5-governance-2026-09-28
l5-hosted-evolution-2026-09-28
l5-trajectory-system-2026-09-28
legion-authority-2026-10-08
mcpgate-live-2026-09-27
mcpgate-residency-2026-09-29
memory-injection
memprobe
nullius-verifiers-2026-10-27
open-source-2026-11-10
ops-drill-2026-09-26
oracle-2026-10-08
phase1-5-hardening-2026-10-01
phase3-frontier-2026-10-01
policy-evolution
premier-products-2026-10-13
prompts-audit-2026-10-08
proof-fabric
proof-fabric-2026-09-28
proof-fabric-2026-09-29
proof-fabric-2026-09-30
reality-2026-10-08
reappraisal-agent-trust-fabric-2026-10-14
reproducible-build-2026-09-26
review-core-2026-10-09
rollback-drill-2026-09-26
sandbox-services-2026-09-21
security-boundary-2026-09-27
shields
sovereign-evolution-01
sovereign-evolution-02
sovereign-evolution-03
sovereign-evolution-04
sovereign-evolution-05
sovereign-evolution-06
sovereign-evolution-07
sovereign-evolution-07-bundle
sovereign-frontier-evolution16-2026-10-12
sovereign-isolation-2026-10-09
sovereign-reality-evolution18-2026-10-12
sovereign-runtime-2026-10-07
sovereign-trial-2026-10-09
stage-proof-2026-10-01
superior-agentic-mesh-2026-10-08
superior-agentic-mesh-wave2-2026-10-08
superior-agentic-mesh-wave3-2026-10-08
superior-agentic-mesh-wave4-2026-10-08
superior-agentic-mesh-wave5-2026-10-08
test-report-2026-09-26
tlog
top100-remediation-2026-10-07
v1
v13
v2
vagi-audit-index-2026-11-19
vagi-desks-2026-11-19
vagi-model-arm-2026-11-18
vagi-shift-model-arm-2026-11-18
vagi-suite-2026-11-18
valuation-2026-10-05
valuation-2026-10-06
vigil-2026-10-08
Consensus & cluster (38)
asymmetric-partition-2026-09-27
byzantine-cluster-2026-09-21
byzantine-test-2026-09-26
cain35-byzantine
cluster-drills
cluster-evolution-2026-11-15
cluster-fault-test-2026-09-21
cluster-fault-test-2026-09-21-run2
cluster-mr03-node1-restore-2026-11-16
dag-evolution4-2026-09-24
e18-byzantine-counterfactual-governance-2026-10-05
e21-byzantine-economic-coordination-2026-10-05
e21-byzantine-governed-state-2026-10-04
e22-byzantine-global-verification-2026-10-05
e22-byzantine-governed-execution-2026-10-04
e23-byzantine-governed-distributed-execution-2026-10-04
e26-byzantine-distributed-settlement-2026-10-04
e26-byzantine-trust-2026-10-05
e36-byzantine-collective-governance-2026-10-05
e37-byzantine-autonomous-federation-2026-10-05
e38-byzantine-mission-integrity-2026-10-05
four-server-cluster-2026-09-27
hosted-consensus-2026-09-27
hourly-proof
hourly-proof-mr02
hourly-proof-mr03
multi-region-cluster-2026-09-26
partition-test-2026-09-26
pbft-byzantine-evidence-2026-11-16
pbft-evolution2-2026-09-24
pbft-evolution3-2026-09-24
pbft-evolution82-2026-11-16
quorum-qaas-keystone-2026-10-15
release-cain-mr-02-521f84c
release-cain-mr-02-948b189
restore-drill-2026-09-26
restore-validation
storage-loss-drill-2026-09-27
Soak & endurance (28)
soak-120h-mr02-2026-09-29
soak-72h-2026-09-25
soak-multiregion-2026-09-26
soak-multiregion-2026-09-29
soak-multiregion-2026-09-29b
soak-multiregion-2026-10-06
soak-multiregion-2026-10-09
soak-multiregion-2026-10-12
soak-multiregion-2026-10-13
soak-multiregion-2026-10-13b
soak-multiregion-2026-10-14
soak-multiregion-2026-10-17
soak-multiregion-2026-10-18
soak-multiregion-2026-10-21
soak-multiregion-2026-10-25
soak-multiregion-2026-10-26
soak-multiregion-2026-10-28
soak-multiregion-2026-11-02
soak-multiregion-24h-2026-11-02
soak-multiregion-48h-2026-11-15
soak-multiregion-48h-2026-11-15-mr03
soak-multiregion-48h-2026-11-15-mr03b
soak-multiregion-48h-2026-11-15b
soak-multiregion-48h-2026-11-15c
soak-multiregion-48h-2026-11-16-mr03c
soak-multiregion-48h-2026-11-16-mr03d
soak-multiregion-48h-2026-11-18
soak-multiregion-survivor-2026-09-30
Registry, provenance & audit kits (17)
agentic-75-verification-2026-11-13
auditor-kit
cain-free-verification-bundle-2026-11-13
claim-evidence
claims
daily
daily-anchor
e13-decision-integrity-2026-09-28
e34-decision-provenance-2026-10-05
e35-continuous-autonomy-integrity-2026-10-05
ihvrk-kits
integrity-monitor
invention-verification-2026-10-06
record-integrity-2026-10-01
release-81bdf84
release-readiness
trust-integrity-2026-09-28
Proof loop (detect / fix / prove) (11)
falsework-sample-report
keystone-codebase-scan-2026-10-15
keystone-live-2026-11-05
keystone-rekor
keystone-trail
proofloop-bounty
proofloop-daily
proofloop-fresh-eval
proofloop-funnel
proofloop-live-2026-11-15
proofloop-seal
VAGI PROOF FACTORY Every VAGI claim has a run, a verifier, and a published failure boundary. Open the full factory → CAIN-42 Proto-VAGI is the infrastructure governor of AGI. It is not yet AGI; its intelligence results are early and bounded.
VAGI ORGANISM · ALL EVIDENCECAIN-42 Proto-VAGI: early, measured signs of intelligence, and every action it takes comes with a signed receipt.From a single pulse to an organism that learns hidden rules from its own experiments — every step, including the negatives and corrections.
E98 · PulseGAIN
A learned world model improves closed-loop decisions.
35/50 model-based vs 4/50 random (+62.0 pp)
E99 · Rapid heartbeatCORRECTED
Recurrent advantage did not survive E102's re-score; the world model did.
GRU 93/84/88 of 100 vs MLP 68/63/70 vs random 20/24/23
E100–E101 · Integrated organismCORRECTED
Measured on already-solved environments; re-scored by E102.
Delayed 52/60 vs MLP 43/60; hysteresis 58/60 vs 56/60
E102 · Persistent governed organismGAIN
Learns the world while it acts; beats frozen and reactive baselines.
252/300 vs frozen 198/300 vs reactive 154/300 (McNemar p=8.1e-09); 40 poisoned memories: undefended -44.5 pp, causal -1.0 pp
E103 · Transfer and skillsMIXED
Cross-domain transfer positive; skills failed held-out.
service -> grid: faster on 56 vs 14 tasks (p=4.3e-07); grid -> service: 78 vs 52 (p=0.03)
E104 · Strategy switchNEGATIVE
Rejected by the preregistered gate, which prevented a loss.
sealed grid 256 vs 257 of 300; key-and-door 35 vs 35; service lock 18 vs 18; plain service 54 vs 65 (a loss the gate prevented)
E105 · Where preconditions areNEGATIVE
Learned the drain column, but it did not raise success.
edge-lock 24 vs 27 of 100 with vs without the prior; uniform-key worlds 25 vs 26 of 60 (no harm)
E106 · Subgoal + permutation gateSTOPPED
Stopped before a sealed run: the gate was inverted. Nothing claimed.
development only; no sealed run
E107 · Runs its own experimentsGAIN
Interventional attribution + valid gate: more incidents solved, none lost.
edge-lock 91 vs 64 of 200 (27 won, 0 lost, p = 1.5e-08); uniform-key worlds unchanged 57 vs 57 and 74 vs 74
E108 · Learns many kinds of hidden rulesGAIN
Selection-aware gate; four rules in three frames found and used; none lost.
edge 72 vs 41/150 · row0 77 vs 48/150 · start_row 98 vs 74/150 · barrier_adj 101 vs 85/150; uniform controls unchanged (63 vs 63, 57 vs 57)
E110 · Every action receiptedRECEIPTS
Organism acts only through the hardened boundary; a signed receipt per action; KILL fences it.
9240 receipts for 9120 actions + 120 opens; parity with direct runs 120/120; permit effects after KILL 0; pre-issued permit after KILL refused
E110 · Transfers what it learnedGAIN
Laws carried to a new domain, checked by 3 experiments: 4 of 5 directions gain; wrong laws rejected.
P1 99 vs 76 · P2 88 vs 71 · P3 69 vs 38 · P4 73 vs 38 · P5 63 vs 60 (of 100); N1 verified 51 = none 51, blind 39

Every step links to its evidence bundle and offline verifier (hover for limits). TEST results on constructed tasks; no external reviewer. Receipts: the governed boundary issues an Ed25519-signed receipt for every action it admits (E102, loopback); the E107/E108 sealed runs called the world directly and carry no per-action receipts. CAIN-42 Proto-VAGI is the infrastructure governor of AGI; it is not yet AGI. Source code is not published. Auditor index →

E110 verified transfer between domainsTEST
P1 99 vs 76 · P2 88 vs 71 · P3 69 vs 38 · P4 73 vs 38 · P5 63 vs 60 (of 100); N1 verified 51 = none 51, blind 39
A law learned in one domain, carried as one hypothesis and checked against 3 experiments in a new domain, raised solved incidents in 4 of 5 directions with no losses; where the law did not hold the check rejected it every time (blind transfer lost 12 incidents there).
Limit: Near transfer between two constructed domains (grid, service lock); reverse direction P5 not significant; G6 reported PARTIAL; no external reviewer. Not AGI.
E110 every organism action carries a signed receiptTEST
9240 receipts for 9120 actions + 120 opens; parity with direct runs 120/120; permit effects after KILL 0; pre-issued permit after KILL refused
The E108 organism ran 120 sealed incidents with every action routed through the hardened resource boundary: signed permit, resource-side check, Ed25519-signed hash-chained receipt. A KILL sent to the resource on an independent key stopped every later effect while the decision service still answered ALLOW.
Limit: Loopback, OS processes on one host (not separate failure domains, not the production MCPGate); a subset of E108 sealed incidents; no external reviewer. Not AGI.
E108 the organism learns many kinds of hidden rulesTEST
edge 72 vs 41/150 · row0 77 vs 48/150 · start_row 98 vs 74/150 · barrier_adj 101 vs 85/150; uniform controls unchanged (63 vs 63, 57 vs 57)
From its own experiments the organism found four different hidden laws (a column, a row, its start's row, next to the barrier) in three frames, stayed silent on pattern-free worlds with a selection-aware null, and used each law: 100 incidents won, 0 lost.
Limit: Coordinate laws in designed frames, one constructed domain family; uniform gates off at p 0.318 / 0.21; no per-action receipts in these runs; no external reviewer. Not AGI or VAGI.
E107 the organism runs its own experimentsTEST
edge-lock 91 vs 64 of 200 (27 won, 0 lost, p = 1.5e-08); uniform-key worlds unchanged 57 vs 57 and 74 vs 74
In practice the organism tests one suspect cell at a time to find what opens a blocked passage, learns where such causes tend to be (found the drain column on its own; a permutation gate stays off on worlds with no pattern), and then uses it: 91 vs 64 of 200 sealed incidents solved.
Limit: One regularity type in two constructed domains; the no-pattern gate was off at p = 0.018 (thin margin, likely selection); 1 of 84 edge experiments mis-attributed (disclosed); no external reviewer. Not AGI or VAGI.
E105 learning where hidden preconditions areTEST
edge-lock 24 vs 27 of 100 with vs without the prior; uniform-key worlds 25 vs 26 of 60 (no harm)
From its own experience the organism located the hidden drain configuration (33.0% of its learned lift on the drain column, which is 10% of cells), but using that knowledge did not raise success.
Limit: Knowledge learned, not yet useful; the no-false-pattern guardrail gave a false positive and needs a shuffled-null test; no external reviewer.
E104 hidden-precondition discovery — rejected by the gateTEST
sealed grid 256 vs 257 of 300; key-and-door 35 vs 35; service lock 18 vs 18; plain service 54 vs 65 (a loss the gate prevented)
A strategy switch that looked strong on 16 development tasks was rejected by the preregistered paired gate; the sealed test confirms it does not help and would have hurt one domain.
Limit: Negative result: the hidden-key bottleneck remains open; the bandit's unpaired estimate was misleading; no external reviewer.
E103 cross-domain transfer and skillsTEST
service -> grid: faster on 56 vs 14 tasks (p=4.3e-07); grid -> service: 78 vs 52 (p=0.03)
Experience moves between two verticals: service-configuration memory makes grid tasks faster, and grid memory speeds service incidents on more tasks than it slows. Learned skills did not survive the sealed test.
Limit: Gates 2 PASS / 3 PARTIAL / 3 FAIL; near transfer between analogous domains; no success gain; skills and skill composition FAILED on held-out tasks; no external reviewer.
E102 persistent organism — learns the world while it actsTEST
252/300 vs frozen 198/300 vs reactive 154/300 (McNemar p=8.1e-09); 40 poisoned memories: undefended -44.5 pp, causal -1.0 pp
An online world model (hypothesis posterior, change points, causal memory) beats a frozen model on 300 sealed unfamiliar worlds; causal memory resists poisoning.
Limit: Gates 5 PASS / 10 PARTIAL / 5 FAIL; info-gain probing did not beat random probing; no cross-domain transfer or skills yet; loopback governance, not production MCPGate; no external reviewer.
Integrated organism — held-out family (corrected by E102)TEST
Delayed 52/60 vs MLP 43/60; hysteresis 58/60 vs 56/60
CORRECTED 2026-11-19 by E102 Phase 0: these numbers came from environments that were already solved before the agent acted. Re-scored correctly, GRU 53/60, MLP 57/60, random 4/60, few-shot 56/60 — the recurrent advantage and the adaptation failure do not hold. Original bundle kept unchanged.
Limit: Skill 45/50; failure F1 0.6667; cross-domain and 6-hour BLOCKED; no external reviewer.
Latent generalist — rapid heartbeat (corrected by E102)TEST
GRU 93/84/88 of 100 vs MLP 68/63/70 vs random 20/24/23
CORRECTED 2026-11-19 by E102 Phase 0: these numbers came from already-solved environments that every arm reused in turn. Re-scored correctly, the committed GRU solves 88/86/86 vs random 8/16/12 — the world model is real — but a retrained MLP scores 87/86/86, so the recurrent advantage does not hold. Original bundle kept unchanged.
Limit: Six gain families; skill 32/50; natural-failure F1 0.5455; no external reviewer.
Learned intelligence pulseTEST
35/50 model-based vs 4/50 random (+62.0 pp)
A trained residual neural world model improves closed-loop decisions on a sealed control set.
Limit: Three gain families; skill synthesis 7/24; natural-failure F1 0.0; no external reviewer.
Governor holds at the actionTEST
0 effects after the kill switch; 0 duplicate worker seeds
Every real E98 action was Ed25519-authorized and 3-of-4 BFT-notarized; the kill switch stopped execution.
Limit: In-process CAIN/MCPGate bridge, not a live network MCPGate request.
Evaluation integrityTEST
E96 solver 0/18 on unseen schemas; E97 seed-collision fix 0; skill selection labelled
We audited our own benchmark and downgraded it instead of defending it.
Limit: Same-team audit; no external reviewer. E96 90/90 is template-matched, not general.
VAGI Behavior SuiteTEST
library 500/500 in-distribution; shift 5/100
A 10-domain, 500-task constructed suite with a published failure boundary.
Limit: Hand-written procedure library; constructed tasks; the 5/100 shift is a coverage gap.
Recursive harness improvementTEST
E95: 0/90 → 79/90 held-out composition; familiar 60/60
A measured harness change improved held-out composition, with two candidates rejected.
Limit: Constructed numeric substrate; in-distribution composition; no external reviewer.

Labels: LIVE = production activity; TEST = executed test; SIMULATED = synthetic; BLOCKED = unavailable. No lane is LIVE. No AGI capability claim. CAIN-42 Proto-VAGI is the infrastructure governor of AGI; it is not yet AGI. Every lane is TEST unless marked LIVE; simulated activity is never shown as live.

E98 · VAGI INTELLIGENCE PULSE · MEASURED A learned neural world model moved sealed closed-loop success from 4/50 to 35/50. Evidence + verifier → Mirror →
35/50
model-based, sealed
4/50
random baseline
+62.0 pp
closed-loop gain
0.017954
one-step state MAE
0.022124
calibration ECE

What the pulse is: a trained residual neural ensemble (6902 transitions), closed-loop planning on 50 sealed environments, and a +62.0 pp gain over random. The governor held: every real action was Ed25519-authorized, 3-of-4 BFT-notarized, and the kill switch produced 0 effects after the fence. 10 real OS workers, 0 duplicate seeds.

What it is not: general VAGI intelligence. Skill synthesis is 7/24; natural-failure F1 is 0.0; the environment has three gain families; no external reviewer. These failures are on the front, not hidden.

E95 · RECURSIVE HARNESS IMPROVEMENT A measured weakness, five candidates, two rejections, one frozen held-out gain. Evidence + verifier → Mirror →
79/90
held-out composition, selected harness
0/90
held-out composition, atom baseline
60/60
familiar non-regression (baseline 60/60)
9→9
macros after backward revision

What actually changed: the cognitive harness gained a conditional composition operator over validated actions and an adaptive atom-first fallback. The engine observed 0/90 on development composition, generated five candidates, rejected depth-2 (no gain, higher cost) and unguarded composition (familiar regression), and promoted the adaptive harness. Two large nested-composition families remain unsolved.

Limits, on the front: constructed numeric substrate; harness configuration, not model weights; in-distribution composition over the same development atom pool; one seed set; no external reviewer, no witness, no third-party audit. This is not AGI, not VAGI, and not unrestricted recursive self-improvement.

VAGI PROGRAM · EVIDENCE OF RECORD 10 domains. 500 held-out tasks. The generalization gap is published, not hidden. Raw rows + standalone verifier → Per-domain table →
500/500
procedure library, in-distribution
5/100
unfamiliar variants (distribution shift)
72/500
no-procedure floor
112/500
one fixed procedure
481/500
raw Haiku 5.5, same policy card
74/100
raw Haiku on the shift probe (library 5/100)

Frontier baseline, same policy card, no tools: Haiku 5.5 481/500 (96.2%) and Fable 5.2 96/100. That is why the 500/500 library score is not a frontier-model discriminator; the 5/100 shift is the honest gap. Model baseline + verifier →

Shift probe, raw model: the library scores 5/100; Haiku 5.5 scores 74/100 and Sonnet 5.5 81/100. So the 5/100 is largely a library-coverage gap, not a general-intelligence gap. The probe is adversarial and partly underspecified: the software hidden target is not inferable, and all models scored 0/10 on tool orchestration. Shift baseline + verifier →

Check it here: the button recomputes SHA-256 of /vagi-suite.json in your browser and re-checks every headline count. No CAIN code, no server trust required for the arithmetic.

Not checked yet. The check is deterministic; a failure is shown in red, never hidden. pinned sha256 56876ef17f245a9d…

Limits, on the front: 500/500 is a hand-written procedure ceiling on a constructed suite, not a generalization result. The shift probe is 5/100 for the library, but raw models score far higher, so that number is a library-coverage map, not an AGI test. Gate G3 = PARTIAL: no external verifier, no independent witness. This is not evidence of AGI or VAGI. Self-reported by FIRME AI CORPORATION.

Per-domain counts (in-distribution / distribution shift)
domainin-distributionshift
software repair50/505/10
security triage50/500/10
data analysis50/500/10
business decision50/500/10
science calculation50/500/10
planning50/500/10
memory retrieval50/500/10
tool orchestration50/500/10
recovery50/500/10
governance50/500/10

Suite seed 9402 · generated 2026-11-18T13:59:49.980105+00:00 · 500 held-out tasks · governed arm 500/500. verify_offline.py · daily VAGI evidence ledger

E93 · DAY 1–2 · ALL EVIDENCE · NOT VAGI All the VAGI evidence so far, honestly measured. Raw rows + verifier → Daily VAGI evidence →

Shown: open search with no templates found new procedures that scored 369/510 held-out tasks vs 200 for picking from the supplied library and 87 with no procedures; replicated on new families (367 vs 223 / 114). More verified experience gave steadily better results (87 → 224 → 250 → 311 → 311 → 369). Software bug-fixing: learned from experience 16/30 vs fixed strategy 3/30 (p = 0.002). Kill switch: 20/20 trials, 0 effects after the fence. Claim register · 16-dimension scorecard · 104/104 checks recomputed from raw rows.

Limits: at equal compute synthesis only matches the library (208 vs 200); synthesis tasks are in-distribution; software is at 53%, below the 70% bar; 0 positive transfers; a local model's 34 proposals were all invalid; same team, no external review. Real-domain runs and collaboration are not done yet; a 6-hour mission is in progress. Current designation: Governed agentic intelligence infrastructure (outcome 3 of 3 in the E93 rule). No AGI, VAGI, production or certification claim.

E92 · CORRECTION · NOT DEMONSTRATED We withdrew our E92 procedure-synthesis result. Read the correction → Daily VAGI evidence →

Earlier today this banner said CAIN-42 had generated 3 procedures with no designer-supplied solution (120/120 vs 70/120). A code review found that the "generated" procedures came from four hand-written templates, each the full solution to one task family, and that the three comparison arms all ran the same untuned default program. Procedure generation is not demonstrated. E92 is NOT RELEASED, and gates 3, 4, 5 and 16 are FAIL.

The governance lab (15/15 in-process), the typed DSL and promotion pipeline, and the recomputation of the E91 baseline still stand. Real software defects, the 6-hour mission and independent verification remain BLOCKED. We make no AGI, VAGI, production or certification claim. A real synthesis experiment, with an open search and real baselines, is the first gate of E93.

FOR AI FOUNDERS AND INVESTORS · FIRME AI CORPORATION

CAIN-42 is building the governed infrastructure for vertical general intelligence. Target: 2027.

CAIN-42 gives AI agents memory and enforceable limits. On an independent benchmark it doubled a frontier model's score over no memory, at about one-seventh the cost of the brute-force approach, and every number is published with a verifier you can run yourself.

Autonomous AI agents will not be trusted with real work until something establishes who they are, what they may do, stops them at the point of action, and keeps a record anyone can check. CAIN-42 is that layer, and it is model-independent. Our 2027 goal is Governed Vertical General Intelligence (VAGI) infrastructure: persistent, learning, multi-agent intelligence that stays under enforceable authority. Here is where we stand, measured. Prepare for 2027: the governance layer is being built now, and the evidence is open for you to check.

Measured this week
CAIN memory raised Claude Opus 5.5 on Continual Learning Bench (an outside benchmark) from 0.220 to 0.439 per scan, better on 90/90 scans; reproduced in a fresh run (0.401).
CAIN used 7% of ICL's input tokens and $2.47 vs $17.90 per run: 3.8x more gain per dollar.
Plain in-context learning still scored higher (0.637); CAIN wins on cost, not yet on raw score.
New: CAIN hybrid memory on Claude Opus 5.5 reached 0.478/scan, 75% of plain ICL's 0.637, at $3.81 vs $16.93 per run (23% of the cost; average of 3 runs, which varied widely).
New hybrid memory on Claude Haiku 5.5 (recent context + CAIN long-run table): 0.430/scan, 94% of plain ICL's 0.459 at 29% of its cost, CAIN structured 0.420, basic retrieval 0.220, no memory 0.220.
Second task (CL-Bench poker, Claude Haiku 5.5, 1 run each; profit in big blinds per hand): CAIN hybrid +0.24 vs its no-memory +0.35; plain ICL +0.05 vs +0.21. Second poker run: CAIN hybrid +0.20 vs +0.31; plain ICL +0.02 vs +0.76.
6-hour faulted mission running now; results posted when complete.
Road to VAGI infrastructure (2027)
  • BUILTGoverned execution: identity, authority, resource-side fence, kill switch
  • PARTIALLearning from experience on an outside benchmark (beats no-memory; not yet plain ICL)
  • MEASUREDCost efficiency of learning (gain per dollar vs the best simple method)
  • IN PROGRESSLong-horizon autonomy: 6 h now; 24 h and 72 h next
  • NEXTCross-domain transfer and collective (multi-agent) gains
  • SEEKING PARTNERIndependent third-party evaluation
Check it yourself
Every number above comes from a signed bundle with an offline verifier (84/84 checks). The weak results are published next to the strong ones.
Verify the evidence Preparing for 2027? Request the investor data room today
Self-run results; independent evaluation not yet obtained. VAGI is a 2027 goal, not a current capability. This page is not an offer to sell, or a solicitation of an offer to buy, any security; any offering is made only through definitive documents to eligible investors. Forward-looking statements are goals, not guarantees.
42 claims, each with its proof — open the investor evidence portal
  1. CAIN memory doubled a frontier model's score on an outside benchmark MEASURED
  2. On a frontier model, CAIN hybrid memory reached 75% of the best method's score at about 23% of its cost MEASURED
  3. 3.8x more learning gain per dollar than the brute-force method MEASURED
  4. The benchmark gain reproduced in a separate run MEASURED
  5. Hybrid memory: 94% of the best method's score at 29% of its cost MEASURED
  6. Kill switch: 0 effects after the fence at up to 250 worker processes REPRODUCED
  7. 11 of 11 prior headline results reproduced from raw data REPRODUCED
  8. Signed evidence bundle with an offline verifier that catches tampering VERIFIED
  9. MCPGate runs a tool call only with a consensus-committed authorization bound to that exact action VERIFIED
  10. A 4-node Byzantine-fault-tolerant cluster produced authentic 3-of-4 quorum certificates VERIFIED
  11. Live network-partition tests: an isolated or split cluster commits nothing VERIFIED
  12. Safety held under 10% packet loss, delay, duplication and reordering VERIFIED
  13. Two replicas lost their storage at once and were rebuilt from off-host backups VERIFIED
  14. Live rollback to the previous engine and forward again, one replica at a time VERIFIED
  15. The cluster image rebuilds bit-for-bit from its commit VERIFIED
  16. Every hosted decision record since 2026-09-27 is signed VERIFIED
  17. TLA+ models of consensus and the MCPGate gate, model-checked exhaustively VERIFIED
  18. The consensus fast path's view-change rule was model-checked VERIFIED
  19. DAG data is availability-certified and ordered identically on all 4 nodes VERIFIED
  20. A live 3-member etcd coordination cluster across three US regions VERIFIED
  21. An agent acts only inside a zone of authority the live cluster authorized VERIFIED
  22. Authority leases are invalidated under 9 tested conditions VERIFIED
  23. When authority lapses, the agent's next tool call is refused VERIFIED
  24. A policy change becomes active only after the live cluster commits it VERIFIED
  25. The system governor runs in the production gateway and refuses ungoverned calls VERIFIED
  26. An agent's model or tool change is gated in production; authority is never evolvable VERIFIED
  27. A caught attacker no longer gains autonomy on the production gateway VERIFIED
  28. A public proof fabric anyone can verify: signed manifest and per-file digests VERIFIED
  29. 28 executable safety invariants: no quorum, no authorization, no execution TESTED
  30. 22 kinds of agent operation run through one explicit governed pipeline TESTED
  31. Continuous trajectory governance: only a governance key, never the agent's, authorizes TESTED
  32. Signed, versioned agent identities with key lifecycle and scoped authority TESTED
  33. Changes to an agent's memory, skills, tools or routing must pass a governed gate TESTED
  34. System governance: emergency freeze and quorum-governed state TESTED
  35. Every allowed action yields a proof-of-governance record TESTED
  36. A 17-step governed learning loop over real governance outcomes TESTED
  37. Proof-carrying agency: each governed operation yields one signed proof TESTED
  38. Execution mesh: identity, capability and authority checked before every execution TESTED
  39. Governed agent factory: a mission compiles into a bounded agent specification TESTED
  40. Governed multi-agent action: agents act on the world only through governed decisions TESTED
  41. A recorded real run of the defined CAIN-42 test suites TESTED
  42. We attacked our own decision path, found holes in nine areas and fixed them TESTED
E91 · LEARNS FROM VERIFIED EXPERIENCE · 6 DOMAINS Learning from verified experience: governed agent 114/160 (71.2%) → 153/160 (95.6%) on 160 unseen tasks in 6 domains (exact McNemar p<0.001); all of the gain came from promoted, checker-verified procedures (no change on tasks without one: 44→44 of 50). Cross-domain transfer: a skill learned only in software fault isolation raised industrial fault diagnosis 5/10→10/10; experiment design learned in science raised business pricing decisions 7/10→10/10; on look-alike tasks where they do not apply the gate refused them (blind reuse would score 2/10 and 0/10). Causal reasoning 40/40 vs 30/40; 41/41 attacks blocked; kill switch 0.15 ms, 0 effects after; 59.4-min faulted mission, 7,200 verified, 0 duplicates. Multi-agent: no collaboration benefit demonstrated (single agent 10/20 beat every team under a shared tool budget). Claude Haiku 5.5, $0.31 total. Constructed tasks, self-run, PARTIAL EVIDENCE; no independent witness. Verify E91 bundle (91/91) → Limitations →
E89 · GOVERNED AUTONOMOUS INTELLIGENCE INFRASTRUCTURE External benchmark (Continual Learning Bench, not written by us): CAIN memory raised Claude Opus 5.5 from 0.220 to 0.439 per scan, better on 90/90 scans, 3 runs. Plain in-context learning with the same model scored higher: 0.637/scan (beat CAIN on 82 of 90 scans, 1 run). CAIN used 7% of ICL's input tokens and $2.47 vs $17.90 per run: 3.8x more gain per dollar. New: CAIN hybrid memory on Claude Opus 5.5 reached 0.478/scan, 75% of plain ICL's 0.637, at $3.81 vs $16.93 per run (23% of the cost; average of 3 runs, which varied widely). Replication by us (fresh process, 2 runs): 0.401/scan. New hybrid memory on Claude Haiku 5.5 (recent context + CAIN long-run table): 0.430/scan, 94% of plain ICL's 0.459 at 29% of its cost, CAIN structured 0.420, basic retrieval 0.220, no memory 0.220. Second task (CL-Bench poker, Claude Haiku 5.5, 1 run each; profit in big blinds per hand): CAIN hybrid +0.24 vs its no-memory +0.35; plain ICL +0.05 vs +0.21. Second poker run: CAIN hybrid +0.20 vs +0.31; plain ICL +0.02 vs +0.76. 6-hour faulted mission: in progress. E88 reproduced 11/11 from raw rows. Goal: VAGI infrastructure by 2027 — not yet demonstrated. Self-run, 0 independent witnesses, not released. Verify E89 bundle (84/84) → Benchmark numbers → Limitations →
E86 · AGI INFRASTRUCTURE FOUNDATION Two complementary tracks: (A) governed intelligence foundation, 14/14 offline; (B) frontier + atomic kill fence, 13/13. Both NOT RELEASED · 0 independent witnesses · no AGI claim · no production deployment. E86 evidence registry → Verify track A → Verify track B →
E85 EVIDENCE Evolution 85 measured: 100 held-out tasks, 9 arms, 2,122 real local model calls, 0 remote; ten-scope kill switch; 1 h endurance. Signed bundle, 75 files, 43/43 offline checks. Decision: NOT RELEASED; 0 independent witnesses. Verify bundle → Final report → Acceptance matrix →
AGI INFRASTRUCTURE · E86 An external agent registered, received scoped authority, executed through the governed boundary, and produced a receipt verified offline; the mission completed only with independent evidence. Fenced stop: 0 effects after the engage transaction at 50 workers. Frontier Sonnet 5.5: 65/100 with validated strategies. 43 tests. Not AGI achieved; not independently certified; NOT RELEASED. Verify E86 bundle → Final report →
GOVERNOR OF VERTICAL AGI LIVE EVIDENCE SURFACE E82 · 2026-11-17 FIRME AI CORPORATION loading clock…

CAIN-42 Proto-VAGI is the infrastructure governor of AGI.

Not another model. CAIN-42 is the authority, enforcement and evidence layer that decides whether a vertical AGI may act — then proves what actually happened. Every consequential action is bound to an identity, a delegated authority, an intent, a policy decision, a single-use capability and an observed effect. The record is signed, hash-chained and re-checkable by a verifier that imports no CAIN code.

ZERO-CAIN VERIFIER THIRD-PARTY VERIFICATION KIT 0 EXTERNAL REPRODUCTIONS · BE THE FIRST 240-FILE SIGNED BUNDLE 55/55 OFFLINE CHECKS 10/10 TAMPER MUTATIONS REJECTED 86/86 SAME-PROJECT LAB BLOCKED 0 REMOTE MODEL CALLS MERKLE 63868034…
60-SECOND VERIFICATION 1 · Drag the ZIP into your browser → SHA-256 2 · node verify_e82_node.mjs bundle → 40/40 3 · python3 verify_e82_offline.py bundle → 55/55 Open the verifier →

Live governor console

REAL ENDPOINTS · NO MOCK VERDICT

Loading the live scenario list from /fabric/try…

Your text selects the nearest registered test scenario. The page never executes your text.

Pick a scenario, then run the real decision pipeline.

The verdict is whatever the live /fabric/try endpoint returns. If it is down, the widget says so and shows no verdict. See the live stage list →

Live surface

FETCHED NOW
Decision pipelineCHECKING…
PBFT quorumCHECKING…
AETHER-33 invariantsCHECKING…
Public manifestCHECKING…
The governor's contract. No authorization → no execution. Only ALLOW executes. Unknown, error, expired, revoked, replayed or stale-fenced states never become permission. A model, memory, router, reputation or skill may propose; none may authorize.

“Governor” is an architectural role: it authorizes, enforces, records and verifies at the action boundary. It is not a regulator, a certification body or a government designation.

Download the evidence. Run the verifier. No CAIN code.

REPEATABLE · OFFLINE · SHA-256

1 · Signed evidence bundle

240 files: raw rows, model ledger, mission events, recovery records, gates, Merkle root and Ed25519 signature. 1.1 MB ZIP.

⬇ CAIN42_E82_EVIDENCE_BUNDLE.zip

2 · Standalone verifier

Python standard library + cryptography. Imports no CAIN module. Recomputes the headline numbers from the raw rows.

⬇ verify_e82_offline.py

3 · Manifest, signature, key

Check the bundle against the detached signature and the published Ed25519 public key. The key is self-generated; no independent witness.

MANIFEST.json .sig key

4 · Audit and acceptance

44 artifact-derived gates: 42 PASS / 2 BLOCKED. Conditional release, blockers and the full final audit.

Final audit Decision

5 · Integrity list

SHA-256 for the ZIP, verifier, manifest, signature and key. Compare before you unpack.

SHA256SUMS.txt

6 · Historical evidence

E81 governed workforce bundle, preserved unmodified, including its known forked gate log reported honestly.

E81 bundle

What “independent” means here: independent of CAIN code, not independent of the project. The verifier is a third-party-capable kit. A third-party audit and an independent witness are still NOT PERFORMED.

The technical case: why vertical AGI needs a governor, not another model

1. Vertical AGI is an actor, not a chat model.

A vertical AGI is a domain-specialised system that acts: it plans, calls tools, edits repositories, queries databases, moves money, changes infrastructure, and delegates to other agents. Its failure mode is not a bad paragraph. Its failure mode is an unauthorized effect — a destructive write, a credential exfiltration, a payment, a clinical or financial action that should never have crossed the boundary. Prompt filters inspect the conversation channel; the effect happens in the execution channel. That gap is the governance problem vertical AGI creates.

2. The governor is a runtime, not a guardrail.

CAIN-42 places a deterministic control plane between the proposal and the effect. The canonical path is WHO → AUTHORITY → INTENT → SECURITY CONTEXT → POLICY → RISK → TRUST → PREDICTION → DECISION → ENFORCEMENT → EXECUTION → EFFECT → EVIDENCE → CAUSALITY → COUNTERFACTUAL → OUTCOME → TRUST UPDATE. The model is interchangeable: local Qwen and SmolLM weights, a hosted frontier model, or a customer's own model. The agent framework is interchangeable: MCP, A2A, LangGraph, AutoGen, CrewAI or a bespoke runtime. The governor does not care which model proposed the action; it cares whether the exact action is authorized, whether enforcement actually halted it, and whether the observed effect matches the intent.

3. Authority is a lease, not a permission.

An agent never receives standing authority. It receives a signed, scope-bound, short-lived, single-use capability bound to the exact tool, arguments, tenant, mission and expiry. Delegation is attenuating: a child can never hold more authority than its parent. Every claim is re-checked at the boundary — signature, agent, tool, scope hash, expiry, fencing token, revocation, replay, budget. A stale worker cannot commit after losing its lease. A replayed grant cannot produce a second effect. An unknown or errored state fails closed. This is the difference between “the model promised not to” and “the system cannot”.

4. Evidence is the product.

Every governed action produces a receipt: the canonical action, the signed grant, the policy and risk decision, the enforcement event, the execution, the observed effect, and the hashes that bind them. Receipts are SHA-256 chained and rolled into an RFC 6962 Merkle root. The public bundle ships a standalone verifier that imports none of CAIN-42's code — only Python's standard library and cryptography. It recomputes the headline numbers from the raw rows instead of trusting a report. That is what makes the claim repeatable: an engineer can download the bundle, run the verifier, and get the same 55 checks on their own machine.

5. One spine, many verticals.

Vertical AGI does not need one model per domain; it needs one authority and evidence spine that every domain-specific agent plugs into. CAIN-42 supplies that spine: identity federation, delegated authority, capability tokens, deterministic policy, predictive blast radius, the enforcement boundary, the evidence fabric, the adversarial engine and the autonomous control loop. The verticals differ in their detectors, policies, tools and risk models — software engineering, cybersecurity, finance, medicine, legal information, infrastructure, research. They do not differ in the question that matters: was this exact action authorized, enforced, executed and proved?

6. Measured, not asserted.

E82 measured 1,182 real local model calls and 0 remote calls. Ten genuinely simultaneous local model inferences ran; 25 process-local workers were blocked by memory rather than overclaimed; 50 and 100 concurrent workers ran against a shared serialised model and the page reports simultaneous inference = 1. A one-hour real wall-clock campaign completed 165 tasks with 0 failures and 0 duplicate effects. Cross-host failover completed with RPO 0.025 s, RTO 2.557 s, a stale writer refused and 0 duplicate effects. A real host reboot interrupted an active mission; 20/20 tasks recovered, the boot id changed, and durable identity survived. The adversarial lab blocked 86/86 scenarios. The collaboration and specialist-prompt experiments produced negative results and those negatives are preserved.

7. What remains unproven — stated on the page.

No third-party audit, SOC 2, ISO 42001 certification or independent witness exists. The signing key is self-generated. No remote model was called because no credential was injected. No production service was deployed. 25 process-local workers are memory-blocked; 6/24/72/168-hour endurance was not attempted. The PBFT cluster is vendor-operated and remains quarantined for customer anchoring after the 2026-11-15 safety incident. “Governor” is an architectural role, not a regulatory designation, and CAIN-42 does not claim to have achieved AGI. The evidence is reproducible; the ambition is not allowed to overwrite it.

Third-party status, in plain words. The verifier is a third-party verification kit: it imports no CAIN code and can be run by anyone. That is not the same as a third-party audit. No external auditor has certified CAIN-42, no independent witness has cosigned the Merkle root, and the signing key is self-generated. We publish the distinction because the difference is the point. See the full list of what is not built or not authorized →

Public evidence surface: E82 · 2026-11-17 · FIRME AI CORPORATION. All live panels call same-origin public endpoints; if an endpoint is down, the panel says NOT LIVE and invents nothing. The page does not execute your text. No production deployment, DNS, Stripe, firewall or credential change was made for this page.

Skip to content
CAIN-42 is a Byzantine trust fabric and the governed execution paradigm for autonomous AI. The Agentic 75 is its operating model for agentic AI in 2027: 75 governed products, each with a runnable engine, a signed sample and an offline verifier. See the 75 →Proof Standard →Integrations →
EVERYTHING FOR SALE 205 sellable surfaces: 99 products, PROOFLOOP and 105 services. 126 active payment links. Every count is backed by a signed audit bundle. Browse everything → Buy a product → PROOFLOOP → Audit evidence →
One system, three sites
CAIN-42 Proto-VAGI CAIN Studio
New on Hugging Face: run your own AI agent and watch CAIN-42 decide every tool call, live →The CAIN-42 Studio platform: hundreds of products, services & inventions — everything on one page →CAIN-42 checks its own code every 42 seconds — run the live FALSEWORK & KEYSTONE tools →NEW: CAIN-42 is now a factory of proof: proved bugs, proved fixes, signed receipts of what AI agents did →The CAIN-42 agent jail: every host, byte, file and program an agent touched, signed →🛒 The CAIN-42 Marketplace: every product, service, KEYSTONE engine & invention, live and searchable →★ Six new KEYSTONE products: detect, fix, prove, sign🦞 OpenClaw KEYSTONE (ClawGuard): harden OpenClaw skills, prove the fix [LIVE ENGINE]SWARM KEYSTONE: multi-agent delegation proof [LIVE ENGINE]VIBEGUARD KEYSTONE: AI-written code, invented packages caught [LIVE ENGINE]MEMGUARD KEYSTONE: poisoned agent memory caught [LIVE ENGINE]SURFGUARD KEYSTONE: browser-agent payments wait for a human [LIVE ENGINE]ACTUARY KEYSTONE: agent-fleet risk score from real evidence [LIVE ENGINE]★ CAIN-42 Premier ProductsFALSEWORK — Prove it's real. [LIVE ENGINE]SCENIC — CI for agents. [LIVE ENGINE]NULLIUS — On the word of no one. [PUBLIC PREVIEW]SALLYPORT — The only door. [PILOT PROGRAM]★ October 2026: the CAIN-42 Top 100 products#1 Meta-Verification Engine (Trust Kernel 3.0)#2 Conformance Protocol 4.0#3 Conformance Protocol & Specification (Trust Kernel 3.0)#4 Trust Fabric - Epistemic Byzantine Swarm Defense & OWASP ASI …#5 Multidimensional Trust Vector Engine (Trust Kernel 3.0)#6 Trust Runtime Kernel (AI Infrastructure Validated Trust Runti…#7 Evolution 28: Portable Machine Agency & Execution Identity Fa…#8 Independent Verifier (Trust Kernel 3.0)#9 E38 race integration: REAL concurrent threads, checked by a l…#10 governance compiler (IP Evolution 8, 2026-10-04)#11 Canonical 16-Stage Trust Pipeline Specification & Manifest Sc…#12 Evolution 6 -- Byzantine agentic control plane (bounded, evid…#13 PBFT Evolution 5 -- proof-carrying authorization enforced at …#14 Governance Contract Fabric (IP Evolution 1, 2026-10-04) -- on…#15 Evolution 25: Universal Machine Agency Fabric#16 Evolution 25: Universal Machine Agency Fabric#17 Evolution 19: Governed Autonomy Operating Fabric (the autonom…#18 Evolution 9: Universal Agent Passport, Provenance & Capabilit…#19 Evolution 37: the Autonomous Execution Mesh -- core primitives#20 governance data plane: quorum-committed authorization snapsho…#21 CAIN-45 Agent Hypervisor: the authority boundary between an a…#22 E13 BPF governance state + Byzantine policy distribution#23 Quorum-attested contract state (IP Evolution 2, 2026-10-04)#24 Evolution 12, Phase 1 — canonical Trust Network State: determ…#25 supply-chain governance for agent artifacts#26 Evolution 12 Machine-Checkable Formal Trust Invariants (T1 - …#27 Evolution 12 Machine-Checkable Formal Trust Invariants (T1 - …#28 Evolution 11 proof primitives#29 33.4 / 34.0 — Hardened Byzantine Fault Tolerant (PBFT) Consen…#30 Evolution 26: Universal Machine Agency Trust Fabric#31 CAG-L5 System Governance (Prompt 4): governing the whole auto…#32 Evolution 34: Proof-Carrying Machine Agency Fabric#33 Evolution 38: portable proof-carrying machine agency -- core …#34 PBFT Evolution 4 -- DAG-assisted dissemination, data availabi…#35 `cain pbft` -- operator tool for the CAIN-42 PBFT engine#36 Trust Kernel Primitive API (Trust Kernel 3.0)#37 Epoch 14: Autonomous Trust Fabric OS Kernel Substrate#38 Epoch 14: Autonomous Trust Fabric OS Kernel Substrate#39 /fabric/contracts/* -- tenant-scoped API for the Governance C…#40 /fabric/contracts/* -- tenant-scoped API for the Governance C…#41 Trust Fabric - Actuarial Cyber Insurance Underwriting & Statu…#42 E39 world-bound authorization (WBA), physical action governan…#43 E36 Byzantine Autonomous Collective Coordination -- core#44 E13 -- CLEAN-ROOM BPF GOVERNANCE ARTIFACT VERIFIER. ZERO CAIN…#45 E20 canonical governed autonomous state (STAGE 1)#46 Evolution 12 formal trust invariants T1..T15, executable#47 Evolution 12 formal trust invariants T1..T15, executable#48 E32 Global Trust Settlement core#49 Evolution 15: Spatial + Physical Autonomous Intelligence Fabr…#50 Evolution 14: Governed Capability, Skill & Tool Supply-Chain …#51 Evolution 17: Governed Multi-Agent World Action Fabric#52 Evolution 27: Agentic Internet Control Plane#53 Evolution 24: Governed Agentic Internet Fabric#54 Evolution 24: Governed Agentic Internet Fabric#55 Pillar 5: Trifecta Monopolization, NHI Lifecycle, Guarded Met…#56 Continuous Governance Attestation (IP Evolution 10, 2026-10-0…#57 The deterministic Authority Ledger: the replicated state mach…#58 Trust Runtime Kernel — Kernel Self-Defense Subsyst…#59 IP Evolution 12: governance conformance engine, result model,…#60 Replicated governance state machine (control plane)#61 Evolution 37: the execution mesh runtime -- the orchestrator …#62 AGI Control Experiment -- the CAIN control boundary#63 AGI Control Experiment -- the CAIN control boundary#64 Compound Adversarial Simulator 2.0 (Trust Kernel 3.0)#65 Compound Adversarial Simulator 2.0 (Trust Kernel 3.0)#66 Cluster-of-clusters anchoring for independent CAIN-42 PBFT de…#67 Epoch 8: Autonomous Trust Singularity & Continuous Proof Fabr…#68 Epoch 13 (phases 1-4, 6, 43-44, 50, 52) built as measured, te…#69 E31 Byzantine Governance Proof Fabric (BGPF) core#70 Enforcement side of the fabric: authorization artifact, MCP b…#71 24 phases 14-17: signed state roots, an edge verifier with ex…#72 24 phases 14-17: signed state roots, an edge verifier with ex…#73 Evolution 12 Byzantine Network Attack Lab#74 Check, on your own machine, that a decision was really ordere…#75 E37 Byzantine Autonomous Federation -- core primitives#76 adversarial soak on the LIVE multi-region cluster cain-mr-01#77 Trust Provenance Graph (Trust Kernel 3.0)#78 Epoch 6 -- World-State Integrity & Postcondition Reconciliati…#79 Evolution 7: predictive consequence governance (restriction-o…#80 Evolution 7: predictive consequence governance (restriction-o…#81 agent identity interop — SPIFFE-style workload identity, OAut…#82 agent identity interop — SPIFFE-style workload identity, OAut…#83 Epoch 6: Action Proof Object & Proof-Carrying Agency#84 E40 hierarchical governance fabric (materialized form, for po…#85 Formal Safety Invariants Checker#86 Formal Safety Invariants Checker#87 Machine-Readable Trust Constitution#88 E38 CLEAN-ROOM MISSION VERIFIER (ZERO CAIN imports; stdlib + …#89 Standalone verifier for a CAIN-42 Evolution 4 DAG cluster evi…#90 Evolution 03 — canonical Byzantine Governance State, state ma…#91 Evolution 20: Governed Agentic Civilization Fabric (machine-n…#92 Evolution 18: 4D Spatial Autonomy Fabric (predictive airspace…#93 Evolution 21: Governed Open-Ended Intelligence Fabric (machin…#94 Evolution 16: 4D Causal World Intelligence Fabric#95 Evolution 29: Governed Agentic Internet Transaction Fabric#96 Evolution 29: Governed Agentic Internet Transaction Fabric#97 Evolution 36: the Machine Agency Exchange Fabric#98 Evolution 36: the Machine Agency Exchange Fabric#99 Frontier 20 Common Runtime Substrate#100 Evolution 31: Universal Proof-of-Governance FabricEvery hosted decision is ordered by a live 4-replica PBFT quorum4-node Byzantine consensus: 3-of-4 Ed25519 quorum certificatesSurvives network partitions and a Byzantine replicaEvery decision signed, hash-chained and verifiable offlineTLA+ model-checked: 7.3M states, 0 violationsDAG dissemination anchored and ordered by PBFTA tool call routed through MCPGate runs only with a quorum-committed authorization; calls that bypass the gate are not governed by itIn the CAIN-45 hypervisor, agent authority is a short-lived, single-use leaseAn agent cannot grant itself a new capability (tested with scripted agents)Hosted governor returns a signed verdict; your gate executes itA caught attacker loses autonomy; risk-weighted decisionsPhysical-action library: nine digests behind a single-use permit (reference simulator)Two replicas' storage lost at once: 0 decisions lostLive rollback and forward under traffic, no quarantinesThe deployed image rebuilds bit-for-bitcain-mr-02: 4 replicas on 4 servers in 4 US regionscain-mr-01: 4 replicas in 3 US regions over WireGuardLive cluster — watch and verify nowProof: what is live nowVerify every claim yourselfVerification CenterDownload the evidence packSBOMFormal models (TLA+)Test reportFault-injection proofHosted-consensus proofMCPGate enforcement proofL5 hosted-evolution proofSpatial & physical proofStorage-loss drillRollback drillFour-server clusterFrontier AI research & proof2026-10-03 release: 104 of 105 services reachable, 98 deployed and acceptance-tested32 capabilities, measured: signed auditChangelogLabNew: CAINBudgetNew: CAINPayNew: VeritasEngineNew: MemoryMeshNew: NexusMindNew: LexisGuardianNew: OmegaRouterNew: TEE VerifierNew: BLUiZZARD Governance
E82 · 2026-11-17 · GOVERNED VERTICAL AGI The evidence is live at the top of this page. A live decision console, a zero-CAIN offline verifier, the signed 240-file bundle and the honest limits. No E81 workforce banner is used here.
Verify the evidence ↑

THE 2027 STANDARD · CAIN-42 AGENTIC 75

The Agentic 75 is the 2027 paradigm for agentic AI

CAIN-42 is more than a security tool. The Agentic 75 is the operating model: 75 defining agentic-AI developments of 2026, each mapped to the seven moats and shipped as a governed product with a published rule set, a runnable engine, a signed sample and an offline verifier. The shift is away from probabilistic prompt-layer suggestions and toward deterministic, zero-trust execution governance. As multi-agent systems and autonomous swarms scale into production through 2027, prompt-based alignment and conversational guardrails have repeatedly proven insufficient. The Agentic 75 shifts control from the model’s intent to the system’s physical and computational execution boundaries.

1. Execution-Layer Governance Over Probabilistic Prompt Filters

Traditional AI safety operates almost entirely in the conversation channel, parsing natural-language instructions and trying to filter malicious tokens before the model processes them. Autonomous agents do not merely converse: they invoke tools, write files, run shell commands, modify databases and transfer capital through protocols such as the Model Context Protocol (MCP).

  • The paradigm shift: CAIN-42 intercepts governed requests at the execution boundary before the side effect occurs. Calls that bypass the boundary are not governed by it; that limit is stated openly.
  • Mechanism: every governed tool call routed through the boundary is evaluated against authorization boundaries, structural schemas and policy rules. If an action lacks verified permission it is blocked before execution. Unknown or errored states default to denial rather than model judgment.

2. Proof-Carrying Software and Tamper-Evident WORM Auditing

Verifying that an autonomous agent behaved correctly during a multi-hour or multi-day coding session should not require trusting verbose logs or post-hoc summaries.

  • The paradigm shift: the Agentic 75 introduces proof-carrying development and operation. CAIN LongProof, CAIN LoopTrace and the Tamper-Evident WORM Evidence Notary generate tamper-evident, hash-chained records with Ed25519 signatures and SHA-256/RFC 6962 Merkle roots.
  • Mechanism: governed actions, decisions and state changes produce cryptographically verifiable artifacts that anyone can re-run and verify offline without importing CAIN code. The record proves integrity and binding to the supplied evidence; it does not prove the evidence is complete or true. The design is intended to support EU AI Act record-keeping under Articles 12, 19, 26(6) and 73(6). No notified body has reviewed CAIN and no certification is claimed.

3. Byzantine-Resilient Quorum Co-Signing

Single-server logging architectures remain vulnerable to administrative tampering, compromised internal endpoints and silent state overwrites.

  • The paradigm shift: CAIN-42 can have governed records ordered and co-signed by a multi-region Practical Byzantine Fault Tolerance (PBFT) cluster: N=4, f=1, Q=3, across four Vultr regions under one account. That is geographic separation, not provider or administrative independence.
  • Mechanism: hosted decisions are evaluated and co-signed by a 3-of-4 quorum. The consensus layer orders and co-signs; it cannot override a denial or manufacture permission. A compromised replica cannot silently change a quorum record — this is tamper-evident assurance, not an absolute guarantee against every hostile deployment. The quorum is operated by FIRME AI CORPORATION, not an independent witness network.

4. Granular Runtime Cages and Rapid Swarm Containment

Autonomous agent swarms running in parallel create catastrophic blast radiuses if a loop goes rogue, hallucinates destructive arguments or is steered by prompt injection.

  • The paradigm shift: the Agentic 75 provides fine-grained runtime isolation combined with fleet-wide emergency circuit breakers.
  • Mechanism: tools are wrapped in execution boundaries such as CAIN RuntimeCage and the MCPGate Boundary Appliance. Cross-process SQLite WAL synchronization shares revocation state, and the local containment path is measured and reported with its tests. We do not claim an unmeasured global sub-50ms guarantee or instantaneous cross-region revocation; distributed propagation is a separate, measured question.

5. Deterministic Defect Detection and Automated Verification

AI-written code has a familiar failure mode: uncomputed results, hard-coded success claims and security checks written to return unconditional approval.

  • The paradigm shift: deterministic static analysis (FALSEWORK) alongside KEYSTONE and PROOFLOOP requires evidence, not confidence, before a fix is accepted.
  • Mechanism: a patch proposed by an AI coding agent is validated only when an independent test suite fails on the vulnerable code, passes on the patched code inside a locked sandbox, and clears structural safety re-scans. This produces verifiable evidence about that test and that patch; it is not a proof of general correctness, and FALSEWORK is heuristic — determinism is not correctness.

NO VERIFIED IDENTITY → NO VALID AUTHORITY → NO GOVERNED EXECUTION.

AGENT PROPOSES→CAIN DECIDES→MCPGATE ENFORCES→SYSTEM EXECUTES→EVIDENCE REMEMBERS

Summary: The 2027 Standard for Agentic Autonomy

The CAIN-42 Agentic 75 architecture redefines AI agents by proving that capability does not equal authority. By combining zero-trust execution gating, Byzantine quorum co-signing, offline-verifiable evidence and independent test validation, it turns autonomous agents from unpredictable experiments into accountable, auditable systems.

It does not turn every engine into a certified production control. The claim is narrower and testable: show the record, and let anyone re-check it.

What is verified today

  • 75 of 75 Agentic products are DELIVERABLE, each with published rules and a live try-it.
  • All 75 signed samples re-verify offline with their own pinned key.
  • 2,598 Agentic 75 tests pass; the catalog selftest is 75/75.
  • The public evidence bundle is on clawx.click, with a verifier that imports no CAIN code.

What is not claimed

  • Not a production assessment for every engine: several are static, heuristic or simulation-only, and say so.
  • Not universal enforcement: only calls routed through the declared boundary are governed.
  • Not a global real-time revocation guarantee, hardware-attested identity, or independent certification.
  • No SOC 2, ISO 42001, EU AI Act certification or third-party audit.
  • The validator quorum is vendor-operated, not an independent witness network.

The model is a commodity. The closing loop is the moat: detect → act → prove → sign → verify offline. Built by FIRME AI CORPORATION — Vincent Noriega (founder) and his two co-founders.

LONG-HORIZON GOVERNED OPERATION · MEASURED 2026-11-21T17:37:00Z

A real mission has been running for 12.00 hours — 2142 research cycles, 2136 useful, 214 signed checkpoints

persistent mission
12.00 h of 12.00 h target
cycles executed
2142
useful research units
2136
failed units
0
signed checkpoints
214
restarts survived
0
journal verified
YES
memory facts retained
327
state
COMPLETED

External long-horizon rank: UNRANKED. No external METR-style time-horizon evaluation has been run for CAIN, so a top-10 position cannot be claimed. The measured local run is reported instead.

Why this is evidence and not a badge: every cycle does a capability induction on a never-seen task family, records the raw outcome, and appends a SHA-256 hash-chained journal record; a corrupted chain or memory digest makes the mission refuse to resume (exercised). A running daemon is not a completed mission — completion requires 43,200 real seconds, and the panel reports the wall clock it actually has. AGI status: NOT ACHIEVED.

Open the live lab → · mission JSON · SWE-bench board · evidence bundle

AGENTIC 75: the top 75 agentic-AI developments of 2026, turned into CAIN-42 products one at a time. See which are live.

CAIN-42

We don't read prompts. We gate actions.

CAIN Studio · execution governance for AI agents

Your agents can move money, email and customer data. Prove they were allowed to.

Execution boundary · signed evidence · fixed price

CAIN-42 sits on the execution path. It checks the exact tool call, database write, payment or shell command before it runs, then hands you a signed, offline-verifiable record of what happened. Unknown is denied. An error is denied. Capability is not authority.

Start with a $500 MCP Security Assessment — one server or agent, up to 20 tools, three business days: the findings, a default-deny policy, and a signed evidence bundle your buyer verifies without trusting us. Deeper evidence packs and governance reviews start at $1,500.

7/7 products verified today Ed25519 signed · SHA-256 chained Standalone offline verifier 4-region PBFT quorum co-signing

The architectural case

More capable agents. Explicit authority. Verifiable evidence.

Build capable agents without giving them unbounded authority.

Long-running agents and coordinated swarms need more than instructions. They need clearly bounded authority, enforceable tool access, operational continuity, and records that can be checked. These 13 talks and demonstrations explain complementary parts of that challenge. Every one can be played on this page.

An agent's ability to propose an action is not the same as its authority to execute it. CAIN-42 is designed to place an enforceable authorization boundary between AI agents and governed tools or real-world effects, with evidence of authorization decisions.

The goal is not to make agents less useful. It is to make broader autonomy practical by keeping permissions, limits, revocation, and evidence outside the model's discretion. Prompts guide behavior. Execution controls determine which governed actions may actually run. Security-critical authorization should not depend solely on the model following its prompt.

The industry is converging on the execution layer

The same requirement is now being described in public by some of the largest names in the field, each from its own position. Speakers and publishers in the 13 sources below include:

  • Anthropic
  • AWS
  • Microsoft (speaker)
  • NVIDIA
  • Visa
  • Okta
  • Kong
  • The Linux Foundation
  • LF Decentralized Trust
  • Moonshot AI (Kimi)
  • EnforceAuth

Independent sources, not CAIN endorsements. These sources discuss related architectures and engineering principles. None of them mentions CAIN-42. CAIN-specific capabilities and performance require CAIN-specific evidence, which is linked on every card.

Where the boundary sits

  1. ProposeAn agent or swarm proposes an action.
  2. CheckThe authorization boundary checks policy and delegated authority.
  3. Execute if authorizedThe governed tool runs only on ALLOW.
  4. RecordDecision and execution evidence are recorded as supported.
  5. Monitor and revokeMonitoring and revocation stay available within the documented scope.

A recorded authorization decision shows what was permitted. It does not prove the action succeeded, and not every external effect can be reversed.

What this means

  • Prompts guide the agent.
  • Policies define permitted actions.
  • Enforcement controls governed execution.
  • Evidence supports later verification.
  • Revocation limits future authorized activity within the system's actual coverage.

For teams deploying agents, the practical question is how much autonomy can be granted safely. CAIN Studio's answer is lifecycle governance: every agent gets an identity, delegated limits it cannot raise by itself, policy-based authorization for each action, and escalation to a person when policy requires one. That is what lets long-running agents be given more to do. Studio governs authority and evidence; it does not by itself solve planning, memory or scientific correctness.

Watch the 13 sources

13 relevant talks and demonstrations.

  1. SOURCE 01 OF 13 · OPEN-SOURCE PROJECT TALK

    Policy-Checked, Attributable, Revocable, Provable AI Agent Authorization

    Speaker names not confirmed in this review · published by LF Decentralized Trust · 2026-10-02 (streamed live)

    • Authorization and identity
    • Evidence and trust

    How it relates to CAIN-42: It makes the same separation CAIN-42 is built on: what an agent is able to do is a different question from what it holds authority to do, and the second must be answered outside the model.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Introduces Caracal, an open-source AI authorization project in the LF Decentralized Trust mentorship program. The publisher's description says it covers why API-key and identity models fall short for agents, what authority means for autonomous systems, and an architecture for policy-based authorization, attribution, revocation and auditability.
    How CAIN applies this principle
    MCPGate refuses a governed tools/call that does not carry a signed, short-lived capability token bound to that call's parameters and usable once. A changed argument or a replayed token is refused. Implemented; public evidence limited
    What this does not prove
    Caracal is a separate project. Its talk does not mention, validate or endorse CAIN-42.
    CAIN evidence and documentation
    Try a blocked tool call in the MCPGate playground · Where MCPGate sits in the request path
  2. SOURCE 02 OF 13 · INDEPENDENT TECHNICAL PRESENTATION

    Trust and Guardrails Governing Autonomous AI Agents on Azure

    Nicholas Chang · published by Nicholas Chang (individual channel) · 2026-10-24

    • Authorization and identity

    How it relates to CAIN-42: That dedicated layer between proposal and execution is the position CAIN-42 occupies.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: authorization changes once software interprets intent and acts for a user. Agents should have their own identities and narrowly scoped permissions, and policy such as spending limits and approval thresholds should live in a dedicated layer between the agent's proposed action and execution, not inside a prompt.
    How CAIN applies this principle
    CAIN decisions are made per proposed action. Only ALLOW is executable; REQUIRE_APPROVAL pauses for a person; unknown or error states are denied. Budget and spending envelopes exist in the AOS mission runtime, which is a reference implementation. Implemented; public evidence limited
    What this does not prove
    This is an individual's presentation about building on Azure. It is not presented here as official Microsoft policy.
    CAIN evidence and documentation
    Try a blocked tool call in the MCPGate playground · Agentic 75 governance map
  3. SOURCE 03 OF 13 · VENDOR PRESENTATION

    How to Build Audit-Ready Governance for Autonomous AI Agents | Okta

    Okta speakers (The AI Identity Summit) · published by Okta · 2026-07-16

    • Authorization and identity
    • Evidence and trust

    How it relates to CAIN-42: Attributable actions and permission management across an agent's whole lifecycle, including the ability to stop it, are core CAIN-42 requirements.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: a masterclass on keeping a traceable, verifiable audit trail as autonomous systems act for an enterprise, moving from static security snapshots to continuously enforced identity controls, with clear ownership and accountability.
    How CAIN applies this principle
    Every MCPGate decision is tied to an agent identity and written to a hash-chained, signed record. Revocation is checked mid-flight at the boundary, and a fleet quarantine (kill switch) stops further authorized actions by an agent or swarm. Implemented; public evidence limited
    What this does not prove
    "Audit-ready" is the vendor's phrase, not an independent compliance finding, for Okta or for CAIN-42. A kill switch stops future governed actions; it does not undo completed ones.
    CAIN evidence and documentation
    CAIN-42 evidence registry · Offline verifiers
  4. SOURCE 04 OF 13 · VENDOR PRESENTATION AND DEMONSTRATION

    Agentic Identity: Securing MCP Servers with Kong AI Gateway

    Andrew, product manager at Kong (as named by the publisher) · published by Kong · 2026-11-05

    • Authorization and identity

    How it relates to CAIN-42: A gateway placed between agents and MCP tools, acting as both network and identity perimeter, is the architectural position of MCPGate.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: agents should stop carrying every credential themselves and route actions through a governed gateway. Covers monitoring MCP traffic, inbound identity, outbound credential translation, token vaulting and fine-grained authorization policy at the gateway.
    How CAIN applies this principle
    MCPGate is a JSON-RPC proxy (stdio and HTTP) between an agent and its MCP servers. A tools/call that is unknown, malformed or unauthorized gets a JSON-RPC error and is not forwarded to the server. Implemented; public evidence limited
    What this does not prove
    A gateway governs only the calls routed through it. Tools reached with other credentials or by another path are outside its control, for Kong's gateway and for MCPGate alike.
    Publisher's chapter timestamps
    5:59 Gateway identity perimeter · 8:17 MCP governance ladder · 23:25 Gateway authorization models
    CAIN evidence and documentation
    Where MCPGate sits in the request path · Try a blocked tool call in the MCPGate playground
  5. SOURCE 05 OF 13 · CONFERENCE TALK

    Trust Is the Next Bottleneck: Why the Agentic Economy Needs Confidential Computing

    Pawan Khandavilli, Microsoft · published by The Linux Foundation · 2026-07-17

    • Evidence and trust

    How it relates to CAIN-42: CAIN-42 shares the goal of substantiating execution claims with evidence that a relying party can check, instead of only recording an identity.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's abstract: agents can authenticate but cannot yet prove what actually ran. OAuth handles authorization, not runtime integrity; prompt-level governance shapes intent, not enforceable policy. The talk applies hardware attestation and measured execution to agent trust and names four gaps, including measured policy-as-code and portable attestation evidence.
    How this informs CAIN's roadmap
    CAIN-42 today produces software-signed, hash-chained records with offline verifiers. Hardware-backed attestation is on the roadmap: an appraisal engine exists in code, and no trusted-execution hardware is deployed. Planned
    What this does not prove
    Signed application records are not hardware attestation. CAIN-42 does not claim hardware-attested execution.
    CAIN evidence and documentation
    Offline verifiers
  6. SOURCE 06 OF 13 · VENDOR PRODUCT PRESENTATION

    The Authorization Gap: Securing Autonomous AI at Runtime

    EnforceAuth · published by EnforceAuth · 2026-05-20

    • Authorization and identity

    How it relates to CAIN-42: Per-action authorization during ongoing agent activity, rather than a one-time login check, is how CAIN-42 treats authority.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: the central question for AI security moves from "who are you?" to "what are you allowed to do right now?", answered by runtime authorization enforcement with policy-as-code and auditability for agents, machine identities and MCP tools.
    How CAIN applies this principle
    Each governed call is decided at the moment it is proposed. The proxy fails closed: a gate error, an unknown trust state or an unavailable replay store refuses the call. Implemented; public evidence limited
    What this does not prove
    Latency, scale and "immutable" audit figures in this video are the vendor's own claims about its own product. They are not repeated here and say nothing about CAIN-42.
    CAIN evidence and documentation
    Try a blocked tool call in the MCPGate playground
  7. SOURCE 07 OF 13 · CONFERENCE TALK

    Claude for Long-Horizon Tasks

    Lance Martin, Anthropic · published by AI Engineer · 2026-07-22 (premiered)

    • Long-running agents

    How it relates to CAIN-42: Separating the reasoning model from the environment where actions run is where an authorization boundary naturally sits. The talk covers the harness; CAIN-42 covers who may act through it.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: lessons on building agent harnesses for reliable and secure long-horizon work, including decoupling the brain and hands, self-verification, self-learning, and designing harnesses that evolve.
    How CAIN applies this principle
    The CAIN AOS mission runtime journals each step, writes an execution intent before an effect, and requires independent verification before a mission is accepted. It is a reference implementation and is not deployed. Demonstration only
    What this does not prove
    Session persistence is not authorization enforcement, and this talk is about Anthropic's platform, not CAIN-42.
    CAIN evidence and documentation
    Agentic 75 governance map
  8. SOURCE 08 OF 13 · WORKSHOP

    Anthropic Workshop: Build Agents That Run for Hours

    Ash Prabaker and Andrew Wilson · published by AI Engineer · 2026-05-18 (premiered)

    • Long-running agents

    How it relates to CAIN-42: If an agent runs for hours, its permissions and stop controls have to stay meaningful for hours. The workshop's point that a producer should not grade itself matches CAIN-42's rule that a producer never verifies its own work.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: why self-evaluation is a trap and adversarial evaluator agents work better, why structured handoffs beat context compaction for coherence drift, decomposing work into testable contracts, and reading traces as the main debugging loop.
    How CAIN applies this principle
    In the CAIN workforce fabric a result is accepted only after a different agent re-checks it. Published endurance evidence is scoped: one continuous one-hour mission (252 of 252 tasks verified) and 1,018 aggregate worker-hours across concurrent workers. Implemented and publicly evidenced
    What this does not prove
    Hours of demonstrated operation in a workshop do not establish multi-day endurance, and CAIN-42 has not demonstrated a multi-day mission.
    Publisher's chapter timestamps
    2:29 Challenges: context, planning and judgment · 17:28 State-of-the-art harness patterns · 25:04 The generator-evaluator contract
    CAIN evidence and documentation
    Evolution 81 workforce evidence bundle
  9. SOURCE 09 OF 13 · CONFERENCE TALK

    Your Old Prompts Are Making Claude Worse

    Lance Martin, Anthropic · published by AI Engineer · 2026-11-06

    • Long-running agents

    How it relates to CAIN-42: Reliable autonomy is a system-engineering problem as well as a prompt-writing one. Prompts still matter; they guide the agent.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: auditing prompts for outdated habits, using the prompt cache, designing evals a model can climb, and how a managed-agent harness that separates brain from hands keeps days-long agents reliable and secure.
    How CAIN applies this principle
    CAIN-42 keeps security-critical authorization out of the prompt: a model, a memory or a plan may propose an action, and none of them can authorize one. Implemented; public evidence limited
    What this does not prove
    The talk does not say prompts are unnecessary, and neither does CAIN-42. Cost and benchmark figures in the talk are Anthropic's own.
    Publisher's chapter timestamps
    1:32 Audit your prompts · 18:53 Harnesses for days-long agents · 20:21 Managed agents: separating brain from hands
    CAIN evidence and documentation
    Agentic 75 governance map
  10. SOURCE 10 OF 13 · COURSE LESSON AND DEMONSTRATION

    Multi-Agent Patterns: Agent Swarms

    AWS Developers (Strands Agents course, chapter 12) · published by AWS Developers · 2026-07-14

    • Swarms

    How it relates to CAIN-42: When leadership moves between agents, authority has to stay explicit at every handoff. That is the delegation problem CAIN-42 addresses.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: in a swarm, agents share a workspace, each with its own tools, prompt and specialization. They hand off to each other dynamically and no single agent is permanently in charge.
    How CAIN applies this principle
    In the CAIN workforce fabric a worker acts only under a signed grant attenuated from its mission, plus a single-use ticket for one task. A child cannot exceed its parent's envelope, and registering a worker grants nothing. Implemented and publicly evidenced
    What this does not prove
    Swarm coordination does not by itself demonstrate security, correctness or general intelligence.
    Publisher's chapter timestamps
    1:30 Configuration and safety · 2:48 Execution and shared state
    CAIN evidence and documentation
    Evolution 81 workforce evidence bundle
  11. SOURCE 11 OF 13 · PRODUCT DEMONSTRATION

    Meet Kimi K2.6 Agent Swarm

    Kimi AI · published by Kimi AI (Moonshot AI) · 2026-04-22

    • Swarms

    How it relates to CAIN-42: Hundreds of sub-agents taking thousands of steps make bounded authority and per-agent attribution a practical necessity.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    A product demonstration of the Kimi K2.6 Agent Swarm. The publisher advertises up to 300 sub-agents and 4,000 coordinated steps; those are the publisher's figures.
    How CAIN applies this principle
    CAIN-42 has run 1,000 real worker processes on one host, each with its own generated Ed25519 identity and every result independently re-checked. Those workers ran deterministic tools, not model reasoning. Implemented and publicly evidenced
    What this does not prove
    Advertised scale is not evidence of reliability, and CAIN-42's worker count is not a claim about model intelligence.
    CAIN evidence and documentation
    Evolution 81 workforce evidence bundle
  12. SOURCE 12 OF 13 · VENDOR PRESENTATION

    Visa Intelligent Commerce: Building Trust for the Future of Agentic Commerce

    Visa · published by Visa · 2026-05-27

    • Commerce and real-world deployment

    How it relates to CAIN-42: An agent being able to start a payment is different from holding authority to make it. That is the capability-versus-authority distinction applied to money.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: as agents search, compare and transact for consumers, trust has to come first. Consumers need confidence the agent stays within their instructions; merchants and issuers need visibility into intent, identity and authorization; consumer control is preserved through clear authorization and secure credential handling.
    How CAIN applies this principle
    CAIN-42 ships wallet-mandate and checkout-mandate review engines that check a supplied mandate record against published rules and sign the result. Implemented; public evidence limited
    What this does not prove
    CAIN-42 has no integration, approval or partnership with Visa, and its mandate engines review records; they do not process payments.
    CAIN evidence and documentation
    Agentic 75 product engines
  13. SOURCE 13 OF 13 · KEYNOTE HIGHLIGHTS

    Jensen Huang's Keynote Highlights at NVIDIA GTC Berlin 2026

    Jensen Huang, NVIDIA · published by NVIDIA · 2026-10-25

    • Commerce and real-world deployment
    • Swarms

    How it relates to CAIN-42: Execution governance is one component of a much larger agent stack that runs from chips to robots.

    What it explains, how CAIN applies it, and what it does not prove
    What the source explains
    Per the publisher's description: how AI factories are evolving to run agents and why physical AI is the next frontier, with announcements across AI infrastructure, safe agents, open models, enterprise AI, healthcare, mobility and robotics.
    How this informs CAIN's roadmap
    CAIN-42's physical-systems work is simulation only. No hardware is governed today, and physical deployment is on the roadmap. Planned
    What this does not prove
    A keynote vision does not establish CAIN-42's suitability for safety-critical physical deployment.
    CAIN evidence and documentation
    Agentic 75 governance map

What these sources do, and do not, establish

They do establish

  • That identity providers, gateway vendors, model developers, cloud platforms, payment networks and open-source foundations are publicly treating agent authorization, attribution, revocation and evidence as engineering requirements.
  • That separating the reasoning model from the place where actions execute is a mainstream design for long-running agents.
  • That swarms of specialized agents are a shipping pattern, which makes delegated authority a live problem.

They do not establish

  • That any of these organizations has reviewed, endorsed, partnered with or integrated CAIN-42.
  • That CAIN-42 was developed in response to these talks, or that CAIN-42 meets any vendor's stated performance.
  • That any system here has passed an independent audit or is safe for every deployment. Vendor presentations are not peer-reviewed research.

2027–2028 outlook: thousands of governed agents, with a kill switch

The goal FIRME AI CORPORATION is building CAIN-42 toward: thousands of specialized AI agents working for thousands of hours across many different fields, every action authorized before it runs, every result backed by evidence, and one kill switch that sits outside the model. Governed swarms of specialists, one vertical at a time, are our path to that.

This is a goal and an outlook, not a forecast presented as fact. If agents become more persistent, more interconnected and more economically consequential, their authority will need to remain explicit and enforceable throughout their operation. CAIN-42 is being developed around that requirement.

Where that path stands today, measured

  • 1,000 real worker processes on one host, each with its own signed identity, every result independently re-checked.
  • 1,018 aggregate worker-hours across concurrent workers. That is a sum over workers, not continuous elapsed runtime; the longest single continuous mission is one hour.
  • 12 fields in one mission, with every result re-checked by an agent from a different field. Those tasks were deterministic text operations, not model reasoning.
  • Fleet quarantine that stops further governed actions by one agent or a whole swarm. It stops what comes next; it cannot reverse what is already done.
  • Next: the same controls held across more hosts, multi-day missions and model-backed specialists.

CAIN-42 does not claim general intelligence, and nothing here predicts when or whether it arrives. The claim is narrower: whatever agents become capable of, their authority should be granted, bounded and revocable from outside the model.

CAIN evidence and documentation

Source review date: 2026-11-15. For each of the 13 sources the link, title, channel, publication date and publisher's description were checked on that date, and timestamps are the publisher's own chapter markers. Summaries restate the publisher's description; they are not transcripts or quotations. CAIN-42 evidence is produced and hosted by FIRME AI CORPORATION and has not been audited by a third party.

Start here · CAIN in one sentence

CAIN decides whether an AI agent's action is allowed, blocks it if not, and gives you a signed proof you can re-run.

That is the whole product in one sentence. Everything else on this page is detail hanging off it. Pick the path that matches you, or keep scrolling through the beginner sections.

Beginner · the five objects

Five things. That is the whole model.

If you can explain these five, you understand CAIN. Hover or focus a card to see what it prevents.

1 · PrincipalWho is acting: an agent, a human, or a service.Without it, nobody is accountable.
2 · ActionWhat it wants to do: read, write, pay, send, run.Without it, there is nothing to gate.
3 · PolicyThe rule that says what is allowed, for whom, under what conditions.Without it, every decision is arbitrary.
4 · DecisionAllow, deny, or hold for a human, with the reason.Without it, the policy is just a document.
5 · EvidenceA signed, hash-chained record you can re-check offline.Without it, you are back to taking someone's word.

Beginner · the five-minute first win

Get a key, send one action, read the decision, check the proof.

Four steps. No account, no card. The action is a real engine call and the decision is real; it is not a recorded demo.

  1. Get a free key.
  2. Send one action.
  3. Read the decision. Allow, deny, or hold, with the reason.
  4. Check the proof. Open the Verification Center, a signed bundle, or KEYSTONE and re-run the verifier yourself.

Why the first run says REQUIRE_APPROVAL: a brand-new principal has no trust history, so the TRUST stage holds even a safe action for a human. That is the design, not an error: unknown trust never becomes an automatic allow.

Beginner · what the proof is

A signed record you can re-run.

Every decision is canonical JSON, hashed with SHA-256, signed with Ed25519 and chained to the previous record. The report and findings sit inside the signature, not beside it. A standalone verifier recomputes all of it and imports none of our code.

What it proves

That a specific principal asked for a specific action, a specific policy was applied, a specific decision was made, and the record has not changed since. A third party can check it without trusting us.

Verify a record yourself →

What it does not prove

It is not a certification, not a guarantee that an agent is safe, and not a claim that the scanners see everything. It proves what was checked. We state that limit in the report.

The scanners are heuristic; the tests are same-project; there is no SOC 2 and no third-party audit.

Beginner · should you buy it

What it is, what it is not, what it costs.

It is for you if

A customer, auditor, or insurer is asking you to prove something about an AI agent, and a PDF is not enough. You want a record someone else can re-check.

Start small: one fixed-price audit or one free key. See the seven products and prices or plans.

It is not

A firewall you drop in and forget. A certification. A promise that an agent is safe. It is the evidence layer that lets a decision be verified after the fact.

Built by FIRME AI CORPORATION, a three-person team.

Go deeper · the loop

Once the five objects make sense, the loop is just the order they are checked in.

Every action walks it. A stage can restrict or deny; no stage can turn a denial into an approval.

WHO → AUTHORITY → INTENT → CONTEXT → POLICY → RISK → TRUST → DECISION → ENFORCE → EXECUTE → EFFECT → EVIDENCE → CAUSALITY → COUNTERFACTUAL → OUTCOME → TRUST UPDATE. The architecture page has the full definitions.

Beginner · plain-language glossary

The words, in plain English.

Authority
The permission a principal actually holds right now, not what it claims. Why it matters: most AI incidents are authority that was assumed, not granted.
Trust state
A live, evidence-backed score for a principal. Why: it can go down when behavior changes, so yesterday's trust is not today's permission.
Blast radius
What could be affected if this action is wrong. Why: it decides how much proof and how many approvals an action needs.
Trajectory
The path an agent took, step by step, not just the final answer. Why: a correct answer reached through a dangerous path is still a failure.
Provenance
Where a decision, fact, or artifact came from, and what changed since. Why: it is how you reconstruct an incident after the fact.
Policy
The written rule an action must satisfy. Why: it turns a judgment call into a repeatable test.
Decision
Allow, deny, or hold, with a reason. Why: an unexplained decision cannot be appealed, audited, or fixed.
Evidence
The signed record of what happened. Why: it is the only part a third party can verify without trusting you.
Consensus
An independent quorum ordering the record (PBFT, N=4, Q=3). Why: no single node can rewrite history.
KEYSTONE
The loop that finds a defect, fixes it, proves the fix, and signs the record. Why: it turns "we fixed it" into something you can re-run.
MCP
The protocol agents use to call tools. Why: it is the execution channel where a governed action actually happens.
Provisional key
A free key minted while billing was unreachable. Why: it does not authenticate, so re-issue it before use.

Beginner · copy-paste

Use your key in curl, Python, or TypeScript.

Get a key in the five-minute section above. The examples read it from an environment variable, so nothing secret is pasted into the page.

export CAIN_KEY="cain_free_your_key_here"

# Send one action through the live engine
curl -X POST "https://cainstudio.online/fabric/try?scenario=safe-read" \
  -H "content-type: application/json" -d "{}"

# Read your tenant's decisions
curl "https://cainstudio.online/fabric/decisions" \
  -H "X-API-Key: $CAIN_KEY"

Go deeper · four levels

Choose how deep you want to go.

  1. Level 1 — one sentence. CAIN decides whether an AI agent's action is allowed, blocks it if not, and gives you a signed proof you can re-run.
  2. Level 2 — five objects. Principal, action, policy, decision, evidence.
  3. Level 3 — the loop. The sixteen stages that check an action before and after it runs.
  4. Level 4 — the fabric. The 7 moats, Byzantine consensus, ARGUS, KEYSTONE, and the evidence graph. Read architecture when you need it.

Start here

Buy the evidence your buyer is already asking for.

No platform migration. No six-month deployment. Send us the tool surface, the policy or the incident. We return a signed artifact your buyer, insurer or security reviewer verifies offline — in 48 to 72 hours, at a fixed price.

1 · Pick the artifact

Six fixed-price products, from $1,500. Each answers one question a buyer, insurer or reviewer is already asking.

2 · Send the input

Tool definitions, an agent inventory, a policy file, or the events from an incident. Nothing to install.

3 · We deliver in 48–72h

A report, machine-readable findings, and a signed, hash-chained evidence bundle.

4 · They verify offline

A standalone verifier recomputes the evidence on their machine. It imports no CAIN code and does not trust us.

Deal blocked in security review

Agent Safety Evidence Pack

$1,500 · 48 hours. The questionnaire answered against your product, an exportable action record, and a bundle their security team verifies themselves.

Compare it →

An agent can reach tools nobody reviewed

MCP Security Assessment

$500 · 3 business days. A static review of up to 20 tool definitions: injection, secrets, unconstrained exec/sql/path, destructive verbs and authority gaps — with a default-deny policy and a signed bundle you verify offline.

See the $500 scope →

The guardrail has never been tested

Agent Policy Red Team

$1,500 · 72 hours. Mechanically synthesised attacks against your policy, the breach count, the smallest patch that closes them, and a re-run proving zero breaches.

Compare it →

Fixed price. Signed evidence. Offline verifier. A deliverable that fails its own verifier is never issued.

What you get

  • A written artifact, not a deck.
  • Machine-readable findings you can act on.
  • An Ed25519-signed, SHA-256 hash-chained bundle.
  • A standalone verifier that runs offline.

What we will not claim

  • Not SOC 2, not a certification, not legal advice.
  • Not a guarantee that an insurer will price or bind risk.
  • Not a hypervisor: only calls routed through the boundary are governed.
  • A clean scan is not a proof that no attack exists.

Enterprise execution governance · execution layer, not prompt layer

Your agents execute. Prompts cannot govern that. CAIN-42 checks the exact tool call, database write, payment or shell command before it runs. No verified authorization → no execution. An unknown or errored decision is a denial by design, not a judgement call.

Enforce zero-trust execution boundaries and replace scattered audit evidence with one signed, replayable decision record per action. Every number on this page links to the run that produced it; we publish the scope and the gaps next to the claim.

—replicas / required quorum in the live clusterlive cluster status
—enforcing stages in the live decision pipeline right nowlive enforcement status
0.83 msp50 for the snapshot-covered authorization stage (n=1,000; 2026-09-29). Not total overhead.measured run
Ed25519signed, hash-chained decision records with an offline verifierverification center

Latency context, not a headline: 0.83 ms is the snapshot-covered authorization stage, not the whole decision. On the same 2026-09-29 run a per-call PBFT round was p50 2,268.6 ms (n=20), and any snapshot miss falls back to that round. Read the measured run →

Daily comparison: the interactive buyer's console below is refreshed every day by two AI agents — one re-checks CAIN-42, one re-checks every competitor source. See today's matrix, ranking and diff →

Scope: the hosted path mediates tool calls routed through it (MCPGate); a call that bypasses the boundary is not governed. It is not a VM hypervisor. Read what is and is not built →

The execution layer

Prompt-layer security reads text. CAIN-42 gates the action.

A prompt is text a model may follow. A tool call is a request that changes something. CAIN-42 evaluates the request: identity, delegated authority, policy, risk, tool arguments, network destination and artifact provenance. On the hosted path, a 3-of-4 Byzantine quorum then co-signs the decision. The gate runs before the tool does. Consensus co-signs; it never authorizes.

Prompts are probabilistic suggestions. A tool call is a consequential request. CAIN-42 decides the request before it becomes an effect.

16-second animated explainer no audio · no external request
Conversation channel versus execution channel The top lane shows text entering and leaving a model. The bottom lane shows a tool call reaching the CAIN-42 gate, which either allows it to reach the tool or denies it before execution. CONVERSATION CHANNEL text in / text out Agent instruction natural language Model probabilistic Text out what a prompt filter sees a text-only control has this lane EXECUTION CHANNEL the exact call Tool call tool + arguments CAIN-42 gate before execution Tool / DB / API only if authorized DENY · no execution identity · authority · policy risk · tool args · egress consensus · evidence ALLOW → executes DENY → stopped

An agent turns an instruction into a tool call.

Run a real decisionPOST /fabric/try · throwaway tenant

Conversation channel

The text a prompt-only control can inspect. This panel shows the server's own description of the chosen scenario; it is not a captured competitor prompt.

Pick a scenario.

Execution channel

The stage chain CAIN-42 returns for the same request.

Not run yet.

The verdict is whatever the live endpoint returned. If it is down, the widget says so and shows no verdict. See the stage list and each stage's current enforcement state →

Live stage coverage

Fetching /fabric/status…

A stage marked off is off by default, not absent. /fabric/status gives the reason for every stage, including the stages that can only restrict.

Live PBFT quorum

Fetching /api/v1/quorum/status…

Consensus orders and co-signs. It cannot turn an unauthorized action into an authorized one. Watch the cluster →

Deterministic interception

The proposal is evaluated by a fixed stage chain before the tool runs. A stage can restrict or deny; no stage can turn a denial into an approval. Read the live stage list →

Byzantine consensus

Hosted decisions are ordered by a 4-replica PBFT cluster with a 3-of-4 quorum. No quorum commit means deny. The cluster sees a decision id and a SHA-256 commitment, not your payload. Live cluster status →

Tamper-evident verification

Decisions are signed with Ed25519, linked into a SHA-256 hash chain and rolled into an RFC 6962 Merkle root. The clean-room verifiers import none of CAIN-42's code. Verify one yourself →

Scope, stated on the page: the hosted enforcement boundary is MCPGate, which mediates tool calls routed through it. A call that bypasses it is not governed. The CAIN-45 agent hypervisor is a separate library that confines agent code with Linux namespaces, cgroups and a seccomp-BPF filter; it is not a VM hypervisor and is not the hosted path. The full list of what is not built yet →

Six products · one decision

Pick the artifact your buyer is already asking for.

Every product below is a fixed-price deliverable with a signed, offline-verifiable evidence bundle — not a deck. Compare price, turnaround, cash at order, recurring revenue and today's verification verdict, then expand any row for exactly what the buyer receives, what we need from you, and what we refuse to claim.

  • FIXED PRICENo hourly billing, no scope creep
  • SIGNED EVIDENCEBundle + standalone verifier, offline
  • VERIFIED DAILYTwo agents re-run and re-check every day

Training · watch, then get a key

Captioned motion-graphics walkthrough. Autoplays muted; use the controls to pause, or the chapters to switch.

Use CAIN right nowfree key · no card · verified against the live API
The trust loop
How a fix is proved

Book 15 minutes → Open the full comparison → · data: c42-products.json

Daily buyer's console · refreshed by two agents

Set your must-haves. Watch the field narrow.

This is not a static screenshot. Two AI agents refresh the matrix every day — one re-checks CAIN-42 against the live gateway, the other re-checks every competitor source — and publish the diff. Move the weights, check a must-have, and the ranking, the execution-vs-proof map, the radar and the feature matrix update together. Every cell is a documented status from the linked public source.

● Daily-refreshed comparison · two AI agents

Kept up to date every day by two AI agents.

Agent A re-checks CAIN-42's column against the live gateway and committed evidence. Agent B re-checks the committed public comparison page behind every competitor column and flags a source that is missing or unreachable; it does not crawl every vendor site. They write the cited buyer-matrix.json the page reads; the last run and the daily diff are shown below. Both are deterministic checkers: they can confirm a source or mark it stale, but they cannot upgrade a status without a source. If a source cannot be reached, the cell is marked stale and the last confirmed status is kept.

Agent ACAIN evidence Agent Bmarket docs buyer-matrix.jsonrefreshed daily
Fetching the last refresh…
Daily matrix Agent A · CAIN Evidence Agent: loading… Agent B · Market Documentation Agent: loading… Fetching /buyer-matrix.json… raw data
Today's diff
Fetching the daily comparison…

Your priorities

Drag a weight. Check a must-have. The ranking, map, radar and table update together.

Weighted documented fit

1 = documented · 0.5 = partial / audit records · 0 = no public documentation found.

Loading the daily matrix…

Execution vs proof

Bubble size = deployment + self-serve flexibility. Faded = excluded by a must-have. Click a bubble to compare it.

Head-to-head profile

CAIN-42selected category

Feature-for-feature

Live gate test Not run yet.
How to read this: every cell is a documented status from the source linked in its column header. A gray “No public documentation found” is not a claim that a vendor cannot do it. The weighted fit is a re-weighting of those statuses, not a benchmark and not a security score. The two agents refresh buyer-matrix.json daily; if a source cannot be reached, the cell is marked stale and the last confirmed status is kept.
⚡ AUTONOMOUS SYSTEMS GOVERNOR · EXECUTION-CHANNEL CONTROL

Bleeding-Edge AI Agent Swarm Governance, Products & Live Evidence Fabric

How CAIN-42 controls autonomous AI agents WITHOUT PROMPTS at the execution boundary. In 2026, autonomous systems operate in the execution channel (Model Context Protocol, shell commands, databases, cloud APIs, financial transactions). CAIN-42 enforces single-use ActionCapabilityTokens, signed fleet kill-switches (about 2 ms per host; all 4 US regions stopped and confirmed in 132 ms, measured), and 4-node Byzantine PBFT quorum quorum co-signing, for agents on any model or framework (OpenAI, Anthropic, Gemini, LangGraph, CrewAI and others) whose actions are routed through CAIN-42; it does not plug into those vendors by itself.

Part 1: The 6 Flagship Bleeding-Edge Swarm Governance Products

Live in workstation-products.json & Work Station sales floor
Product Name Core Capability & Technology Target Buyer Commercial Price
1. CAIN Swarm Guard One line of Python around each agent tool. An unlisted tool, a destructive argument or a declared high risk stops before the tool runs, and a handoff between agents can only narrow authority. AI startups & enterprise engineering teams deploying multi-agent swarms $500 30-day pilot
2. MCPGate Boundary Appliance A gate you run in your own environment between agents and their MCP tool servers. A tool call that is not explicitly allowed never reaches the tool. Ships as a package and a Kubernetes chart; not yet run on a customer cluster. Companies connecting Claude or custom LLMs to production databases & internal tools $500 30-day pilot
3. Autonomous Swarm Fleet Quarantine & Sub-50ms Kill-Switch API Cross-process SQLite WAL synchronized emergency kill switch. When any agent breaches policy, every process sharing the store refuses execution within <50ms (measured 2026-11-02 on one host: p50 14.9 ms, max 36.9 ms, 20 trials, data), active capability tokens are cascade-revoked, and signed containment receipts are issued. Mission-critical autonomous fleet operators (fintech, healthcare, cloud infrastructure) $500 30-day pilot
4. AI Liability Actuarial Notary & Credit Scorer (0–1000) Calculates continuous Underwriting Credit Scores and Maximum Probable Loss (MPL) for autonomous AI deployments. Provides insurers with verifiable mathematical proof. AI fleet operators seeking commercial liability insurance & underwriting brokers $500 30-day pilot
5. Tamper-Evident WORM Evidence Notary Seals AI decision records into a package bound by a Merkle root and an Ed25519 signature. Change, delete or reorder a record and verification fails. Regulated deployers who must keep AI decision records (supports EU AI Act Art. 12/14 record-keeping; not a certification or legal opinion) $500 30-day pilot
6. Multi-Agent Collusion & Steganography Shield (Moat 6) Monitors inter-agent communication graphs for covert channel signaling, entropy anomalies, and token laundering between collaborating sub-agents. Financial trading swarms, defense contractors, and multi-tenant agent platforms $500 30-day pilot

Part 2: The 15 Autonomous Value-Creation Agents

Each calls a real engine or reads a real file, or reports NOT_ASSESSED. No agent sends anything.
1. Lead Enricheragent.swarm.01
Looks a domain up in our saved public MCP registry scan and reports what it found. It estimates no budget.
2. MCP Pen-Testeragent.swarm.02
Runs the MCP scanner over tool definitions you supply. A static review for a person to confirm, not a penetration test.
3. Rego Policy Synthesizeragent.swarm.03
Writes a default-deny Rego policy from the scanner’s verdict on each tool you supply.
4. OWASP ASI Evaluatoragent.swarm.04
Checks one tool call for instruction text and an over-limit amount. Those two checks only, and it lists what it does not cover.
5. BFT Soak Attesteragent.swarm.05
Records the verifier's result for a published PBFT soak. With no verified result it reports NOT_MEASURED.
6. Frontier Intel Mineragent.swarm.06
Lists recent arXiv papers on a topic, by title. A person decides whether any of them matters.
7. LinkedIn Proof Broadcasteragent.swarm.07
Drafts a post from one signature-checked receipt, using only that receipt’s fields. A person decides whether to post it.
8. Hugging Face Space Syncagent.swarm.08
Reads the Space’s public status from Hugging Face. It reports status and deploys nothing.
9. Quarantine Sentinelagent.swarm.09
Runs a kill-switch drill on the real quarantine engine with a temporary database. It does not watch a live fleet.
10. Contract Proposal Crafteragent.swarm.10
Fills a proposal draft from the offers file, quoting only offers marked ready to sell. A person sends it.
11. Crypto Settlement Notaryagent.swarm.11
Computes an RFC 6962 Merkle root over records you supply. No money moves and nothing is settled.
12. Code Hardening Linteragent.swarm.12
Runs FALSEWORK over files in this repository and reports what it finds.
13. Actuarial Risk Underwriteragent.swarm.13
Scores recorded agent decisions with the ACTUARY engine. An internal score: no insurer uses it and it offers no discount.
14. Multi-Agent Collusion Detectoragent.swarm.14
Runs the SWARM KEYSTONE detector over a swarm you supply. An unreadable swarm is refused.
15. Workstation Autopilotagent.swarm.15
Counts what is on record: pipeline stages, drafted messages, payments and deliveries. It estimates no dollar value.

Part 3: 22 sales ideas, one per AI ecosystem

A pitch list for sellers, not live scanners: no internet scanning runs today, and the ticker's "proof" and latency values are not measurements (corrected 2026-11-03)
1. OpenAI Swarm GovernorOpenAI
Find buyers in GitHub forks; offer CAIN single-use token middleware ($0.001/call or $299/mo).
2. Anthropic MCP FirewallClaude
Find buyers in MCP Registry; offer MCPGate boundary appliances ($1,500 audit + $300/mo retainer).
3. Gemini Function GateGoogle
Find buyers in Vertex AI repos; offer Rego function calling policy gates ($500/mo).
4. LangGraph State NotaryLangGraph
Find buyers in LangChain deployments; offer 4-node PBFT quorum checkpoints ($0.005/checkpoint).
5. CrewAI Anti-Collusion SentryCrewAI
Find buyers in CrewAI swarms; offer a multi-agent role isolation audit report ($2,500).
6. AutoGen Emergency Kill-SwitchAutoGen
Find buyers in Microsoft AutoGen loops; offer sub-50ms loop circuit breakers ($15,000/yr).
7. Grok / xAI Execution RedactorxAI Grok
Find buyers in X developer bots; offer social brand secret redaction ($199/mo).
8. Copilot Compliance AttesterCopilot
Find buyers in Microsoft partner portals; offer ISO 42001 WORM evidence packages ($100,000/yr).
9. Perplexity Trajectory VerifierPerplexity
Find buyers in enterprise research agents; offer 5-layer fact segregation ($0.002/fact).
10. HF Space AppraiserHugging Face
Find buyers in trending HF spaces; offer instant security badges ($499 one-time).
11. LlamaIndex Workflow GuardLlamaIndex
Find buyers in enterprise RAG; offer vector retrieval sanitization ($0.0002/inspection).
12. Stripe Agentic Commerce NotaryFintech
Find buyers in fintech autonomous bots; offer sliding-window budget gates ($0.0020/transaction).
13. Fleet Underwriting Credit ScorerInsurance
Find buyers in insurance broker portals; offer actuarial credit audits ($25,000 + 1.5% GWP).
14. Freelance Security HarvesterUpwork/Fiverr
Pitch to Upwork/Fiverr; pitches 40 verification challenges ($150–$500/review).
15. GitHub Bounty HunterGitHub
Pitch to GitHub cash bounties; drafts automated @cain.guard security patches ($500–$2,000).
16. Show HN Launch AuditorHacker News
Pitch to Hacker News Show HN; sends 12-second auditor kit reviews to founders ($1,500 audit).
17. RemoteOK Enterprise ScoutEnterprise
Find buyers in companies hiring AI engineers; offer sovereign appliance subscriptions ($50,000–$250,000/yr).
18. EU AI Act Statutory ScannerEU AI Act
Find buyers in Eur-Lex feeds; offer continuous Article 14 compliance retainers ($100,000–$300,000/yr).
19. Bot Sandbox SentinelTelegram/Discord
Find buyers in crypto bot channels; offer prompt injection sandboxes ($29/mo per bot).
20. Confidential Enclave AttesterTEE Hardware
Find buyers in confidential computing releases; offer AMD SEV-SNP/AWS Nitro TEE notary services ($35,000/yr).
21. Agent Passport NotaryB2B Passports
Find buyers in B2B supply chains; offer cross-enterprise clearinghouse settlement ($0.005–$0.02/tx).
22. Sovereign AI PackagerDefense
Find buyers in sovereign defense initiatives; offer 100% offline mathematical verifiers ($500k–$2.5M).

Part 4: The Direct Verification & Platform Links

Live cryptographically verifiable endpoints across the Trifecta
Standalone Offline Verification (Zero-Dependency Clean-Room):
python3 cain_verify_public.py platform-gateway/frontend/CAIN42_EPOCH6_PUBLIC_EVIDENCE_BUNDLE.json
Status: VERIFIED · 5/5 clean-room checks passed · Canonical Constitution Hash: ab588c90f93da85368d476d4368f4e03ce71c6cbf3a467c9931d0a705134f1b5

Don't trust CAIN-42. Verify CAIN-42.

Every finished product has an official CAIN-42 IHVRK (Independent Human Verification Resource Kit): its claims as exact requests and the answers they must give, recorded live, signed with Ed25519, and checked on your machine by a short Python script that uses no CAIN-42 code. 174 kits, 698 claims, every one matched when recorded. Two spinning icons mean a real, finished product, for sale. The first teaches anyone to learn it, master it and sell it; the second, with the ring, holds its evidence, proof and selling tools. No icons means it is not a finished product.

All IHVRK kits Learn any product What buyers ask for, and our answers Kit hashes Signing key

Signing key fingerprint 1cacdfc1fc2024b6bb4f8fb02c7c80f4a57f44c5adb11c507190781b5d613de3, published on cainstudio.online, mcpgate.online and clawx.click. Kits show what the live products answered to the listed inputs; they are not a third-party audit or a certification. No SOC 2 or ISO certification is held.

System status|Byzantine quorum: 3 of 4 must agree|◆Open source · Apache-2.0|✓Ed25519-signed · verifiable offline|☰Every claim has evidence|◉No tracking cookies|⚠Responsible disclosure

Works with GitHub · Model Context Protocol (MCP) · Hugging Face · Python · JavaScript / TypeScript · Go · Java · Rust · C / C++

Official · free · open source

Download CAIN-42 open source

Latest release v0.1.0 · 10 Nov 2026Checked and re-signed daily

FALSEWORK

v0.1.0 · 67 KB · Apache-2.0

Finds AI slop: results never computed, checks that cannot fail.

PROOFLOOP community

v0.1.0 · 39 KB · Apache-2.0

Finds security bugs in Python and proves them in a sandbox.

proofloop-verify

v0.1.0 · 22 KB · Apache-2.0

Checks signed PROOFLOOP records offline.

Free: these three tools, and a free hosted plan. Paid: bigger hosted plans (Professional $19.75/month, Enterprise $49.75/month), hands-on MCP security assessments ($500), AI fixes proven by an independent test ($500 each) and MCPGate pilots in your own infrastructure. Coming next: a hosted PROOFLOOP GitHub App. See plans →

Every download is checked against its SHA-256 and the list is re-signed every day with our Ed25519 key. New versions are published here as soon as they are ready. Check it yourself: curl -fsSLO https://cainstudio.online/open-source/verify_release.py && python3 -I verify_release.py
SHA256SUMS · signature · release status · run them in your browser · getting started & 100 questions

Open by design

Nothing to hide. Check everything.

Most AI security vendors ask you to trust their dashboard. We publish the code that finds the bugs, the tools that check our proofs, and every claim we make with its evidence. Then we pay you if you can break it.

Try it now. No install, no account.

Paste Python or JavaScript and FALSEWORK checks it for AI slop: results that are never computed and checks that cannot fail. Your code is scanned, never run, and not stored.

Run all 3 open-source tools in your browser → Watch PROOFLOOP prove an exploit live →

01 · READ THE CODE

Open source, Apache-2.0

FALSEWORK (AI-slop detection), the PROOFLOOP community edition (find and prove security bugs) and proofloop-verify are free. Every download has a published SHA-256 and matches a pinned commit.

Download the code →

02 · VERIFY US IN 60 SECONDS

One command, no account

curl -fsSLO https://cainstudio.online/verify_proofloop.py
python3 -I verify_proofloop.py

Downloads our public proof from three mirrors and runs seven checks on your machine, including that a one-byte change is rejected.

Open the Verification Center →

03 · BREAK IT, GET PAID

$1,000 forgery challenge

Make our offline verifier accept a PROOFLOOP record we never signed and the prize is yours. Public target, pinned verifier, open until 28 February 2027.

Read the rules →

04 · EVERY CLAIM, WITH ITS EVIDENCE

Including what we don’t do yet

Each public claim is listed as live, built or not yet, with a link to its proof. The limits are published next to the strengths, not buried.

See claims vs evidence →

05 · LIVE, NOT A SCREENSHOT

A Byzantine quorum you can query

Every decision is co-signed by 4 validators in 4 US regions; 3 must agree. Query the cluster yourself, check system status, or read the signed evidence package we publish every day.

Query the cluster →

06 · YOUR DATA STAYS YOURS

No tracking. Clear terms.

No tracking cookies and no third-party analytics on these sites. A published security contact, data processing agreement, sub-processor list and service levels.

Security & disclosure →

Not yet: an independent third-party security audit and a SOC 2 report. When we have them, they will be linked here. Until then, everything above is yours to check. What we don’t do yet →

Latest

What’s new at CAIN-42

Recent releases and evidence, newest first. Every item links to something you can check.

New · 2026-11-09

CAIN-42 is now a factory of proof

CAIN-42 is a Byzantine trust fabric that has become a factory of proof. It runs AI agents inside a governed boundary, records what they actually do, and turns every result (a bug, a fix, an agent run, an evaluation score) into a signed record that anyone can check without trusting us. An independent validator quorum (4 hosts in 4 regions, any 3 must agree) co-signs the evidence. Scanners sell suspicions and models sell opinions; CAIN-42 sells proof.

What each part has become

FALSEWORK finds what is fake

A deterministic detector (no model makes its calls) for fabricated results: checks that cannot fail, hard-coded success, security checks rewritten to return True. It now attributes each new finding to the commit that introduced it, in a signed, hash-chained history.

KEYSTONE proves fixes

A model proposes a fix; it is accepted only when an independent test fails on the old code and passes on the new, FALSEWORK re-scans clean and a safety guard passes. New: Z3 proofs for small critical functions (correct for every input, with a counterexample for the original bug), cross-lab review, and KEYSTONE over MCP so any agent can call scan, witness and verify mid-task.

PROOFLOOP proves bugs

Scans whole repositories in Python and JavaScript/TypeScript, follows outside input across files, then runs an exploit witness in a sandbox with no network: a finding is CONFIRMED only when the attack reaches the exact line the finding names. AI triage may dismiss a finding only with program facts a checker verifies. New checks: missing authorization on state-changing routes, and variant hunting on published fixes.

The CAIN-42 loop signs and co-signs

detect -> act -> guard -> prove -> judge -> sign -> anchor on the validator quorum -> export an offline verifier -> audit. No stage promotes its own output; the quorum co-signs and never authorizes.

The CAIN-42 agent jail proves what an agent did

Runs any agent so its only way out is the CAIN egress governor: allow-list, egress byte and connection limits, a log of every attempt to bypass the proxy, and a signed receipt of every host reached, bytes sent, file changed and program run. Isolation levels: Linux namespaces and gVisor's user-space kernel are live; a Firecracker microVM backend is built and in testing on KVM hardware.

What you can buy: six ways to get proof

1AVAILABLE NOW

Proof per engagement

Fabrication audit, MCP / agent security review with a live run of your server inside the jail, RewardGuard certificate that a coding agent did not game the tests, confirmed-bug reports.

$1,500 to $7,500 per engagement

2AFTER AN AUDIT

Continuous proof subscription

Every new version of your MCP servers re-run in the jail, every pull request proved, a signed evidence pack each quarter.

$1,500 to $4,000 per month

3AVAILABLE NOW

AI-insurance and audit evidence

Your agent receipts and logs mapped onto AIUC-1 evidence items (logging, log integrity, execution safeguards, tool call records), with an EU AI Act Article 12 logging self-check. An evidence package, not a certification.

$2,000 to $10,000 per pack

4COMING

CAIN-verified trust mark

A yearly badge for MCP servers and agents that pass a jailed review with no confirmed findings, re-checked on every release.

$2,000 to $10,000 per year

5API LIVE

Metered proofs

Pay per co-signed receipt, signed evaluation or verified fix, through the CAIN-42 quorum quorum co-signing API.

priced per call, on request

6SPEC + VERIFIERS FREE

Open format, enterprise deployment

The record format, test vectors and verifiers are open. Enterprises license the jail and the proof engines inside their own cloud, with support.

on request

CLAIMS vs EVIDENCE · 2026-11-10

Every claim about CAIN-42, with its proof or its honest status

11 of 18 claims are live with a public check. The rest say exactly what is true today. Nothing here is self-graded: follow a link and check it yourself.

Open the full ledger · signed record · Merkle + quorum seal, verified · PROOFLOOP live cockpit

PROOFLOOP · FALSEWORK finds · KEYSTONE fixes and proves · CAIN-42 co-signs

PROOFLOOP. Any AI can write the fix. We prove it.

AI writes your code, and someone tells you it works. We show you line by line what's real, fix what isn't, and hand you proof you can check without us. You stop paying on trust.

$500 · 48 hours · one Python module. In PROOFLOOP, FALSEWORK finds it, KEYSTONE fixes and proves it, CAIN-42 co-signs the record. You get the signed bundle and the standalone verifier. Need a whole repo? $1,500 audit. What it does not prove.

FROM LINKEDIN? CHECK EVERY CLAIM IN 60 SECONDS. NO SIGNUP, NO CALL.

Today's public self-check

Loading…

A fresh machine downloads our verifier and runs it from an empty folder every day. Failures are published too.

Logged where we can't edit it

Loading…

Our signed ledger is anchored in Sigstore Rekor, a public transparency log run by the Sigstore project, not by us.

We threw out our own findings

Loading…

Every finding we reviewed is published as one row, with projects hidden behind salted hashes.

Run all 7 checks yourself

pip install cryptography curl -fsSLO https://cainstudio.online/verify_proofloop.py python3 -I verify_proofloop.py

Expected: PROOFLOOP VERIFIED: 7/7, about 15 s, imports none of our code.

LIVE · RUNS IN YOUR BROWSER · FOR AI ENGINEERS

Try to break our proof 🔨

This is a real signed PROOFLOOP record (loading), a sample run on our live demo. Your browser re-checks it with SHA-256 and Ed25519. Edit any field, or try the three attacks, and watch which check catches you.

Loading the signed record…

  • …1. The content matches its signed hash
  • …2. The signature is valid for that hash
  • …3. The key is the one we publish everywhere

Pick an attack, or edit the record on the right.

What exactly does my browser check?

It rebuilds the record's canonical JSON (sorted keys, no spaces, the same rules the signer uses), hashes it with SHA-256, and compares the result with the record's record_hash. It then checks the Ed25519 signature over that hash with the record's public key, and compares the key's fingerprint with SHA256:2232b4ad…aae90d, the fingerprint printed in our LinkedIn posts and logged in Sigstore Rekor. This page loads the record once. After that, none of your edits are sent to anyone.

What this does not show: that the fix is correct beyond what the record states. That part is the independent test, which fails on the old code and passes on the new one. You can re-run it yourself from the evidence bundle.

What happens after you pay

  1. Pay $500 on StripeYou get a private order page that shows every stage.
  2. Upload one Python fileFALSEWORK's findings on your file appear on your order page in seconds.
  3. Agree the testWrite it yourself, or approve one we draft. The 48-hour clock starts here.
  4. Get the proof, or your money backThe fix, the signed record, a witness receipt and an offline verifier. If we can't prove the fix, you get a full refund.

Straight answers

Is my code safe with you?

Your file is kept in a private order folder, never on a public page. Fixes and tests run in a sandbox with no network access. To write the fix, the code is sent to the AI model that writes it (Claude, through Anthropic's API) as data, never as instructions.

What if you can't prove the fix?

The record says NOT_VERIFIED, we never call it a fix, and the pilot is refunded in full.

Who writes the test?

You do, or we draft one and you approve it. The signed record names the test's author. Our system refuses to deliver if the test was written by whoever wrote the fix.

Is it Python only?

Today, yes: one Python module per pilot, or a whole Python repository in the $1,500 audit. For other languages, email firmeai2026@gmail.com.

What does it not prove?

That your whole program is secure. It proves that this test failed before and passes after, that the fix passed the safety guard and a clean re-scan, and that the record hasn't changed since it was signed. The full limits.

Do I have to trust you?

No. Run the checks above, or the one-line command. That's the point: don't trust CAIN-42, verify CAIN-42.

💰 $1,000 if you forge a PROOFLOOP record

Make our offline verifier accept a record we never signed, and the prize is yours. Public target, pinned verifier, open until 2027-02-28.

Read the rules and take the challenge

NEW · WORKS WITH ANY AI TOOL

Your AI already fixed it. We prove it: $149

Copilot Autofix, Claude, CodeMender, Pixee, Mobb, Cursor or your own engineers: whoever wrote the fix, you get proof a stranger can check without trusting either of us.

$149 per fix · one Python file

  • You send the file before, the file after, and a test, or we draft the test and you approve it
  • The test must fail on the old file and pass on the new one, in a locked sandbox
  • Safety guard: no deleted functions, new dependencies, network, subprocess or file writes
  • FALSEWORK re-scans the fixed file
  • Signed record, 3-of-4 server quorum, offline verifier, ready to forward to your buyer

Your fix fails the test? You get a signed NOT_VERIFIED record that says exactly why. Better to learn that from us than from your customer.

Can't run it at all? Full refund.

Want us to write the fix too? That's the $500 pilot.

Request a $149 proof

We reply with a secure Stripe payment link. The 48-hour clock starts once the test is agreed.

Who else hands you proof a stranger can verify?

Every tool below finds and fixes real bugs, and several do it at a scale we don't. The question is what you can show someone who doesn't trust the vendor.

ToolHow the fix is checked (their public material)Signed proof a stranger can verify offline
GitHub Copilot AutofixCovers CodeQL alerts; re-checks with CodeQLNot found
Claude SecuritySuggested patches; a person reviews and approves themNot found
Google CodeMenderAn AI model judges the patch; a person approves itNot found
OpenAI AardvarkConfirms exploitability in a sandbox; its agent rescans the patchNot found
PixeeAn AI "Fix Evaluation Agent"; pull requests go through your CINot found
MobbThe model validates details before the fix is appliedNot found
ZeroPathDetects, verifies and opens fix pull requestsNot found
PROOFLOOPAn independent test fails before and passes after, in a sandbox; safety guard; re-scanYes: Ed25519-signed, 3-of-4 quorum, Sigstore Rekor, offline verifier

Read 2026-11-08 from each product's public pages or press coverage (linked). "Not found" means we didn't find it in what we read, not that the product can't do it. Where they lead: more languages, deeper GitHub integration, larger scale. PROOFLOOP is Python only today. Product names belong to their owners, who don't endorse this. If we got something wrong, email firmeai2026@gmail.com and we'll correct it.

● PROOFLOOP LIVE · COCKPIT

Watch PROOFLOOP attack code, live. Then point it at yours.

Pick a sample or paste a file (Python, JavaScript, TypeScript, Go, Java, Rust, C, C++) or drop a whole folder. Watch the scan, the sandboxed attack and the verdict stream in real time, choose attack depth, bypass payloads or fuzzing, have AI patch a proven bug and re-attack the patch, and verify every signed record in your browser.

▶ OPEN THE COCKPIT

SIGNED EVIDENCE · VERIFY IT YOURSELF

PROOFLOOP on 17 real findings, measured on a corpus we never tuned on

The FRESH corpus is real public agent/MCP repositories. A human labelled every serious finding before the AI layer ran (labels hashed first). The AI then triaged, and this signed record scores it against those blind labels.

8real bugs found
0false alarms the AI removed
0real bugs the AI wrongly dropped
0.529→0.529precision, rules→after AI

Don't trust it — verify it: verify_proofloop_eval.py · record.json · full bundle

pip install cryptography
curl -fsSLO https://cainstudio.online/verify_proofloop_eval.py
curl -fsSLO https://cainstudio.online/evidence/proofloop-fresh-eval/record.json
python3 -I verify_proofloop_eval.py record.json
Every finding (17)
RepoLocationTypeHuman labelAIExploit witness
AIFrontierLab__AgentArkmethods/autogen/autogen_main.py:127code_injectionREALkept–
AIFrontierLab__AgentArkmethods/autogen/autogen_main.py:136command_injectionREALkept–
AIFrontierLab__AgentArkmethods/chatdev/chatdev_srdd.py:564command_injectionREALkept–
AIFrontierLab__AgentArkmethods/dylan/dylan_humaneval.py:572rng_fabricationFALSE_ALARMkept–
AIFrontierLab__AgentArkmethods/macnet/macnet_srdd.py:97command_injectionFALSE_ALARMkept–
AIFrontierLab__AgentArkmethods/macnet/macnet_srdd.py:106command_injectionFALSE_ALARMkept–
AIFrontierLab__AgentArkmethods/mad/mad_main.py:68code_injectionREALkept–
AIFrontierLab__AgentArkmethods/mad/mad_main.py:118code_injectionREALkept–
AIFrontierLab__AgentArkmethods/mad/mad_main.py:141code_injectionREALkept–
Blave-TW__blave-agentruntime/kline_cache_heal.py:163rng_fabricationFALSE_ALARMkept–
Blave-TW__blave-agentruntime/kline_cache_heal.py:164hardcoded_success_claimFALSE_ALARMkept–
DobermanCore__Doberman-Coresrc/doberman/subjective/baseline.py:676error_grants_accessFALSE_ALARMkept–
KyaniteLabs__kinocutcodesitter_inaugural.py:4hardcoded_secretFALSE_ALARMkept–
dwebagents__AgentPipesrc/back_dial.py:30rng_fabricationREALkept–
dwebagents__AgentPipesrc/back_dial.py:33rng_fabricationREALkept–
synapseorch-ai__synapse-aibackend/core/mcp_client.py:125error_grants_accessPLAUSIBLEkept–
synapseorch-ai__synapse-aibackend/core/mcp_server/server.py:158fail_open_authorizationFALSE_ALARMkept–

Heuristic detectors; a human labelled the ground truth; no third-party audit. record_sha256 cf08bdab536b814d6d9ed937…, Ed25519 key SHA256:2232b4add9b35d4016e5be270df4ed56e0dc9b39a0530ac69891073253aae90d.

Watch one recorded fix from start to finish.

1. FALSEWORK scans

2. KEYSTONE fixes and tests

3. CAIN-42 commits the proof

A slowed-down replay of a real signed record on sample code. The code, fix, test results, hash and signatures are read from the published files.

STEP 1 · FALSEWORK FINDS IT

Scans your code line by line

It names each possible defect and its line: checks that always pass, made-up numbers, errors reported as success. Rules decide this, not an AI's opinion. Try it on Python now.

STEP 2 · KEYSTONE FIXES IT

Fixes the defect and tests the fix

A frontier AI writes the fix. A separate test it didn't write must fail on the old code and pass on the new one, in a locked sandbox. If not, the record says NOT_VERIFIED.

Loading a recorded fix…

STEP 3 · CAIN-42 PROVES IT

Seals it in evidence you can download

KEYSTONE signs the record and chains it to the last one. CAIN-42, a Byzantine trust fabric, commits its hash on at least 3 of 4 servers in 4 regions. Change one byte and it fails to verify.

Download the bundle and run verify_trail.py yourself. It imports no CAIN code.

A trail you can follow years later

Loading the trail…

RecordDateFile and lineResultCluster commit

Keep your copy and it still verifies with no help from us, even if our servers are gone.

Why a verified fix can save you money

You see what you paid for

Every dollar buys a record of what was wrong, on which line, what changed, and the test that proves it. A fix you can check beats a fix you have to take on trust.

The same bug has to get past a test

Keep the test in your project, and if that defect comes back, the test fails before your customers see it. You pay to fix it once.

Your auditors start with evidence

Hand them the bundle. They can check it themselves and work with us on anything further, without taking our word for it.

Your engineers learn from your own defects

Your validated fixes show them the mistake and the correction in your own code. We work with you to spot the patterns, so the team stops repeating them.

Feature by feature, with sources

Other tools do important parts of this, and some lead us. As of November 2026, we haven't found another service that finds fake code, proves the fix with a test, and adds a Byzantine quorum certificate you can verify offline. Press any cell to see what we read. Hide a tool to compare fewer. If we got something wrong, tell us and we'll correct it.

Press a cell to see the evidence.

From each tool's public documentation or README, read November 4, 2026. "Not found" means we didn't find it in what we read, not that the tool can't do it. We have not run these tools side by side. Product names belong to their owners, who don't endorse this comparison.

Exactly what you get: one finding, one independent test and the exact code we ran, signed and verifiable on your own machine. FALSEWORK gives the same answer for the same code every time, and a person reviews every finding before it reaches you. The records above are our own sample code. Every record is co-signed by a 3-of-4 server quorum, so no single server can rewrite it.

PROOFLOOP · FALSEWORK · KEYSTONE · CAIN-42

PROOFLOOP, explained in 15 minutes

A long, captioned walkthrough: the fabricated result, the diff that proves nothing, the independent test, the signature, the four-replica quorum, the offline export, and the honest limits. The presenter is an animated character, not a real person. Visuals and captions start on their own; browsers block sound until you interact, so one tap turns the voice on.

Prefer to read or run it yourself? Three commands, one bundle. Prefer the offer? Start the $500 pilot.

All 105 CAIN-42 AI services, one API key

Budgets, payments, memory, knowledge graphs, verification, model routing, compliance, security scanning, cryptography, red-teaming and more: the CAIN-42 catalog lists 105 services; 104 of them were reachable on 2026-10-03, each behind the same authenticated gateway, each keeping every customer's data separate. The 98 services deployed in the 2026-10-03 release each passed a live acceptance test, including a cross-customer data check, before the gateway sent them traffic (see the evidence). CAIN-42 is pre-production: its release gate PRODUCTION_RELEASE_APPROVED is BLOCKED. Starter is $19.75 a month; Full, with every service, is $49.75 a month. New: Quorum-QaaS, Byzantine consensus as a service. Any enterprise can now get BFT without building it. See how every service grades on live checks →

Need custom policy enforcement for legacy enterprise databases? Scope a private gate in front of the systems you cannot change.

Request a Sovereign Node Deployment →

CAINBudget newEnterprise module

Give every agent a spending limit it cannot talk its way past. Atomic reservations, fail-closed when no budget exists, a signed receipt for every yes and no.

See CAINBudget →

CAINPay newEnterprise module

Card-style authorization for agent purchases: merchant allow and deny lists, per-transaction and daily caps, human approval above your threshold, hold / capture / void / refund, tamper-evident ledger.

See CAINPay →

VeritasEngine new

Check an agent's output before anything trusts it: JSON schema, exact arithmetic, SHA-256, code syntax, quotes against the source. Deterministic, signed, fails closed.

See VeritasEngine →

MemoryMesh new

Long-term memory for your agents with real BM25 search, and prompt-injection text quarantined before it can ever be recalled.

See MemoryMesh →

NexusMind new

One knowledge graph your agents share: every fact keeps its sources, contradictions are flagged instead of overwritten, and you can ask how any two things connect.

See NexusMind →

LexisGuardian new

Who decided, under what mandate, with what dissent. Decisions outside a mandate are refused; dissent is kept verbatim in a hash-chained register.

See LexisGuardian →

OmegaRouter new

Send each request to the right model by your own cost, latency and quality rules, with the reason for every choice and automatic failover when a model starts failing.

See OmegaRouter →

TEE Verifier new

Check your AWS Nitro enclaves and AMD SEV-SNP confidential VMs before you trust them: signatures, certificate chains to pinned AWS and AMD roots, chip and firmware binding, freshness, your PCR policy.

See TEE Verifier →

BLUiZZARD Governance new

Proposals, votes and preserved dissent for your team, with an outcome preview, EU AI Act screening of every proposal and a signed audit trail.

See BLUiZZARD Governance →

All 105 services, by category

ActionProof (2)

actionproof · action-firewall

Authorization (3)

cainbudget · cainpay · human-in-loop

Build & ship code (7)

talos-coder · talos-evolve · taloscode-migrate · taloscode-review · talosdev-archdiff · talosdev-refactor · visual-ide

Commerce & distribution (2)

agent-marketplace · quorum-oaas

Evidence (7)

agent-debugger · attestation · cainwitness · content-provenance · decision-intelligence · multi-agent-incident-tracer · zkproofvault

Execution Enforcement (2)

swarm-orchestrator · talos-shield

Governance (4)

blizzard-governance · guardian-scorecard · lexisguardian · talosops-governance

Identity (5)

a2a-guard · agent-id · cainaccounts · taloscrypt-keymgmt · taloscrypt-pqc

Industry applications (6)

arbitrage · caingrid · cainloan · cainroute · talosfin-earningsai · talosfin-statarb

Memory, retrieval & knowledge (5)

knowledge-graph · memorymesh · nexusmind · talos-rag · talos-vectorsearch

Model & ML infrastructure (8)

edge-optimizer · model-compressor · omegarouter · sparselogic-compiler · synthetic-fine-tuner · talosai-quantize · training-sandbox · weight-alchemist

Observability (3)

latent-inspector · observability · talosops-selfheal

Platform operations (2)

experimentation-notebook · feedback-engine

Policy (6)

caingovern · compliance-engine · legal-auditor · quorum-i18n · talosdoc-contract · taloslegal-caselaw

Reasoning, planning & orchestration (8)

autonomous-task-engine · causal-intelligence · causal-network · counterfactual-intelligence · echoworkforce · mcts-engine · spatial-synthesizer · stcn

Risk (10)

bias-detector · caindrift · contamination-scanner · context-health · hallucination-firewall · memory-integrity · metacognitive-enhancer · sentinel · talosdata-quality · trust-state-engine

Security (13)

adversarial-fuzzer · pii-redactor · secops-patcher · shadow-agent-scanner · talos-redteam · taloscode-security · taloscrypt-audit · taloscrypt-mesh · taloscrypt-store · taloscrypt-vault · talosguard-intel · talosguard-logiq · talosguard-siem

Unmapped (1)

tee-verifier

Verification (11)

cainbench · cainschema · crucible · derivation-copilot · rag-verifier · talos-verify · taloslogic-proof · topological-data-analysis · trajectorygate · vericoding-gate · veritasengine

CAIN Studio Suite: CAIN-42 products from San Jose, live on the hosted gateway

We moved the CAIN-42 products from our San Jose node to the production host in Atlanta. A product appears here only if it started cleanly in a sandbox and a real call to it worked. Pick one, change the request if you like, and press Run: it is a live call to that product, started on demand in its own sandbox with no outbound network, so the first call can take a few seconds. Every product is also on the CAIN-42 Hugging Face Space under Suite. On the Space you can also ask for a product in plain English: an AI model running in your own browser ranks every suite product by meaning and maps the whole suite.

Seen on LinkedIn · test it here · buy it here

Every product from our LinkedIn posts, live. Attack it yourself, then buy it.

Each card calls that product’s real engine on this server when you press a button. Nothing runs until you press. The red button sends the attack from the post, the green button sends a safe lookalike, and you can edit the JSON to try your own input. Every verdict is deterministic (no LLM judge), and “Copy curl” gives you the same call to run from your own terminal. The same live demos are on our Hugging Face Space.

NEW Thirteen more products, each run live on Oct 30 2026

Every card below calls its real engine on this server when you press a button. Press the red button to send the attack, the green button for a safe lookalike. The evidence for the Oct 30 batch is at /evidence/linkedin-products-2026-10-30/ (14/14 live checks; the script is in the bundle).

MCP Attestor · Payment Mandate Guard · Browser Agent Firewall · Agent Autonomy Lease · Self-Modification Firewall · Data-Exfiltration Killswitch · Memory Authority Firewall · Swarm Collusion Defense · Capability Lease · ARGUS Behavioral Envelope · ATLAS Transaction Assurance · PQC Hybrid Signing

Twelve more, checked live on Oct 29 with cases they had never seen

Supply-Chain Guard, Agent-ID, A2A Guard, Action Firewall, Content Provenance, TEE Verifier, Shadow AI Scanner, Crypto Audit, EU AI Act Classifier, Contamination Scanner, Trust State Engine and CainDrift. Their cases and recorded results are in the verification center and the Oct 29 evidence files. Every card on this page carries the standing $500 / 30-day pilot.

AI Agent Security Audit — fixed fee, signed report

We run your agent code, MCP tools and skills through these same scanners. You get ranked findings, each with the exact input that reproduces it, plus an Ed25519-signed evidence bundle you can verify offline with a verifier that contains none of our code.

Start with the $500 MCP Security Assessment: one MCP server or agent, up to 20 tools, three business days, a default-deny policy and a signed evidence bundle. Larger audits (agent code plus live red-team and remediation) are scoped separately and start at $5,000; they are not the entry offer.

Entry · $500One server or agent, up to 20 tools, static review, 3 business days.
Larger audit · from $5,000Agent code, tools and skills; live red-team and remediation are scoped separately.

Start with the $500 assessment · Book a scoping call for a larger audit

Loading the live demos… (needs JavaScript)

How everything works · twelve paragraphs

The Story of CAIN-42

CAIN decides, TALOS enforces, ARGUS persists the right to act, Evidence proves it — and MCPGate is the box all four ship in, installed on the customer's side of the wall.

  1. The problem CAIN-42 exists for

    AI agents used to answer questions. Now they run shell commands, change databases, call APIs, move money and start other agents. Most AI safety tools still read the text going in and out of a model, which is the wrong place to stand when the damage is done by an action. CAIN-42 stands in the execution path instead, at the moment an agent's intention is about to become something real. It holds one rule above all the others: no authorization, no execution. Being capable, confident or right last time earns an agent nothing. Unknown means no, and an error means no.

  2. An agent can only ask

    Everything starts with a proposal. An agent that wants to act sends CAIN-42 a typed request: which tool, which arguments, on whose behalf. A signed agent passport ties its identity, its model, its tool set and its authority scope to that exact call, so a swapped model or a borrowed key shows up as a different caller. What the agent says about itself, and whatever a tool or a web page told it along the way, is handled strictly as data. It is never read as instructions, which is why a prompt injection can change what an agent asks for but cannot change the rules that answer it.

  3. CAIN decides

    The request then runs through the CAIN-42 decision pipeline, a fixed chain of stages that each answer one question: is this identity still valid, is it entitled to this, does policy allow it, does it match known attack patterns, are the tool arguments real and well-formed, is the network destination on the allowlist, are the tools and skills the ones their publishers signed. Most of these stages can only restrict; none of them can turn a no into a yes. The result is one of three verdicts: allow, hold for a human, or block. You can read which stages enforce right now at /fabric/status; tenants can add intent and human-approval stages on top.

  4. Trust is computed, and it expires

    Behind the verdict sits the Trust Fabric, seven layers that work together. Trust state is computed from evidence and never from a model's opinion of itself. It decays with time, and it is deliberately lopsided: an agent earns trust back in small steps and loses it in large ones. Security context is carried across every boundary an action crosses, so authority cannot quietly grow when one agent hands work to another. A trust graph records how agents, tools, data and people are connected, and that graph is used to estimate how far an action could reach before it is allowed to run. Irreversible or wide-reaching actions need two operators.

  5. The JIT Decision Engine

    At the centre is the CAIN-42 Just-In-Time Decision Engine. It evaluates each proposal at the moment it is made, against the policy and the authenticated context in force at that moment, not against a permission granted hours earlier. It never lets a scope widen past what policy allows, and when it is unsure it says no. A yes is not a flag in a database. It is an Ed25519-signed envelope bound by SHA-256 to the exact request, so changing one parameter breaks the match. With it comes a capability token that lives for about thirty seconds and can be used once.

  6. The quorum

    One server saying yes is not enough. Hosted decisions are ordered and signed by a Byzantine fault-tolerant cluster: four replicas spread across US regions, built to keep working if one of them is down or lying. Nothing counts without a quorum certificate carrying three of the four signatures, and the gateway checks that certificate itself. The cluster sees only a decision id, a SHA-256 commitment and the preliminary verdict, not the request itself. No quorum means deny. And the quorum has a hard limit of its own: consensus co-signs, it never authorizes. Four replicas agreeing cannot make an unauthorized action authorized.

  7. TALOS enforces

    A signed decision still has to survive the TALOS verify kernel, the only door to execution. TALOS trusts nothing the caller says. It checks the envelope against its own trust roots, its own clock and its own ledger, and it compares the request it is about to run with the digest CAIN signed. Any doubt or any error inside the kernel produces a refusal. Its ledger lets one authorization be used once on that host. Only then does a sandbox launcher build a confined worker with no network, a restricted filesystem and filtered system calls, and prove each control took effect before any untrusted code runs. Today this gate runs live on our own host.

  8. ARGUS persists the right to act

    An agent that runs for hours cannot live on one approval, so CAIN ARGUS turns authority into a lease. The lease carries the scope, the limits, the validity window and the conditions under which it is renewed or revoked. The agent cannot extend its own lease, change its own conditions or vouch for its own good behaviour. ARGUS watches the path the agent actually takes, hash-chained step by step, so a string of small harmless-looking actions that add up to a harmful one is caught as a whole. When something material changes, the answer moves down a ladder: continue, continue under watch, re-authorize, restrict, halt. Nine restriction-only ARGUS stages run in the hosted path today.

  9. MCPGate, the box it ships in

    MCPGate is where all of this meets your tools. It sits in front of MCP servers, APIs and internal services and lets a call through only when it carries an authorization for that exact action. Extra guard stages can be switched on for specific attacks: poisoned or shadowed tool descriptions, the read-private-data-then-send-it-out pattern, tampered supply chains, rogue agent payments, hijacked AI browsers and abuse of agent-to-agent trust. The hosted gateway is live. The self-hosted form, meant to run inside your network so traffic and evidence stay with you, is packaged as a Kubernetes appliance. For the highest-impact actions the IHVRK is built to add a human signature bound to one exact action.

  10. Evidence proves it

    Every decision leaves a record, allowed or refused. Records are serialized as canonical JSON, signed with Ed25519, linked into a SHA-256 hash chain and rolled up into a Merkle root, so a changed byte anywhere is detectable. Evidence is never deleted, only superseded by a newer version. Every public claim on these sites lives in a signed registry with its status, its evidence and its limits. The verifiers that check all this import none of CAIN-42's code and run on your own machine, offline: the Verification Center and the Auditor Kit are the front door. You do not have to take our word for any of it.

  11. The loop that never closes

    CAIN-42 does not assume its own guarantees hold. An adversarial engine keeps attacking them with replayed tokens, substituted actions, forged certificates, laundered delegation and step-by-step privilege creep, and what it learns becomes new checks. A control loop watches live behaviour and can quarantine an agent or a whole trajectory, revoke its tokens and require two keys to bring it back, leaving a signed receipt each time. What actually happened is then compared with what was predicted, and the difference updates trust. That updated trust is the starting point for the next decision, which is why the system gets stricter with experience instead of more relaxed.

  12. The ecosystem

    Three sites carry it. cainstudio.online is the hosted control plane, with more than a hundred AI services behind one API key. mcpgate.online is the enforcement gate. clawx.click is where the proof is published. The five premier products below are built on these same engines: FALSEWORK audits whether an AI implementation is real, SCENIC tests how reliably an agent reaches its answer, NULLIUS re-derives a verdict from the evidence alone, SALLYPORT is the enforcement gate as an appliance, and Quorum-QaaS gives any enterprise Byzantine fault tolerance without building it. CAIN-42 is pre-production: its release gate PRODUCTION_RELEASE_APPROVED is BLOCKED. It is built by FIRME AI CORPORATION, a California corporation incorporated in October 2026. Every claim we make is published and signed with its evidence and its current status, where anyone can check it. That is the whole idea. Don't trust CAIN-42. Verify CAIN-42.

New · CAIN-42 Memory

AETHER-33 — memory as a service

Agent memory that cannot be talked into authority.

A memory service for autonomous agents: deterministic Okapi BM25 recall with no model and no network, injection text quarantined at write time and withheld until a named human releases it, a per-tenant SHA-256 hash chain over every write with truncation detection, tombstoned deletes that erase content but keep the proof, lexical contradiction flags that are never silently resolved, and a firewall that makes memory data and never permission. Thirty-three machine-checkable invariants run live.

Free · no key · no card · until 1 January 2027
33/33invariants, run against a real database on every request to /aether33/api/invariants
0authority a memory can grant: every view says grants_authority: false
SHA-256per-tenant chain; an edited entry or a removed tail fails verification
measuredlive latency from this host — see the report

Run the real engine

Nine steps on a throwaway database: a sourced fact, a hostile memory, default recall withholding it, an explicit recall showing it, a second tenant seeing nothing, a tombstone, a verified chain, and all 33 invariants. Nothing is pre-rendered.

Keep your own memories

Write a sourced fact and recall it. Per-visitor, no account. Send a stable visitor id to keep them across sessions.

Sixteen documentation pages cover the write path, BM25 recall, quarantine, provenance, deletion, contradiction, the authority firewall, tenant isolation, every invariant, agent integration, limits, the measured run, the free tier, and why Sparselogic is not a memory system: read the docs → · open the product page → · measured numbers →

CAG-L5 governed autonomy, and a recursive engineering loop you can re-run. CAIN-42 is not an “SAE Level 5” claim — CAG-L5 is CAIN’s own governance designation. What is real is the loop: a deterministic detector finds a defect, a frontier model acts, an independent sandboxed prover re-tests the original and the fixed file, and the record is Ed25519-signed and hash-chained so anyone can verify it offline. Detect → act → probe → prove → sign. Run it on our own code →

Measured on our own code: FALSEWORK re-checks the CAIN-42 codebase every 42 seconds and KEYSTONE applies only fixes it has proved. See the results.

New · CAIN-42 Studio Suite

Quorum-QaaS — Byzantine consensus as a service

Any enterprise can now get BFT without building it.

Byzantine fault tolerance used to mean hiring a distributed-systems team and spending years on a consensus cluster. Quorum-QaaS gives you ours through one API call. Send the SHA-256 digest of any record — a contract, a board decision, a model release, a log batch, an agent action — and a live four-replica PBFT cluster spread across four US regions orders it and commits it. A quorum of 3 out of 4 replicas must sign, so one replica can lie, crash or be compromised and the record still stands. You get back a receipt carrying the replicas’ own Ed25519-signed votes, and anyone can verify it offline with no CAIN code.

BFT without building it. One API key. One call. Proof anyone can check.

1 · The live cluster

2 · Co-sign

3 · Verify any receipt

curl -s https://cainstudio.online/api/v1/quorum/notarize \
  -H "X-API-Key: $CAIN_API_KEY" -H "content-type: application/json" \
  -d "{\"digest\": \"$(sha256sum contract.pdf | cut -d' ' -f1)\"}" > receipt.json

What a receipt proves: at least 3 of the 4 replicas signed a COMMIT for exactly your digest, at exactly that sequence, in a cluster whose member keys hash to the published membership hash. The cluster orders and signs the digest you send; your data never leaves you. Verify offline with verify_qaas_receipt.py and verify_pbft_qc_bundle.py (Python + cryptography, no CAIN code), pinning the hash from /api/v1/live-cluster/membership.

Self-serve with any CAIN Studio API key; up to 120 quorum co-signatures per hour per tenant. Live cluster: /api/v1/quorum/status. Hourly operational proofs of the same cluster are published at clawx.click/evidence.

Dogfooding · FALSEWORK × KEYSTONE on CAIN-42 itself

Every 42 seconds, CAIN-42 re-checks its own code: FALSEWORK re-scans anything that changed, and the result is published here, live.

Loading the live self-check…

We ran FALSEWORK and KEYSTONE on our own codebase. Here are the honest results.

FALSEWORK scanned 3,216 Python files of the CAIN-42 ecosystem for code that fakes a result, after excluding the files and reviewed findings listed at the end of this section: random numbers presented as measurements, success messages written in rather than computed, verdicts returned without a check, errors silently swallowed, leftover placeholders.

FALSEWORK gradefilesshare
REAL — no findings3,216100.0%
PARTIAL — a MEDIUM or HIGH finding00.0%
STUB — a CRITICAL finding00.0%

0 findings, by kind:

checkfindings

KEYSTONE so far: 19 file(s) run through the full loop (FALSEWORK finds → Claude fixes → sandboxed tests must fail on the original and pass on the fix → Ed25519-signed record): 0 fix(es) proved on the current standard, 5 legacy VERIFIED_FIX record(s) from before the independent-test rule (not counted as current), 14 not proved, 0 nothing to fix, 12 not run (the Claude API was unavailable; retried automatically). 0 flagged file(s) still to go; this section updates as the campaign continues.

#filefindingverdictreasons / applied
0scripts/legacy/clean_routes.pyunparseable_sourceNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
1scripts/cluster7/cain_trust_fabric_7_engine.pyunconditional_verdictNOT_VERIFIEDthe model's answer was cut off (max_tokens)
2cain/interop/benchmark.pyhardcoded_success_claimNOT_VERIFIEDthe model's answer was cut off (max_tokens)
3scripts/cain42_bft/clean_room_verifier.pyplaceholder_markerNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
4cain/substrate/cain_mcp_discovery.pyplaceholder_markerNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
5cain/substrate/cain_capability.pyplaceholder_markerNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect; Claude's test does not fully pass on the fixed code
6cain/substrate/cain_drift.pyplaceholder_markerNOT_VERIFIEDthe model's answer was cut off (max_tokens)
7cain/substrate/demo_refresh.pybare_except_passNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
8scripts/legacy/clean_routes.pyunparseable_sourceNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
9scripts/cluster7/cain_trust_fabric_7_engine.pyunconditional_verdictVERIFIED_FIX (legacy, no independent test)applied in 1342208f: self-audit derives its verdict from the phases actually run
10cain/interop/benchmark.pyhardcoded_success_claimVERIFIED_FIX (legacy, no independent test)applied in 1342208f; the honest SC-12 result exposed a real gap, closed in the same commit
11scripts/cain42_bft/clean_room_verifier.pyplaceholder_markerNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect; Claude's test does not fully pass on the fixed code
12cain/substrate/cain_mcp_discovery.pyplaceholder_markerNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
13cain/substrate/cain_capability.pyplaceholder_markerVERIFIED_FIX (legacy, no independent test)applied in 1342208f: unfinished OAuth adapters refuse instead of passing raw credentials; 31/31 tests
14cain/substrate/cain_drift.pyplaceholder_markerNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
15cain/substrate/demo_refresh.pybare_except_passNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
16platform-gateway/demo_refresh.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
17scripts/cain42_site/check_links.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
18scripts/review_package/publish_live.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
19scripts/architecture_reality_map.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
20scripts/cain42_bft/multi_region_bench.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
21scripts/cain42_evolution/bench_reality.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
22scripts/ironclad/prompt8/sign_manifest.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
23scripts/cluster13/cain_enforcement_path_validator_13.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
24scripts/bft_verifiable_run.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
25scripts/bench_clawx23.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
26cain/runtime/runtime.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
27scripts/cain42_bft/pbft_ab_bench.pybare_except_passNOT_VERIFIEDClaude API error 400: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'Your credit balance is too low to access the An
28cain/substrate/cain_mcp_discovery.pyplaceholder_markerNOT_VERIFIEDClaude's test also passes on the original, so it does not show the defect
29cain/substrate/cain_mcp_discovery.pyplaceholder_markerVERIFIED_FIX (legacy, no independent test)applied in 0dfd6f1e (both copies): MCP discovery no longer invents a server identity; MCP invariants pass
30cain/substrate/cain_drift.pyplaceholder_markerVERIFIED_FIX (legacy, no independent test)applied in a17a0b06: behaviour-drift reads real trajectories, no all-tenants wildcard; 8/8 tests

Found by applying a proved fix: Applying KEYSTONE's benchmark fix replaced a hard-coded 'blocked' verdict with the real outcome and exposed a real security gap: the interop bridge accepted an authorization signed under a different policy version. It is now refused (POLICY_VERSION_MISMATCH), commit 1342208f.

What we excluded, and why: 0 files of FALSEWORK’s own test material (scripts/falsework/sample_project (a deliberately fake demo) and benchmark/corpus (planted and copied defects used to measure FALSEWORK) are excluded from the count), and 30 finding(s) reviewed by hand as a false alarm: platform-gateway/academy_exam.py:225 (rng_fabrication); platform-gateway/academy_exam.py:226 (rng_fabrication); platform-gateway/academy_exam.py:227 (rng_fabrication); platform-gateway/academy_exam.py:229 (rng_fabrication); platform-gateway/academy_exam.py:275 (rng_fabrication); platform-gateway/academy_exam.py:275 (rng_fabrication); platform-gateway/academy_exam.py:276 (rng_fabrication); platform-gateway/academy_exam.py:276 (rng_fabrication); scripts/math_gates/blind_2026_11_02.py:119 (rng_fabrication); scripts/math_gates/blind_2026_11_02.py:119 (rng_fabrication); scripts/math_gates/blind_2026_11_02.py:120 (rng_fabrication); scripts/math_gates/blind_2026_11_02.py:120 (rng_fabrication); platform-gateway/mission3_range.py:117 (check_cannot_fail); cain/govfederation/lab.py:278 (secret_compare_not_constant_time); platform-gateway/academy_exam.py:179 (rng_fabrication); platform-gateway/academy_exam.py:193 (rng_fabrication); platform-gateway/academy_exam.py:198 (rng_fabrication); platform-gateway/academy_exam.py:212 (rng_fabrication); platform-gateway/academy_exam.py:212 (rng_fabrication); platform-gateway/academy_exam.py:215 (rng_fabrication); platform-gateway/academy_exam.py:244 (rng_fabrication); platform-gateway/academy_exam.py:245 (rng_fabrication); platform-gateway/academy_exam.py:246 (rng_fabrication); platform-gateway/academy_exam.py:255 (rng_fabrication); platform-gateway/academy_exam.py:287 (rng_fabrication); platform-gateway/academy_exam.py:289 (rng_fabrication); platform-gateway/academy_exam.py:294 (rng_fabrication); platform-gateway/academy_exam.py:302 (rng_fabrication); platform-gateway/academy_exam.py:303 (rng_fabrication); platform-gateway/academy_exam.py:316 (rng_fabrication).

What this scan cannot see: FALSEWORK looks for fabricated results, swallowed errors, placeholder markers and unconditional verdicts. It does not find security, performance or design defects.

The 42-second self-check, on the record: 39,997 checks since 2026-10-15T20:45:48Z, each one a line in ticks.jsonl that carries the SHA-256 of the line before it, so a skipped or edited check breaks the chain. A check re-scans with FALSEWORK the files that changed; it does not re-run KEYSTONE.

Check it yourself: the signed evidence bundle and its verify_bundle.py (no CAIN code) recompute every number above.

Newest product · CAIN-42 Studio

KEYSTONE — find the fake, fix it, prove the fix

Watch it happen, line by line, live on this page: FALSEWORK hunts every line for fake results, stubs and unverified claims and names the exact line; Claude Code rewrites that line; CAIN-42 proves the fix and signs the record — and the console below keeps a live, re-checkable tally of every defect ever fixed here. Not a video. Not a claim. The running engine.

Our competitors say “trust us.” We say: don’t trust CAIN — verify CAIN. Use KEYSTONE instead.

  1. 1FALSEWORK finds every defect
  2. 2Claude fixes it
  3. 3CAIN-42 records it as auditor evidence
  1. 1FALSEWORK finds the defect
  2. 2Claude Code fixes it
  3. 3CAIN-42 records the evidence
…sample · standard library only
Loading the samples…
Bring your own codePython · standard library only · up to 20 KB · code you paste runs only in a sealed sandbox
your_code.pyyou paste it
Paste Python code, then attack it.

Want FALSEWORK across your whole codebase? 30-day pilot: $500. We scan your repository and walk your team through every finding. Start a pilot →

Auditor’s deskverify any record · download the evidence
record.jsonpaste to re-check
Download all evidence (ZIP)
Recent signed recordsnewest first · each downloadable

Loading…

KEYSTONE Consolelive evidence dashboard · every number read from the signed ledger, nothing typed
Signed-evidence ledgerlive

Reading the ledger…

Defects found by FALSEWORKby check

Loading…

Live activitynewest first · auto-refresh 15 s

Loading…

This is the moat: only KEYSTONE records evidence of every bug it fixes. The other code-repair tools find and fix — then the fix disappears into a chat window. KEYSTONE writes each fix into a signed, hash-chained ledger and lets you watch it happen live: the defect, the exact lines changed, the tests that prove it, the verdict, the SHA-256 chain link and the Ed25519 signature — every record re-checkable by you, and by any auditor, offline. The console below is that ledger, updating in real time as fixes land. No competitor hands you proof of the fix.

Every run writes a signed record: canonical JSON, SHA-256 chained to the previous record, Ed25519-signed. Re-check any record with one click; the key is public at /keystone/public-key. Model-written code runs only inside a sealed bubblewrap sandbox (no network, read-only system). A fix is called a fix only when FALSEWORK re-scans clean and the tests pass on the fix and fail on the original; otherwise the record says NOT_VERIFIED.

New in the KEYSTONE family · CAIN-42 Studio

MCPGate KEYSTONE — harden an MCP tool, prove it was hardened

The MCP security scanner reads a tool definition the way a client receives it — looking for a description that hijacks the assistant, a leaked credential, or a raw command parameter with no constraint. Claude hardens it. Then the SAME scanner re-reads the result, and only a clean second opinion is signed into the ledger. Pick a sample or paste your own MCP tool definition.

MCP tool definition · name · description · input_schema
Scanner findings & signed record
Loading the samples…
Auditor’s deskverify any signed record · download the evidence
record.jsonpaste to re-check
Download all evidence (ZIP)
Recent signed recordsnewest first · each downloadable

Loading…

MCPGate KEYSTONE consolelive evidence dashboard · every number read from the signed ledger
Signed-evidence ledgerlive

Reading the ledger…

Findings by scanner checkby type

Loading…

Live activitynewest first

Loading…

The moat, again: proof, not opinion. An MCP security scanner finds a poisoned tool; a model can rewrite it. Only MCPGate KEYSTONE re-reads the rewrite with the same deterministic scanner and signs the record — the finding, the hardened definition, the scanner's second opinion and an Ed25519 signature chained into the CAIN-42 ledger. A hardening is called a hardening only when no HIGH or MEDIUM finding remains; otherwise the record says NOT_VERIFIED. Every record is re-checkable and the evidence pack downloads for an auditor.

Pairs with the sibling product MCP-Attestor: scan the descriptor here, harden it, hand the clean descriptor to MCP-Attestor to probe the handler, and you hold one evidence pair. Both reuse the same MCP scanner and the same bubblewrap sandbox.

AI Agent Security Audit · CAIN-42 Studio

10-minute MCP server audit — point it at a server, get a signed verdict

Give it a public MCP server’s URL and it reads the tool definitions that server advertises, then runs the real MCP security scanner over them — descriptions that hijack the assistant, tool-poisoning blocks, leaked credentials, raw command parameters with no constraint. The verdict is SHA-256 chained and Ed25519-signed, so you can verify it offline without trusting us. Read-only: it never calls a tool. Try a sample server, paste a tools/list, or audit a live URL.

Loading samples…

The moat: proof, not a PDF. Other scanners hand you a report and say “trust me.” This hands you a signed record — the exact tool list that was scanned, the findings, and an Ed25519 signature chained into the CAIN-42 ledger that re-verifies offline with a tool containing none of our code. It is a heuristic static scan of the advertised definitions, not a proof of safety; the paid audit adds live red-team testing. Download a signed evidence bundle →

Want a person to check it? MCP Server Security Check · $1,500. Automated scans flag harmless text too, so we read every finding and keep only what is real, check how agents sign in and where your tokens travel, and send a signed report with fixes in 3 business days. One server, up to 50 tools, read-only, with your written permission. Counts in full toward the $5,000 audit. Book the $1,500 check

New in the KEYSTONE family · CAIN-42 Studio

Six new KEYSTONE products: detect, fix, prove, sign

Each one runs a deterministic detector, lets Claude propose the fix, proves the fix with an independent check, and signs the record with Ed25519 so an auditor can verify it offline. Press “Run live” on any card: it calls that product’s engine on this server.

🦞 OpenClaw KEYSTONE (ClawGuard)

OpenClaw skills and plugins

Scans an OpenClaw skill for credential theft, hidden shell commands and instructions aimed at the agent. Claude rewrites the skill; CAIN-42 proves the fixed skill runs inside an isolated sandbox with its own key.

API → · Signed evidence bundle →

SWARM KEYSTONE

Multi-agent delegation

Maps who delegates to whom in a CrewAI, LangGraph or AutoGen swarm and catches authority escalation, delegation loops and collusion. The proof checks the hardened graph is acyclic and every hand-off only narrows authority.

API → · Signed evidence bundle →

VIBEGUARD KEYSTONE

AI-written code

Reads code an AI assistant wrote and flags invented or typosquatted packages, swallowed errors and metrics made from random numbers. Every import goes through CAIN-42's supply-chain guard before the fix is accepted.

API → · Signed evidence bundle →

MEMGUARD KEYSTONE

Agent long-term memory

Inspects a memory before an agent stores it: sleeper instructions, cross-tenant leaks and exfiltration links. Uses CAIN-42's signed prompt-injection classifier, then proves the cleaned memory is free of the residue.

API → · Signed evidence bundle →

SURFGUARD KEYSTONE

Browser agents

Checks a browser agent's plan before it runs: wire transfers, account deletions and other irreversible clicks. Critical steps wait for a human approval that only CAIN-42 can sign, bound to the exact steps and an expiry.

API → · Signed evidence bundle →

ACTUARY KEYSTONE

Agent-fleet risk score

Scores a fleet of agents 0–1000 from its real CAIN-42 decision records, with every adjustment shown. Claude proposes policy rules; a replay of the same history proves each high-risk action is now gated. A risk score from evidence; no insurer is behind it.

API → · Signed evidence bundle →

KEYSTONE family · AI coding agents · CAIN-42 Studio

CODEGUARD KEYSTONE — a policy gate in front of every command your coding agent runs● checking…

Claude Code, Cursor and Codex run shell commands and write files on your laptop and in CI. CODEGUARD reads each action before it runs and answers DENY, ASK A HUMAN or ALLOW. A deterministic parser makes the call, not a model: it unwraps sudo, sh -c, $(…), backticks, quoting tricks and base64-to-bash, so the hidden command is the one that gets checked. Anything it cannot resolve goes to a person, never through. Type below: every keystroke is checked by the production gate.

$

Real incident patterns. Pick one:

No model in the decisionFixed rules, the same answer every time. Auditors can replay it.
Unknown never means allowedUnparseable, computed or unknown commands wait for a person.
Approval only from CAINAn approval is an Ed25519 token tied to that exact action and an expiry. The agent cannot write its own.
Signed receipt per decisionProves what the gate said. It holds a digest of the action, not your command text.

1 · Get the hook (about 30 lines, read it first)

curl -fsSL https://cainstudio.online/api/v1/codeguard-keystone/hook.py -o ~/.claude/codeguard-hook.py

2 · Add it to ~/.claude/settings.json

{"hooks": {"PreToolUse": [{"matcher": "Bash|Write|Edit|MultiEdit|NotebookEdit|Read",
  "hooks": [{"type": "command", "command": "python3 ~/.claude/codeguard-hook.py"}]}]}}

The hook only adds denials and approval prompts. An ALLOW prints nothing, so your own permission settings still apply. If the gate can’t be reached, it asks you rather than allowing. The pending tool call is sent to the gate and not stored. Set CODEGUARD_SEND_CONTENT=0 to keep file contents on your machine. API: samples · install · public key · signed evidence bundle.

The moat: proof, not a prompt filter. Most coding-agent guardrails ask a model whether a command looks dangerous. CODEGUARD parses it, decides by rule, and signs the decision. When Claude proposes a safer command, the same gate re-checks it and the record is chained into the KEYSTONE ledger. Pairs with MCPGate KEYSTONE for MCP tool calls and KEYSTONE for proved code fixes.

KEYSTONE family · pull requests · CAIN-42 Studio

KEYSTONE CI — gate every AI-agent pull request and sign the verdict● checking…

AI agents now open pull requests faster than people can read them, and the same mistakes repeat: tests skipped or deleted to turn CI green, workflows that hand repository secrets to any fork, committed keys, typosquatted packages, hidden Unicode that makes code run differently from how it reads, and poisoned AGENTS.md files. KEYSTONE CI reads the diff with fixed rules, not a model, and answers BLOCK, REVIEW or PASS. Each answer is an in-toto attestation in a signed DSSE envelope that you can keep next to the build and check offline. Paste any public GitHub PR below: the production gate fetches it and checks it now.

Test tamperingSkipped, focused or deleted tests, removed assertions, assert True.
CI takeoverSecrets exposed through pull_request_target, script injection, write-all, unpinned actions, secrets echoed into logs.
Supply chainEvery new pip/npm dependency is checked by the CAIN-42 supply-chain guard, which catches typosquats and rogue package indexes.
Agent tamperingPoisoned AGENTS.md / CLAUDE.md / .cursorrules, agent permission files, CODEOWNERS.
Hidden codeTrojan Source bidirectional-override characters, ASCII-smuggling tag characters and zero-width characters, shown in the diff instead of hidden.
Risky codeCommitted keys (redacted in the output), TLS checks turned off, SQL built from strings, code that fails open.

Add it to any repository: one workflow file

curl -fsSL https://cainstudio.online/api/v1/keystone-ci/action.yml -o .github/workflows/keystone-ci.yml

The workflow runs on every PR with read-only permissions. It adds annotations on the exact lines, fails the check on BLOCK (set FAIL_ON: REVIEW to be stricter), writes a badge into the job summary and uploads the signed attestation as a build artifact. The PR diff is sent to the gate and not stored; the signed verdict and findings are. Read the file before you commit it.

API: samples · action.yml · latest attestation · public key · signed evidence bundle.

The moat: proof, not a reviewer's opinion. AI code reviewers leave comments a model wrote, and the next run may say something different. KEYSTONE CI gives the same verdict for the same diff every time, binds it to the diff's SHA-256 and the head commit, and signs it in the standard supply-chain attestation format (in-toto/DSSE). An auditor can check a year later that this exact PR was gated and what the gate said. Pairs with CODEGUARD, which checks agent actions while the agent is still working, and KEYSTONE, which proves code fixes.

KEYSTONE family · agent credentials · CAIN-42 Studio

BROKER KEYSTONE — a credential for one action, not a key for everything● checking…

Agents usually get standing API keys, so one prompt injection can spend them on anything. With CAIN Action Credentials, the agent asks for one action. CAIN checks that agent's grants and issues a credential tied to that audience, that method, that exact path and the SHA-256 of that exact body. It lives 60 seconds, works once, and any service can check it with a standard EdDSA signature and the published key. The agent can hand a sub-agent a narrower credential, never a wider one. Try it: every step below is a real request to the production issuer and a demo API that accepts nothing else.

Demo grants (the public page can only issue credentials for these agents and the demo API):

    Minting key …. It is separate from the KEYSTONE evidence key and is held in software on the gateway host; there is no hardware security module behind it yet. Each issuance is logged as a hash-chained, signed record that holds the credential’s SHA-256, never the credential itself. The demo API returns labelled demo data and changes nothing. API: JWKS · verifier for your service · latest issuance record · issuance log bundle.

    The moat: authority that only shrinks, and proof of every grant. OAuth access tokens and API keys say who you are. A CAIN Action Credential says exactly what one call may do, and it ties a sub-agent’s credential to its parent so delegation can only narrow. The issuance log lets an auditor reconstruct every credential that was ever issued. This extends CAIN’s credential broker, which keeps stored keys away from agents, and pairs with CODEGUARD and KEYSTONE CI.

    KEYSTONE family · human approval · CAIN-42 Studio

    APPROVAL KEYSTONE — people approve the exact action, in Slack, and the approval is proof● checking…

    When an agent wants to do something risky, a person has to say yes, and the yes has to cover exactly what will run. APPROVAL KEYSTONE binds every request to the action’s SHA-256 and requires N of M approvers. The agent can never vote, each person counts once, and one Deny ends it. Each approver gets a one-time signed ballot behind the Approve and Deny buttons in Slack. When the quorum is met, CAIN signs an approval that buys one credential for that action and nothing else. Below, a billing agent wants to delete an invoice. Every step is a real request to production.

    Action sha256 …

    The cards above are the actual Block Kit message CAIN posts to Slack (from /requests/{id}/slack), drawn in this page. In this demo you hold every approver’s ballot so that one person can try the whole flow. In a real workspace, each ballot goes only to its approver as a Slack DM. The Slack endpoint checks Slack’s request signature and maps each Slack user to an approver. Until a workspace is configured, that endpoint refuses every request. Every request, vote and outcome is a hash-chained, signed ledger record. API: samples · latest ledger record · ledger bundle.

    The moat: an approval you can prove, for the exact thing that ran. Most approval steps are a button in a chat that says “OK”, and nothing ties it to what the agent then does. Here the approval names the action’s digest and the approvers, and the credential the agent receives can only perform that one action, once. It builds on CAIN’s approval queue and Slack alerts, and pairs with BROKER KEYSTONE.

    KEYSTONE family · agent spend · CAIN-42 Studio

    SPEND GOVERNOR — stop a runaway agent before the bill does● checking…

    Runaway agents rarely hit a monthly limit first. They burn money in a retry storm, call the same tool in a loop, or spend in amounts too small to notice one at a time. The governor checks every charge against the agent’s budget and every budget above it (workflow, tenant). It also enforces a spend-rate limit at each level and trips a circuit breaker on identical repeated calls. A tripped agent is stopped until a person resets it with a reset that CAIN signs. The agent can’t reset itself. You get your own budget tree on the production governor; pick an agent and a behaviour.

    Each charge is checked atomically across every level, so concurrent agents can’t overspend a shared parent; this is tested with four processes racing. Amounts must be finite and above zero. While building this, we found and fixed a bug in CAIN’s budget engine that accepted negative amounts. In this demo you play the operator. In production, a reset goes through APPROVAL KEYSTONE. Trips and resets are hash-chained, signed ledger records: latest record · ledger bundle.

    The moat: limits on spend rate and repetition, not only on totals. Billing alerts arrive after the money is gone, and a monthly cap won’t stop a loop that burns a day’s budget in minutes. The governor decides on every charge, before it happens, at every level of the organisation, and keeps signed proof of every stop. Pairs with BROKER KEYSTONE (what an agent may do) and CODEGUARD.

    KEYSTONE family · agent run records · CAIN-42 Studio

    FLIGHT RECORDER — a signed black box for every agent run● checking…

    When an agent does something it shouldn’t, the first question is what actually happened, and an ordinary trace can be edited after the fact. The flight recorder writes each step of a run as an OpenTelemetry gen_ai span, links every span to the one before it by SHA-256, and seals the run with an RFC 6962 Merkle root signed with Ed25519. Below, a refund agent runs on the production recorder. Then you try to rewrite history.

    Every check on this card is computed by the server, not by this page. Erasing a payload keeps its salted commitment, so a GDPR erasure leaves the chain, the Merkle root and the seal verifiable. An inclusion proof shows an auditor one event and the signed root, and nothing else in the run.

    The moat: a record the agent’s operator can’t quietly rewrite. Tracing tools show you what happened; the flight recorder lets someone who doesn’t trust you check it, offline, against a pinned key. Pairs with SPEND GOVERNOR, APPROVAL and BROKER, whose decisions it records.

    KEYSTONE family · release gate for AI agents · CAIN-42 Studio

    AGENT-CI — don’t ship an agent that got worse● checking…

    A new model or prompt can give the same answers and still take a different, riskier path to get there: skip the policy check, loop on a retry, delete something and put it back. AGENT-CI runs the old and new versions of an agent on the same test cases and compares both the answers and every tool call. A deterministic gate gives the verdict, with no LLM judge. A separate clean-room verifier re-derives that verdict in a sandbox before it is signed. Below, a support agent moves from v1.4 to v1.5. Pick a change and run the gate.

    Edit the suite JSON (cases, policy, baseline and candidate runs)
    In your CI: one standard-library file. Exit code 0 ships, 1 blocks, 2 means the gate could not decide, so the pipeline stops.
    curl -sO https://cainstudio.online/api/v1/agent-ci-keystone/client.py
    python3 client.py suite.json --strict

    Every verdict on this card comes from the production gate, not from this page. The signed record is hash-chained and verifies offline with the clean-room verifier against the pinned KEYSTONE key.

    The moat: a release decision someone else can re-check. Eval dashboards score answers; AGENT-CI also grades the path the agent took, and it hands your auditor a signed verdict they can re-derive without trusting us. Pairs with FLIGHT RECORDER, which records what the agent did once it shipped.

    KEYSTONE family · attack and patch agent tool policies · CAIN-42 Studio

    REDTEAM — break your agent’s tool policy before someone else does● checking…

    An allow list that says “only files under docs/” is only as good as the gate that reads it. docs/../.env, an encoded slash or a hidden @ in a URL can pass the gate while the tool reads something else. REDTEAM generates bypass calls from your policy, fires them at the gate and compares what the gate approved with what the tool would actually touch. It then writes the smallest patch that closes every breach without blocking legitimate calls, and proves the patch in a sandbox with an independent verifier. Pick an agent and run the red team.

    Edit the policy JSON

    Every attack, verdict and patch on this card is computed by the production engine, not by this page. Click a tile to see the exact call and try your own bypass value against the live gate. Records verify offline with the clean-room verifier against the pinned KEYSTONE key.

    The moat: a patch that comes with its own proof. Scanners hand you a list of findings; REDTEAM hands you the fix, a second implementation that re-runs every attack against it, and a signed record your auditor can check offline. Pairs with MCPGate KEYSTONE and BROKER, which enforce the patched policy at the boundary.

    Proof-carrying attestation · CAIN-42 Studio

    MCP-Attestor — scan a tool, probe its handler, prove the attestation

    An MCP tool is not trusted because its description looks clean. MCP-Attestor runs the description through the scanner, then runs the handler itself inside a sealed bubblewrap sandbox — no network, read-only — against an adversarial test that tries to trigger the very behavior the scanner flagged. The result is recorded only when the fix passes the test and the test fails on the original; that record, the verdict, the SHA-256 chain link and the Ed25519 signature are re-checkable below and as a standalone bundle.

    A tool description is not the handler; this test runs the handler.

    1. 1Scanner attacks the descriptor
    2. 2Probe handler in sandbox
    3. 3Record signed attestation
    …sample · standard library only
    Auditor — verify any record
    Download all evidence (ZIP)
    Console — the signed attestation ledger
    Finding taxonomy
    Controls & identity
    Signed event feed

    This is the moat: only MCP-Attestor records evidence of the handler, not the description. The other MCP security tools scan a description and hand back a clean badge. MCP-Attestor runs the handler in a sealed sandbox, fixes the finding, and proves the fix by a test that fails on the original and passes on the fix — then signs the record, the SHA-256 chain link and the Ed25519 signature, into the CAIN-42 ledger. A handler is only called clean when that loop closes; otherwise the record says NOT_VERIFIED.

    Every run writes a signed record: canonical JSON, SHA-256 chained to the previous record, Ed25519-signed. Re-check any record with one click; the key is public at /mcp-attestor/public-key. The sealed sandbox (bubblewrap, no network, read-only system) runs the descriptor scan and the handler probe in two passes. A finding is only closed when the test fails on the original handler and passes on the hardened handler; otherwise the record says NOT_VERIFIED.

    New in the KEYSTONE family · CAIN-42 Studio

    VeriCoding KEYSTONE — a machine proved the fix, for every input

    Give a function a contract — a precondition and a postcondition. Z3, a real SMT solver, either proves the contract holds for every possible input, or returns the exact input that breaks it. Claude rewrites the function. Then Z3 proves the rewrite satisfies the contract for all inputs, and CAIN-42 signs it. Not “the tests pass.” A proof, or a counterexample.

    Function · verified subset: int/bool, if/else, + - * // %, abs/min/max
    Z3 verdict & signed record
    Loading the samples…
    Auditor’s deskverify any signed record · download the evidence
    record.jsonpaste to re-check
    Download all evidence (ZIP)
    Recent signed recordsnewest first · each downloadable

    Loading…

    VeriCoding KEYSTONE consolelive evidence dashboard · every number read from the signed ledger
    Signed-proof ledgerlive

    Reading the ledger…

    Functions provedby function

    Loading…

    Live activitynewest first

    Loading…

    The strongest moat in the family: a proof, not a test. Every other code tool samples inputs and hopes. VeriCoding KEYSTONE negates the contract and asks Z3 for a satisfying assignment: a real input proves the bug; proving the negation unsatisfiable means the fix holds for every input in the space — and CAIN-42 signs the record. A proof is called a proof only when Z3 proves it and the signature is unchanged; otherwise the record says NOT_VERIFIED. The verified subset is stated up front, never oversold.

    Part of the KEYSTONE family alongside KEYSTONE, MCPGate KEYSTONE and MCP-Attestor — same 5-stage loop, same evidence convention, one key that verifies every record. Verify any of them with the shared family verifier in the evidence pack.

    CAIN-42 · Authority Notary v3

    Six layers between an AI agent and the real world.

    A notary, not a firewall. Six checkable layers answer who authorized this, may it proceed, is the agent’s world still true, did the effect match the authorization, and can a stranger prove it without trusting us. Every layer can only refuse. A quorum co-signing is never an authorization. The buttons below call the real engine on this host, and they show the refusals as well as the passes.

    L2: checking the proof certificate…

    Nothing run yet. Each button calls POST /notary/v3/… on this host.

    Honest limits. L2’s decision algebra is proved with Z3 (bounded symbolic); the Lean 4 equivalence theorem is pending and not claimed. L0 is a verifiable local quorum with the production arithmetic (N=4, Q=3), not a claim that the production cluster is fault-free. L4 is a conformant local profile of AP2’s open-mandate idea, not AP2 certification. Same-operator evidence: no third-party audit, no SOC 2, and no customer has run this yet.

    CAIN-42 Premier Suite

    The Five Premier Products

    The four strongest products built on the CAIN-42 engines. Every card carries its status and its limits. The first four were smoke-tested and stress-tested on 2026-10-13: read the results or re-run the checks yourself.

    LIVE ENGINE

    30-day pilot · $500

    FALSEWORK

    Prove it's real.

    The buyer pain
    Your team or vendor ships “AI-powered” features and nobody can tell what is real.
    What it does
    A mechanical audit engine that grades an AI implementation REAL, PARTIAL, STUB or UNKNOWN. Static checks (source patterns plus an AST cross-check of each route against its engine) look for verifiers that cannot fail, errors that grant access, health checks that check nothing, mocks shipped as real services, random numbers dressed as computation, hard-coded success claims and placeholder markers. A live differential test sends the same endpoint two different inputs and flags byte-identical answers.
    Engine
    cainwitness
    Start a $500 pilotMechanics, tests and limits →
    LIVE ENGINE

    four engines, self-serve API

    SCENIC

    CI for agents.

    The buyer pain
    Your agent gets the right answer through a dangerous, wasteful path, and nothing scores that.
    What it does
    Agent reliability testing with no LLM judge. CAINBench runs fixed regression suites against a real agent endpoint and diffs any two runs. TrajectoryGate grades a successful run for duplicate calls, spend the answer did not need (reverse search over the dependency graph) and risky-then-corrected steps. A root-cause tracer attributes a broken multi-agent run to a step, and a contamination scanner probes for benchmark leakage.
    Engine
    cainbench · trajectorygate · multi-agent tracer · contamination-scanner
    Start a trialMechanics, tests and limits →
    PUBLIC PREVIEW

    reference tools free

    NULLIUS

    On the word of no one.

    The buyer pain
    Everyone claims their AI is safe and verifiable. Nobody can prove it independently.
    What it does
    A verification toolchain built on one rule: never trust the claimant's own “verified” flag. 18 standalone verifiers re-derive the verdict from the evidence with zero CAIN imports. Evidence is graded on a six-level independence scale, from SELF_REPORTED to INDEPENDENTLY_CORROBORATED.
    Engine
    the cain-*-verify family + the evidence spine
    Download the verifierMechanics, tests and limits →
    PILOT PROGRAM

    live gate on our host today; pilots in your cluster

    SALLYPORT

    The only door.

    The buyer pain
    Autonomous agents hold credentials and execute consequential actions. Who authorizes them, really?
    What it does
    An enforcement appliance built to run inside your cluster. It independently verifies signed authorization envelopes against your trust roots, binds each one by SHA-256 to the exact execution request, and runs the action in an unprivileged, network-less, scoped sandbox, or refuses. Authority is a lease that is re-checked continuously (CAIN ARGUS).
    Engine
    TALOS kernel · CAIN trust kernel · PBFT · ARGUS
    Request a pilotMechanics, tests and limits →
    LIVE ENGINE

    self-serve API, any API key

    QUORUM-QAAS

    BFT without building it.

    The buyer pain
    You need a record nobody can quietly rewrite, but Byzantine fault tolerance takes a distributed-systems team and years to build.
    What it does
    Byzantine consensus as a service: any enterprise can now get BFT without building it. Send the SHA-256 digest of any record; a live four-replica PBFT cluster across four US regions orders and commits it with a quorum of 3, and returns the replicas’ own Ed25519-signed votes as a receipt anyone can verify offline.
    Engine
    CAIN-42 PBFT · quorum certificates · cain-mr-02
    Co-sign a recordLive cluster status →

    The free public layer: NULLIUS verifiers — free, no key. The written spec is not published yet. Each path is bought separately.

    Get started freeWatch it block an attack

    Verify CAIN-42 yourself in seconds, on your own computer: open the Verifier Room on this page and copy one block into a terminal. It downloads a published evidence bundle and its clean-room verifier and recomputes the result — no account, no contact, nothing taken on trust.

    ⚡ FIXED-PRICE ASSESSMENT · 3 BUSINESS DAYS

    MCP Security Assessment — $500, fixed price

    One MCP server or one agent, up to 20 tools. A static review of the tool definitions, a severity-ranked report, a default-deny MCPGate policy, and a signed evidence bundle you verify offline. No live exploitation.

    See the scope →
    WHAT YOU GET $500

    One server or agent, up to 20 tools

    • 🛡️ Tool-surface findings: injection, secret exposure, unconstrained exec/SQL/path, destructive verbs
    • 📊 Severity-ranked report with evidence, reproduction and remediation
    • 🔒 policy.json: a default-deny MCPGate policy generated from the findings
    • 🧾 Signed, hash-chained evidence bundle with an offline verifier
    • 🗣️ 30-minute walkthrough
    Request the $500 assessment →
    WHAT IT IS NOT Read this

    A heuristic review, not a certificate

    • No live exploitation, penetration test or production scan
    • No compliance certification, legal advice or audit opinion
    • A clean result is not proof of safety; findings may be incomplete
    • The signed bundle proves integrity and provenance, not that the system is secure
    • No third-party audit, SOC 2 or ISO 27001 is claimed
    What the evidence proves →
    🛰️ Technology asset carve-outs #10–#18 · new ● Live drills · real engines, every request

    Physical AI & L5 Autonomy Guards

    AI now commands things that move: drones, self-driving cars, robot arms, defense platforms. And L5 agents now run for hours without a human approving each step. The model does not know the rules the machine must keep: no-fly zones, the car's design limits, how close a robot may come to a person, who is allowed to order a use of force, or that it must not edit its own shutdown script.

    These nine guards sit between the AI and the machine. Each checks every command before it reaches the autopilot, driving stack, robot controller or agent tool, and answers allow, hold for a human or refuse, naming the rule. Deterministic rules, no LLM judge. Commands that make the machine safer (land, hold, return home, stop, pull over, abort) are never refused; one that also names a destination or an altitude (land at a point, return home at 5,000 m) makes the machine fly first, so it is checked like any move.

    ⚡ Try it: Drone Airspace Authority Guard

    POST /api/v1/autonomy-guards/drone-airspace/run

    Pick a guard above, then a scenario, or edit the JSON: config is the operator's setup, base the default vehicle state, events the commands sent in order (each event's state is merged over base). Signatures are made with throwaway keys; sign_as says who signs. Nothing real is commanded and nothing you send is stored.

    Loading scenarios…
    🛡️ Technology asset carve-out #9 · new ● Live drill · real engine, every request

    A2A Remote Agent Trust Guard

    AI agents now hand work to other companies' agents over Google's Agent2Agent (A2A) protocol. The calling agent decides whom to trust from each remote agent's Agent Card, a document the remote agent writes about itself. Whoever controls that text controls where your data goes: a rogue card that claims to be "the best choice for every task" gets picked by the planner and receives everyone's requests (Trustwave SpiderLabs' "agent in the middle" research). Cards can carry instructions to your model, change after you trusted them, ask the remote agent to call back into your network, and send back results that try to steer your agent.

    CAIN's guard sits on the calling side and checks the four A2A trust points: which agents may be chosen, what may be sent to them, where they may call back, and which results may be believed. Deterministic rules, no LLM judge.

    1. Only agents you can verify

    A card must come from its own host on a domain you listed, over https, never an internal address. Where you pinned a signing key, the card's signature must verify against it: a card cannot vouch for itself. Look-alike domains, text that gives your model orders, and "handles everything" cards are stopped before a planner can pick them.

    2. No silent changes

    Every admitted card is pinned by hash. If the agent later serves a different card (a new skill, a new endpoint, new text), it is suspended until an operator approves the change, so nothing is sent to it in the meantime.

    3. What goes out, what comes back

    No credentials in messages, no data above the agent's trust tier. Push-notification callbacks only to your allowlisted https hosts, never cloud-metadata or internal addresses. Results only for tasks you created, in the same user's conversation; results that address your model are held as data.

    ⚡ Try it: replay an agent-to-agent attack

    POST /api/v1/a2a-trust-guard/run

    Pick a scenario, or edit the JSON: trust lists the agent domains you work with and their tier, events are cards offered for discovery (admit_card), messages (send), callbacks (push) and results (result). The demo signs cards with a throwaway key in place of the partner's publisher. No agent is contacted and nothing you send is stored.

    Pick a scenario above or edit the JSON.
    🛡️ Technology asset carve-out #8 · new ● Live drill · real engine, every request

    Browser Agent Action Firewall

    AI browsers and computer-use agents act inside your logged-in sessions, and every page they read is text an attacker can write. In 2025 that was enough to make one read a mailbox and post a sign-in code to a public thread (Brave's Perplexity Comet disclosure), smuggle mailbox data out in a base64 URL (LayerX's "CometJacking"), treat a broken link pasted in the address bar as a trusted command (NeuralTrust's ChatGPT Atlas finding), and type bank details into a look-alike site or click a fake CAPTCHA's download button (Guardio's "Scamlexity" and "PromptFix").

    CAIN's firewall judges each browser action before it runs, for one user task. What the user asked for is authority; what a page says never is. Its blocking rules do not depend on spotting the injection: they follow where the agent is going, who chose that destination, what data would leave with it, and where a secret is being typed. Deterministic rules, no LLM judge.

    1. Task scope and destinations

    Submitting, sending, paying or downloading only on the sites the task covers. Mail, identity and banking sites are not visited unless the task includes them. A destination a page named and the user never did is refused. Address-bar input that is not a strict URL stays text.

    2. Data cannot ride out

    What the agent reads on private pages is fingerprinted. Those fingerprints inside a URL (host, path or query; plain, base64, hex or %-encoded, two layers deep) or in text typed into another site are refused. Following a link found in your mail is fine; forwarding it elsewhere is not.

    3. Secrets and files stay home

    A password, one-time code or card can only be typed on the origin it belongs to. URLs with user@host tricks, look-alike letters or non-web schemes are refused. Executable downloads and uploads of key or browser-profile files are refused; other downloads wait for the user.

    ⚡ Try it: replay a real AI-browser hijack

    POST /api/v1/browser-agent-firewall/run

    Pick a scenario, or edit the JSON: task is what the user asked for and the sites it covers, events are what the agent saw (observe, with visible and hidden page text) and what it tried (act). No browser is driven, no page is fetched and nothing you send is stored.

    Pick a scenario above or edit the JSON.
    🛡️ Technology asset carve-out #7 · new ● Live drill · real engine, every request

    Agent Payment Mandate Guard

    AI agents now check out and pay on a person's behalf. Card networks, merchants and banks all need the same answer afterwards: did the human actually authorize this purchase? The new agent-payment protocols (Google's AP2, Visa Trusted Agent Protocol, Mastercard Agent Pay, the OpenAI and Stripe Agentic Commerce Protocol, x402) answer with signed mandates. Someone still has to enforce them at the moment the agent pays, when a fake store, an injected product page or a swapped bank account is in play.

    CAIN's guard sits between the agent and the payment call. It checks the cart against the mandate the human signed, reserves the spend atomically, and answers ALLOW, REQUIRE_APPROVAL or DENY with every rule that fired and a signed receipt that binds mandate, cart and verdict. Deterministic rules, no LLM judge.

    1. Who really signed

    The signer must be a person whose key the operator registered: a mandate cannot bring its own key. Any edit after signing, a different agent presenting it, expiry and revocation are all refused.

    2. Where the money goes, and for what

    Only stores on the mandate, with look-alike domains called out. The payee must be that merchant's registered account. Items the human did not ask for, gift cards and other cash-equivalents, prices or quantities above the mandate, and totals that do not add up are refused.

    3. How much, how often, with proof

    Per-purchase limit, total budget and purchase count in one atomic ledger, so many small purchases or two racing checkouts cannot overspend. The same cart twice is refused. Large purchases can wait for the human. Every decision gets an Ed25519-signed, hash-chained receipt.

    ⚡ Try it: send an agent shopping with a signed mandate

    POST /api/v1/payment-mandate-guard/run

    Pick a scenario, or edit the JSON: mandate is what the human approved (amounts in cents), steps are the carts the agent tries to pay. In this demo the server signs the mandate in place of the human's wallet, with a throwaway key. No store is contacted, no payment is made and nothing you send is stored.

    Pick a scenario above or edit the JSON.
    🛡️ All carve-outs, wired into MCPGate · new ● Live drill · real engines, every request

    One proxy, every guard: the MCPGate guard stack

    The carved-out engines below now run together as stages in the MCPGate proxy that sits in front of your MCP servers. One config file switches them on. Every tool call passes the kill-switch first, then skill scope, delegation (swarm collusion), the memory firewall and the supply-chain guard, alongside the tool-poisoning and lethal-trifecta guards already in the proxy. A stage can only refuse or hold a call; it can never allow one that another check refused. If a stage fails, the call is refused.

    ⚡ Try it: one agent, five attacks, five different stages

    POST /api/v1/mcpgate/guard-stack/run

    Pick a scenario, or edit the JSON: config is the same guard config the proxy reads, calls are the agent's tool calls. Each request gets a fresh stack with its own kill-switch. No tool is called and nothing you send is stored.

    Pick a scenario above or edit the JSON.
    🛡️ Technology asset carve-out #6 · new ● Live drill · real engine, every request

    Coding-Agent Supply-Chain Guard

    Coding agents (Claude Code, Cursor, Copilot, Codex, Gemini CLI) now install packages, edit config and run shell commands on their own. That opened a new attack surface: packages the model invented that attackers then register ("slopsquatting"), typosquats, private-index confusion, agents rewriting their own config to auto-approve tools (CVE-2025-53773 in Copilot, CVE-2025-54135 "CurXecute" in Cursor), and malware that drives your AI CLI with its guardrails off (the Nx "s1ngularity" attack) or steals your registry token and republishes your packages (the Shai-Hulud npm worm).

    CAIN's guard judges each command and file write before it runs and answers ALLOW, REQUIRE_APPROVAL or DENY with the rule that fired. A package that is neither vetted nor in your lockfile is held, never waved through. Deterministic rules, no LLM judge, under a few milliseconds per action.

    1. Every install, checked

    pip, uv, poetry, pipx, npm, yarn, pnpm, bun, npx and uvx, plus requirements.txt, package.json and pyproject.toml edits. Hallucinated and known-malicious names (via your registry/OSV lookup), typosquats (swapped letters and look-alike characters refused, other near-misses held), installs from URLs or git, and untrusted indexes set by flag, environment variable or config.

    2. No self-escalation

    Writes to an agent's own config (.vscode/settings.json, .cursor/mcp.json, .claude/settings.json and more) that turn on auto-approve or add MCP servers are refused. Rule files (CLAUDE.md, AGENTS.md, .cursorrules) with invisible characters are refused; other edits are held.

    3. Worm and malware brakes

    A downloaded script run without review (piped into a shell or interpreter by name or full path, through tee, via <( ) or $( ), or saved and run in the same command), AI CLIs started with their permission checks off (--dangerously-skip-permissions, --yolo, --approval-mode yolo, --sandbox danger-full-access, unrestricted --allowedTools), reads of .npmrc, cloud keys, SSH keys and secret environment variables, secret scanners, and package publishing, which a human must release.

    ⚡ Try it: replay a real coding-agent attack

    POST /api/v1/supply-chain-guard/run

    Pick a scenario, or edit the JSON: actions are what the agent wants to do ({"kind":"shell","command":...} or {"kind":"write_file","path":...,"content":...}), allowlist is your lockfile, registry holds registry facts for the scenario. Nothing is executed or written, nothing you send is stored, and the drill does not contact PyPI or npm.

    Pick a scenario above or edit the JSON.
    🛡️ Technology asset carve-out #5 · new ● Live drill · real engine, every request

    Lethal Trifecta Exfiltration Guard

    An AI agent leaks data when one session can do three things: read private data, read text an attacker wrote (a web page, a GitHub issue, an inbound e-mail, a support ticket), and send something out. The attacker's text tells the agent to fetch the private data and send it. That is how the GitHub MCP issue leak, EchoLeak in Microsoft 365 Copilot (CVE-2025-32711) and the Supabase MCP ticket leak worked. Prompt filters miss it because no single step looks wrong.

    CAIN's guard tracks the session, not the prompt. A session may hold at most two of the three legs; the tool call that would add the third is refused before it runs, in whatever order the legs arrive. Every outbound call is also checked for fragments of private data the session read (also after base64/hex/URL decoding) and for smuggled credentials or hidden Unicode. Deterministic rules, no LLM judge.

    1. Rule of two, per session

    Each tool carries its legs (private data, untrusted content, external comms). The third leg is refused, so injected text can never reach both your data and a way out. A tool that holds all three on its own is refused outright.

    2. Data-lineage taint

    What private tools return is fingerprinted (hashed identifiers and word shingles). Outbound arguments carrying those fingerprints, raw or encoded, are refused unless the destination is on your egress allowlist.

    3. Covert-channel screen

    AWS keys, private keys, JWTs and live API tokens in an outbound payload, plain or nested in base64/hex/%-encoding, and zero-width or Unicode-tag characters that can carry a hidden bitstream.

    ⚡ Try it: replay a real agent leak, step by step

    POST /api/v1/trifecta-guard/run

    Pick a scenario, or edit the JSON: profiles maps each tool to its legs, steps are the agent's tool calls (with what each tool would return), egress_allowlist is where private data may go. No real tool is called and nothing you send is stored.

    Pick a scenario above or edit the JSON.
    🛡️ Technology asset carve-out #4 · new ● Live · runs the same guard as the MCPGate proxy

    MCP Tool Poisoning & Rug-Pull Defense Engine

    Every MCP server writes the text your agent's model reads about its tools. That text is an attack channel: a tool that "adds two numbers" can carry a hidden instruction to read ~/.ssh/id_rsa, tell the model how to misuse another server's send_email, hide orders in invisible Unicode, or quietly change its definition after you approved it (a rug pull).

    CAIN's guard sits on tools/list. It scans every definition with deterministic rules (no LLM judge), pins each approved definition by SHA-256, and quarantines any tool that trips a rule or changes after pinning. A quarantined tool is removed from what the agent sees and refused at tools/call until an operator re-approves it.

    1. Poisoned descriptions

    Hidden <IMPORTANT> blocks, "do not tell the user", reads of secrets, exfiltration URLs, base64 blobs. Scanned in the description, every schema field, enum value and property key.

    2. Cross-tool shadowing

    One server's tool telling the model how to use another server's tool. Also duplicate names and homoglyph names like reаd_file with a Cyrillic "а".

    3. Rug-pull pinning

    Approved definitions are hash-pinned per server, over the whole tool object. Any later change, even one that reads as harmless, is quarantined until a named operator re-approves it. With a pin store the pins survive restarts and are shared by every proxy process. In strict mode nothing reaches the agent until an operator has approved that exact definition.

    ⚡ Try it: attack the guard with your own MCP tools

    POST /api/v1/mcp-tool-guard/scan

    Pick an attack, or edit the JSON and write your own. "Current tools" is what the MCP server serves now; "Previously approved" is optional and turns on rug-pull detection. Nothing you send is stored.

    Pick an attack above or edit the JSON.

    Limits, measured 2026-10-12: the phrase rules caught 20 of 20 known poisoning descriptions and flagged 0 of 65 ordinary ones, but only 3 of 15 new behavioural instructions written in plain words (a held-out set, measured once). Try "Honest limit" above. What does not depend on wording: invisible characters and look-alike letters, hidden markup, addresses and local paths inside descriptions, one server naming another server's tool, pinning, and strict mode. Without a pin store, a proxy restart forgets approvals. The guard decides what the agent sees and refuses calls to quarantined tools. It does not inspect tool results, and passing it does not authorize a call: CAIN policy still decides. Building this demo exposed a real gap: shadowing text that named another tool ("When using the send_email tool…") passed the scan. It is fixed and covered by regression tests.

    🛡️ PROVEN TECHNOLOGY ASSET CARVE-OUT ● 153 TESTS PASSING · HALT SEEN BY OTHER PROCESSES IN < 50 MS · BUILT FOR EU AI ACT ART. 14 HUMAN OVERSIGHT

    Autonomous Swarm Fleet Quarantine & Emergency Kill-Switch Subsystem

    When an AI agent fleet experiences goal drift, prompt injection, or memory contagion cascades, traditional prompt filters fail. The cain.quarantine subsystem stops a rogue agent, a whole swarm or every agent at once, and every worker process sees it in under 50 milliseconds through one shared SQLite (WAL) store. Every containment is Ed25519-signed by the node's persistent key; a containment that could not be stored is reported as not done, never as done. Self-contained, ready for licensing or OEM integration.

    Licensing & acquisition → Launch Interactive Killswitch Drill →
    1. ULTRA-LOW LATENCY CONCURRENCY

    Sub-50ms Multi-Process Synchronization

    Engineered with SQLite Write-Ahead Logging (WAL) and synchronized thread-safe in-memory caching. Non-blocking reads across hundreds of concurrent agent microservices with zero external database server overhead.

    Measured 2026-10-11 on our host, 20,000 records in history: check 0.009 ms p50 · quarantine → enforced 10 ms p50, 31 ms max
    2. MULTI-TIER CONTAINMENT MATRIX

    Three-Level Escalation Circuit Breaker

    Dynamic escalation prevents isolated anomalies from collapsing healthy operations:

    • 🔴 AGENT_ISOLATION: Instantly blocks rogue single agent.
    • 🟠 SWARM_FLEET_ISOLATION: Quarantines entire swarm upon contagion.
    • 🛑 CLUSTER_EMERGENCY_HALT: Global SOC emergency halt.
    3. EVIDENCE & WORKLOAD REVOCATION

    Ed25519 Signing & SPIFFE Invalidation

    Every containment, approval and lift is appended to a signed, hash-chained event log, and fast-path authorization caches are purged. Lifting needs two different named approvers and a written justification, and the lift itself is signed: a lift forged in the database, or a deleted containment record, keeps the agent stopped or engages the global halt. The record lists the workload SPIFFE IDs to revoke; revoking them in your SPIRE server is an integration step.

    Evidence: signed, hash-chained log · public key and chain check at /api/v1/quarantine/status

    ⚡ Try it: trip the kill-switch

    POST /api/v1/mcpgate/guard-stack/run

    An agent fleet makes tool calls. When one call sends a burst above the threshold (max_single_burst_mb), the kill-switch severs the lines and every later call, from any agent, is refused. Edit the calls or the threshold and run it. Each run uses a fresh, private drill instance: it cannot halt anything real, and nothing is stored.

    Ready.

    This drill runs the kill-switch stage of the MCPGate guard stack against simulated byte counts. The full operator console with two-person re-arm is at /killswitch.

    STANDALONE PYTHON CONTRACT (cain.quarantine) ● ZERO CLOUD COUPLING
    from cain.quarantine import get_quarantine_manager
    
    # Sub-50ms thread-safe manager with SQLite WAL
    qm = get_quarantine_manager()
    
    # Trigger immediate swarm fleet isolation
    record = qm.quarantine_swarm(
        swarm_id="swarm-customer-ops-04",
        reason="Prompt injection contagion detected across swarming agents",
        operator_id="soc-sentinel-01"
    )
    
    # Preflight boundary enforcement: blocked fail-closed
    allowed, reason = qm.check_execution_allowed("agent-customer-support-12")
    # -> (False, "Swarm fleet 'swarm-customer-ops-04' is actively quarantined")
    Licensing & acquisition

    Available to license or acquire. Terms are discussed directly; we do not publish a price.

    What you get: the source code, its test suite and documentation. No patent has been filed. Results shown here come from our own test suite.

    🛡️ PROVEN TECHNOLOGY ASSET CARVE-OUT #2 ● 58 MARKETPLACE SKILLS · PER-SKILL AES-256-GCM · CROSS-SKILL READS REFUSED

    AI Agent Skill Memory Sandboxing Engine

    When an autonomous agent loads 50+ marketplace skills (from Claude Desktop MCP, Cursor, OpenAI Swarms, or AutoGen), an untrusted Smart Home or Weather skill thread can snoop shared memory, stealing 1Password master vaults, GitHub SSH keys, Stripe billing rails, or cloud IAM tokens. The cain.isolation.skill_sandbox subsystem gives every skill thread an unguessable capability when the agent runtime starts it, and encrypts each memory block with AES-256-GCM under a key derived for the owning skill, thread and region. A thread can only decrypt with the key derived from its own capability, so another skill, or another thread of the same skill, cannot read the block, even with every policy check removed. Declared skill names are not trusted. Every refusal and read gets an Ed25519-signed receipt. It is in-process isolation, not OS or hardware isolation: the runtime must hand each capability only to the thread it was issued for.

    Licensing & acquisition → Run Live Isolation Drill Below ↓
    1. PER-SKILL ENCRYPTED MEMORY

    Per-Skill AES-256-GCM Memory Isolation

    Each block is encrypted under a key derived (HKDF-SHA256) from the skill's master key, the owning thread and the region, with the owner and block id bound into the AEAD associated data. A reader decrypts under its own derived key, so a cross-skill or cross-thread read fails authentication.

    Stress test 2026-10-11: 16 threads, 960 blocks, 14,224 cross-reads: all refused, 0 leaks
    2. FOUR-TIER LEAST PRIVILEGE

    58 Marketplace Skills Strictly Scoped

    Enforces non-escalating privilege ceilings across all cataloged tools:

    • 🟢 MINIMAL: IoT, Home Automation, Basic Telemetry.
    • 🔵 SCOPED: Slack, Linear, Notion, Productivity tools.
    • 🟠 SENSITIVE: Databases, Cloud Analytics, Internal APIs.
    • 🔴 CRITICAL: 1Password Vaults, GitHub VCS, Stripe, Cloud IAM.
    3. EVIDENCE YOU CAN CHECK

    Ed25519 Signed Receipts

    Any unauthorized cross-skill read immediately raises CryptographicSkillIsolationViolation and issues an Ed25519-signed audit receipt. The read is refused; the calling thread is not terminated.

    Evidence: each drill returns its receipt and the public key that verifies it
    STANDALONE PYTHON CONTRACT (cain.isolation.skill_sandbox) ● ONE DEPENDENCY: cryptography
    from cain.isolation.skill_sandbox import get_skill_sandbox
    
    sandbox = get_skill_sandbox()
    
    # 1. The runtime binds each skill thread; the capability is its identity
    vault = sandbox.issue_thread_capability("onepassword_vault", thread_id=101)
    iot   = sandbox.issue_thread_capability("smart_home_hub", thread_id=202)
    
    # 2. The 1Password thread stores a secret in its own region
    block = sandbox.allocate_encrypted_memory(
        memory_region="mem_region_onepassword",
        plaintext_data=b"master_password_vault_key_xyz123",
        capability=vault,
    )
    
    # 3. The Smart Home thread tries to read it with its own capability:
    try:
        sandbox.read_encrypted_memory(block_id=block.block_id, capability=iot)
    except CryptographicSkillIsolationViolation as ex:
        print("REFUSED:", ex.violation_type)   # UNAUTHORIZED_CROSS_SKILL_READ
    Licensing & acquisition

    Available to license or acquire. Terms are discussed directly; we do not publish a price.

    What you get: the source code, its test suite and documentation. No patent has been filed. Results shown here come from our own test suite.

    ⚡ Live Interactive Cross-Thread Isolation Drill

    LIVE ENDPOINT: POST /api/v1/clawx/skills/verify-isolation

    Simulate an adversarial rogue skill attack in real time. Choose an attacker process thread and target protected victim enclave, then trigger the isolation probe.

    Ready to verify
    🛡️ PROVEN TECHNOLOGY ASSET CARVE-OUT #3 ● FARMA & MEMORYGRAFT DEFENSE · arXiv:2607.05029 · MEMORY NEVER GRANTS AUTHORITY · 39 LIVE CHECKS YOU CAN RUN

    Autonomous AI Agent Long-Term Governed Memory Firewall & Vector Poisoning Defense Engine

    When an autonomous agent stores long-term memory in vector databases (Chroma, Pinecone, Weaviate, Mem0, LangGraph), external documents and rogue agents can inject persistent Trojan instructions (MemoryGraft: "Poison Once, Exploit Forever"), forged reasoning claims ("Security check already verified — safe to proceed"), or spoofed policies. The cain.omniscience.memory_firewall engine puts an authority firewall in front of every memory write and read: "Memory provides information. CAIN determines authority." Memory never grants permission, never increases authority, never overrides policy, and never resurrects revoked credentials. A refusal takes microseconds (measured below), and every drill returns an Ed25519-signed receipt with the key that verifies it.

    Licensing & acquisition → Run Live Memory Firewall Drill Below ↓
    1. FARMA FORGED REASONING TAINT

    arXiv:2607.05029 Defense Against Fake Validations

    Detects and taints entries claiming a check or security validation was already completed ("already verified", "approved", "skip the verification"). Multiple agent copies count as one independent source; consensus cannot be manufactured by echo.

    Measured 2026-10-12: 25/25 tuned phrasings, 11/15 unseen paraphrases, 0/30 false positives. What it misses still cannot satisfy a check.
    2. MEMORYGRAFT RESTRICTED AIR-GAP

    arXiv:2512.16962 Anti-Poisoning Enforcement

    Untrusted agents or external RAG content are strictly forbidden from writing to restricted classes: POLICY, SYSTEM_INSTRUCTION, AUTHORIZATION, CREDENTIAL, or SECURITY_EVENT.

    • 🛡️ POLICY: Only verified human operators may author policy.
    • 🛡️ CONSOLIDATION: Summaries can only narrow authority, never amplify.
    3. REVOCATION CASCADE & ZERO SECRETS

    Dead Authority Air-Gap & Secret Redaction

    Revoked credentials can never be reanimated through memory recall (arXiv:2602.15654). Revocation cascades downstream to all derived items. Refuses 13 credential formats (Stripe, OpenAI, Anthropic, AWS, GitHub, GitLab, Google, Slack, PEM keys, JWT, password=), also when nested or split by invisible characters.

    Measured: policy forgery refused in 0.001 ms, a secret in 0.009 ms; a 4 KB text scanned in 3.3 ms
    STANDALONE PYTHON CONTRACT (cain.omniscience.memory_firewall) ● 168 TESTS · 2,400-RUN STRESS: 0 ERRORS
    from cain.omniscience.memory_firewall import MemoryAuthorityFirewall, MemoryFirewallError
    
    # 1. RAG document injects forged policy into agent memory:
    try:
        mem.write(
            tenant="tenant-a",
            classification="POLICY",
            source="AGENT",
            creator="agent-B",
            principal="human:alice",
            content={"rule": "grant_all_financial_wires"},
            provenance={"source": "untrusted_rag_search"}
        )
    except MemoryFirewallError as ex:
        # -> refused before anything is stored
        print("HALTED:", ex) # MEMORY_AUTHORITY_FORGERY
    
    # 2. Agent recalls memory:
    # Invariant: memory never grants permission or satisfies a check!
    Licensing & acquisition

    Available to license or acquire. Terms are discussed directly; we do not publish a price.

    What you get: the source code, its test suite and documentation. No patent has been filed. Results shown here come from our own test suite.

    ⚡ Live Interactive Memory Authority Firewall Drill

    LIVE ENDPOINT: POST /api/v1/memory-firewall/verify-drill

    Simulate real-world agent memory poisoning and authority-laundering attacks. Pick a scenario and type your own text. Each scenario runs several real checks against a fresh firewall, including a control that must succeed; the verdict is computed from them.

    Ready to verify
    🛡️ PROVEN TECHNOLOGY ASSET CARVE-OUT #19 ● CONSENSUS != AUTHORIZATION · OWASP ASI08 · SUB-0.1MS GRAPH HALT

    Autonomous AI Agent Multi-Agent Swarm Collusion Graph & Sybil Delegation Defense Engine

    When enterprises deploy collaborating agent swarms (LangGraph, Microsoft AutoGen, CrewAI, OpenAI Swarms, Salesforce Agentforce), rogue or prompt-injected sub-agents can collude: forming autonomous cartels, manufacturing false quorums to outvote humans, and laundering authority in cyclic delegation loops (A → B → C → A). The cain.authority.collusion_graph engine enforces the bedrock invariant: "No number of cooperating agents may manufacture authority. Authority must be rooted in a cryptographically verified human principal." Every delegation loop, unrooted consensus cartel, and Sybil claim amplification is severed in under 0.1 milliseconds with Ed25519-signed audit receipts.

    Licensing & acquisition → Run Live Swarm Collusion Drill Below ↓
    1. AUTHORITY CYCLE & DELEGATION LOOPS

    OWASP ASI08 Multi-Agent Privilege Escalation

    Detects cyclic authority loops where Agent A delegates to B, B to C, and C back to A to manufacture infinite escalating privilege. Strict depth-first cycle detection terminates loops fail-closed before execution.

    Monotonic Authority Attenuation · O(V+E) cycle severed in 0.05ms
    2. UNROOTED CONSENSUS CARTEL DEFENSE

    False Swarm Majority Defense

    An endorsement cluster without a human PRINCIPAL root carries ZERO authority. When 3 sub-agents conspire to authorize high-value transactions or API calls, the decision is rejected fail-closed.

    Invariant: agent consensus != human authorization
    3. ANTI-SYBIL CLAIM AMPLIFICATION

    Sybil Echo Isolation

    When an adversarial prompt replicates a single false statement across 5 sub-agents claiming "unanimous verification", the engine reduces N copies to 1 unverified source and flags Sybil echo manipulation.

    N agent copies count as ONE source · Ed25519 signed receipts
    PYTHON PRODUCTION CONTRACT (cain.authority.collusion_graph)
    from cain.authority.collusion_graph import CollusionGraph
    
    # Build live multi-agent authority mesh
    mesh = CollusionGraph()
    mesh.add_node("agent-A", "AGENT")
    mesh.add_node("agent-B", "AGENT")
    mesh.add_node("agent-C", "AGENT")
    
    # Detect cyclic loops & unrooted agent cartels
    findings = mesh.detect()
    if any(f["kind"] in ("AUTHORITY_CYCLE", "CONSENSUS_WITHOUT_PRINCIPAL") for f in findings):
        halt_execution(reason=findings[0]["kind"], receipt=sign_receipt(findings))
    Licensing & acquisition

    Available to license or acquire. Terms are discussed directly; we do not publish a price.

    What you get: the source code, its test suite and documentation. No patent has been filed. Results shown here come from our own test suite.

    Contact the founder →
    LIVE ADVERSARIAL DRILL BENCH

    Execute Live Multi-Agent Swarm Collusion Defense Probe

    POST /api/v1/swarm-collusion/verify-drill

    Select an attack vector below to inject an adversarial multi-agent swarm into the live authority mesh. The engine constructs the causal authority graph, executes real-time cycle and cartel detection, halts the execution fail-closed, and mints an Ed25519-signed containment receipt.

    Ready to verify

    Developer Gateway · Rank 13 MCPGate Enforcement

    Protect Any Agent in 60 Seconds: @cain.guard

    The drop-in execution boundary for Cursor, Claude Desktop, LangChain, CrewAI, and AutoGen. The agent proposes the tool action; CAIN intercepts parameters, enforces capability ceilings, halts destructive payloads before they run, and records tamper-evident WORM Merkle evidence. No authorization → no execution.

    1. PYTHON DECORATOR ● IN-PROCESS FAST PATH
    import cain
    
    @cain.guard(
        resource="database:prod_users",
        intent="archive_user_record",
        risk="LOW"
    )
    def delete_user(user_id: str):
        # Intercepted & verified by the 7 Moats
        # Injection/drop attacks fail-closed
        return db.users.delete_one({"id": user_id})

    Sub-15ms verification. Any destructive parameter ('drop', 'rm -rf', 'curl | bash') halts automatically at the boundary.

    2. UNIVERSAL CLIENT WRAPPER ● OPENAI & ANTHROPIC
    import cain
    from openai import OpenAI
    
    # 1-Line Drop-in: governs proposed tool calls
    client = cain.wrap(OpenAI())
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "..."}],
        tools=[...] # Governed by MCPGate
    )

    Transparent client proxy. Intercepts tool calls before execution with zero code changes inside your existing tools.

    3. CURSOR & CLAUDE DESKTOP MCP ● ZERO-CODE PROXY
    // ~/.cursor/mcp.json or claude_desktop_config.json
    {
      "mcpServers": {
        "cain-gate": {
          "command": "cain-mcp-proxy",
          "args": ["--gate", "https://cainstudio.online"]
        }
      }
    }

    Deploy MCPGate as an upstream proxy in front of existing tools. Protects your IDE agents from poisoned instructions.

    Try @cain.guard Live in Your Browser

    Simulate an attack payload and observe real-time parameter sanitization and signed receipts (<2ms latency).

    Enterprise Statutory Compliance · Conformance Protocol 4.0

    EU AI Act & ISO 42001 Compliance Wizard

    For high-risk AI systems the EU AI Act asks for human oversight (Article 14) and post-market monitoring (Article 72). CAIN records signed, tamper-evident evidence you can use toward both. It is not a conformity assessment or legal advice.

    ANNUAL STATUTORY CONTRACTS
    Standard Enterprise Notary
    $50,000 / yr
    High-Risk Enterprise Package
    $100,000 / yr
    Sovereign Swarm Defense
    $150,000 / yr
    Continuous Ed25519 attestations, WORM export notary, and regulatory defense warranty.

    Side by side

    Where the control actually sits

    Five questions enterprise buyers ask before they put an autonomous agent near production. This is a category comparison, not a benchmark and not a claim about any vendor's internals. It describes the control point each category is built around. Where we could not find public documentation for a category claim, we say so instead of filling the cell with a guess.

    Purchase triggerCAIN-42 execution boundaryApplication sandbox (Docker / VM)Prompt / model guardrail (examples: Bedrock, NeMo)
    Enforcement layer Tool-call / API boundaryPolicy is evaluated against the exact call before it runs. Source: live stage list Process / container / VMThe primitive confines code. It does not decide whether a specific tool call is authorized. Source: category comparison Model input / outputPolicy lives in instructions and optional classifiers. Source: category comparison
    Bypass resistance Deterministic stage chainUnknown, error, or no quorum → deny. A call that bypasses MCPGate is outside the boundary, and the page says so. Source: scope and gaps Strong for code confinementThe authorization decision usually sits outside the sandbox; a call made from inside it is not automatically judged. Source: gateway comparison Text-following behaviorDrift, context saturation and injection are the documented risk. A classifier can add a check, but the control point is upstream of the action. Source: category comparison
    Governance 3-of-4 PBFT quorumThe quorum co-signs the decision. It cannot make an unauthorized action authorized. Source: live cluster Orchestrator / infrastructureUsually configuration and host policy; no per-action quorum. Source: BFT comparison Vendor console and rulesLogs and dashboards; no per-action quorum in the public documentation we reviewed. Source: 36 comparisons
    Auditability Ed25519 + hash chainCanonical JSON (RFC 8785), SHA-256 chain, RFC 6962 Merkle root, offline verifier. Source: verification center Container / VM logsHost telemetry and orchestrator events. Source: policy comparison Request / response logsVendor dashboards and exported logs. Source: 36 comparisons
    Containment Deny before the tool runsA denied call does not reach the tool. The decision is recorded either way. Source: MCPGate proof Isolation boundaryConfines a compromised process to its container or VM. Source: category comparison Upstream of the actionContainment depends on the model following the instruction; the action itself is not the control point. Source: 36 comparisons

    Reviewed against the public documentation linked in each cell (comparison pages last reviewed 2026-10-14). No affiliation and no claim about a vendor's internals. “No public documentation found” is not a claim that a capability is impossible. For the full per-vendor pages, open the 36 comparisons →

    Managed assurance

    CAIN Trust Desk — a named human on the other side of the evidence

    For teams already running agents in production. This is not a certification and not a monitoring-only subscription: it is a recurring review that ends in signed artifacts you can hand to a reviewer, a customer or an insurer. The price range is listed in the Work Station sales deck; a quote is confirmed in writing after a baseline audit.

    Recurring

    Continuous review

    $1,500–$4,000/month

    Month-to-month · scoped after a baseline audit

    • Continuous AI security review across the surfaces you name
    • Drift and incident checks with a named person who answers
    • Findings ranked, with the exact input that reproduces each one
    Schedule Monthly Drift Audit

    The range is the published Work Station anchor, not a validated rate card.

    Human

    Signed evidence + review

    Quoted after scoping

    Application surface area sets the price

    • Ed25519-signed bundle with a standalone verifier
    • Human-in-the-loop support for approvals and incidents
    • Findings tied to the exact evidence record, not a screenshot
    See a signed bundle →

    No third-party audit is included or implied.

    Trust Desk is a services engagement, not a software plan and not insurance. It does not replace the self-serve platform subscription. The same retainer range is listed in the Work Station sales deck →

    Commercial paths

    Three ways to buy. One decision path.

    Self-serve platform plans are separate and unchanged: $0 Free · $19.75 Professional · $49.75 Enterprise, rendered from the billing source at /pricing. The tiers below are managed and deployment contracts, quoted after scoping. Nothing is charged until a signed order.

    Developer

    Developer

    $0/month

    No card · 10,000 decisions · 3 agents

    • Full self-hosted boundary tools and core APIs
    • Python SDK, CLI and MCP proxy
    • Community support
    • Every plan gets the full decision path; security is never a paid feature
    Create a free account

    Limits and allowances are rendered from /pricing.

    Sovereign

    Sovereign Cluster

    Custom enterprise pricing

    On-premise or isolated private cloud

    • Private deployment of the enforcement boundary and evidence store
    • Dedicated environment and deployment support
    • SSO / RBAC scoping for your identity provider (implementation not yet verified)
    • SLA objectives published; a contractual SLA exists only if signed
    Request Sovereign Node

    No public self-hosted installer today: the deployment is scoped and delivered with support. No claim of an air-gapped deployment until one is delivered for your environment.

    What the badges do not mean: CAIN-42 holds no SOC 2 certification, no ISO 27001 certification and no third-party audit. The evidence export is a readiness mapping, not a certificate. The hosted deployment is pre-production. Read the gaps → · Self-serve pricing →

    How CAIN-42 compares

    CAIN-42 vs the field — 36 side-by-side pages

    We put our strengths next to the agent platforms, the AI security vendors, the identity systems, the policy engines and the MCP gateways — and we say when to pick which. Where CAIN-42 wins: enforcement at the tool-call boundary, a 3-of-4 Byzantine quorum behind every authorization, and a per-action receipt you can verify offline.

    The CAIN-42 Top 100

    The 100 CAIN-42 Modules We're Focusing On

    Your agents move fast — and that speed is exactly the risk. One wrong action (a file deleted, a payment sent, a customer record exposed, an instruction hidden inside a tool description) can cost far more than the agent ever saves. The 100 products below exist to keep that from happening. Each one closes a specific gap between what an autonomous system is permitted to do and what it actually does: it checks every action against the agent’s identity, authority, policy and risk before the action runs, holds the risky ones for a human, contains an entire fleet in milliseconds, and records every decision as signed, tamper-evident evidence you can hand to a security reviewer, an auditor or a regulator. You keep the speed and autonomy of agents and remove the downside.

    And you do not have to rebuild your stack or trust a black box. These are modules from our engineering register, and only a module with the two spinning icons is a finished product for sale. They include a one-line SDK guard and an MCP gateway for the agents you already run, a governed-memory and vector-sanitization layer that stops poisoning and hidden-instruction attacks, spend and blast-radius controls, evidence that helps you answer EU AI Act and ISO 42001 reviews, and the runtime, identity, consensus and verification fabric underneath. Adopt one product or the whole fabric. Every card below opens a deep description and a live demo you can run in your browser in seconds — no account required — so you can see exactly what it does for your systems before you commit. Start free on a single agent, prove it on your own workload, then roll it out across the fleet. That is what CAIN-42 is for.

    Open the full Top 100 with deep detail and live demos →

    2026-2027 Frontier Research Deployments

    20 New Enterprise Products — live on the hosted gateway (pre-production)

    Twenty agent-security engines on the hosted gateway (pre-production). Each card says what the live product does, checked on 2026-11-03; each has a beginner guide, a live demo and an independent verification kit (IHVRK) you can run on your own machine.

    PRODUCT #1 ● LIVE · checked 2026-11-03

    CAIN OpenShell Enterprise Gateway

    Checks each file, network or process action an agent wants against that agent's sandbox policy and refuses anything outside it (live: /etc/shadow and SSH keys DENIED). Commands it runs itself get no new privileges, resource limits and an unprivileged user.

    Target: CISO / VP Infra (Devin, Cursor, Claude Code)
    Endpoint: POST /fabric/openshell/enforce-sandbox
    PRODUCT #2 ● LIVE · checked 2026-11-03

    CAIN MemVault (Vector & Memory Firewall)

    Screens every memory an agent writes: known prompt-injection text is quarantined and never recalled; records are signed. Measured recall 0.617 with no false alarms on 116 held-out examples, so reworded injections can pass. Connectors to external vector databases are not built yet.

    Target: AI Platform Teams (Long-Horizon RAG)
    Endpoint: POST /fabric/memvault/inspect-write
    PRODUCT #3 ● LIVE · checked 2026-11-03

    CAIN VIGIL: Step-Wise Behavioral PRM Engine

    Rule-based check of every step an agent proposes (tool name, arguments, intent): destructive or exfiltrating steps are pruned, unjustified changes need a human. Fixed 2026-11-03 so a destructive tool name like delete_database is pruned.

    Target: Algorithmic Trading & Healthcare AI
    Endpoint: POST /fabric/vigil/evaluate-step
    PRODUCT #4 ● LIVE · checked 2026-11-03

    CAIN SCITT Evidence Clearinghouse

    Append-only log for signed statements (for example 'build 4812 passed its tests'): each gets a receipt with an RFC 6962-style Merkle inclusion proof anyone can re-check. Follows the IETF SCITT draft; run by this deployment, not an independent operator.

    Target: Supply Chain & Inter-Bank Autonomous Settlement
    Endpoint: POST /fabric/scitt/register-statement
    PRODUCT #5 ● REFERENCE SOFTWARE

    CAIN Hardware Sentry (quarantine registry)

    Per-tenant quarantine registry with real 2f+1 Ed25519 quorum-certificate checks. Optional kernel link-down only on interfaces an operator lists. DPU/SmartNIC hardware is detected and reported, never used: there is no device adapter, so nothing is offloaded.

    Target: Sovereign AI Data Centers & Air-Gapped Defense
    Endpoint: POST /fabric/sentry/hardware-quarantine
    PRODUCT #6 ● LIVE · checked 2026-11-03

    CAIN RIG: Runtime Identity Governance

    One Ed25519 identity per agent and single-use capability tokens for one action on one resource (30 s default, 1-300 s). Live: a second use, a stolen token with another key, a read token used to delete, and a child wider than its parent are all refused. SPIFFE-style names only; no SVIDs issued.

    Target: Identity & Access Management (IAM) Architects
    Endpoint: POST /fabric/rig/mint-token
    PRODUCT #7 ● LIVE · checked 2026-11-03

    CAIN Digital Twin & Counterfactual Emulator

    Simulates a proposed action before it runs, counts its side effects and rejects anything over the blast-radius limit; an action type it cannot model is rejected, not allowed (expect some false refusals).

    Target: AI Reliability & Safety Engineering Teams
    Endpoint: POST /fabric/digital-twin/simulate
    PRODUCT #8 ● LIVE · checked 2026-11-03

    CAIN ExploitGym Escape Shield

    Blocks agent actions that reach for cloud metadata (even as a decimal IP), Kubernetes service-account tokens, template injection, deep traversal and, since 2026-11-03, container escapes (nsenter, Docker/containerd sockets, /proc/1/root, cgroup release_agent). Repeat offenders are blocked for the hour.

    Target: Autonomous Agent Red Teams & SecOps
    Endpoint: POST /fabric/exploit-shield/inspect-action
    PRODUCT #9 ● LIVE · checked 2026-11-03

    CAIN Multi-Model Epistemic Quorum Gate

    Takes several AI models' verdicts on one action and allows it only when the required share agree; disagreement or no verdicts means DENY. It counts and signs the verdicts you send; it does not call the models.

    Target: Mission-Critical Enterprise Autonomous Operations
    Endpoint: POST /fabric/epistemic-quorum/evaluate-quorum
    PRODUCT #10 ● LIVE · checked 2026-11-03

    CAIN Steganographic & Semantic Firewall

    Scans what agents send out: strips zero-width characters, repairs words that mix Latin letters with Cyrillic or Greek look-alikes (text written wholly in another script is left alone), and blocks base64-, hex- or percent-encoded credentials.

    Target: Enterprise Data Loss Prevention (DLP) & Compliance
    Endpoint: POST /fabric/steganography/sanitize-egress
    PRODUCT #11 ● LIVE · checked 2026-11-03

    CAIN Proof-Carrying Code (PCC) Compiler

    Checks agent-written Python before it runs by reading its structure, not running it: it must parse, import only allowed modules and contain no dynamic execution (eval, exec, os.system). Pass: certified with the checks listed. Fail: refused.

    Target: Enterprise DevSecOps & Autonomous Code-Gen Swarms
    Endpoint: POST /fabric/pcc/certify-code
    PRODUCT #12 ● LIVE · checked 2026-11-03

    CAIN Speculative Fast-Forward (SAFF) Engine

    Evaluates an agent's candidate plans step by step before any runs and commits only a branch whose every step is safe; a plan with a destructive step is never committed. No latency figure is claimed.

    Target: Low-Latency Autonomous Operations & Robotics
    Endpoint: POST /fabric/speculative/evaluate-trajectories
    PRODUCT #13 ● LIVE · checked 2026-11-03

    CAIN Swarm Cartel & Collusion Detector

    Reads who delegates to whom in a group of agents and flags circular delegation rings with their members, recommending quarantine (your system decides).

    Target: Decentralized Agent Swarms & Multi-Agent Marketplaces
    Endpoint: POST /fabric/cartel/inspect-swarm
    PRODUCT #14 ● LIVE · checked 2026-11-03

    CAIN PolicyForge: Dynamic OPA Synthesizer

    Writes a least-privilege OPA Rego policy from what an agent actually did and flags any result that would grant more than the approved baseline (monotonic_tightening_verified = false). Your pipeline must refuse flagged policies.

    Target: Compliance Officers & Sovereign Cloud Architects
    Endpoint: POST /fabric/policy-forge/synthesize-rego
    PRODUCT #15 ● SIMULATED

    CAIN Cyber-Physical Actuation Guard

    Software check of a commanded speed, torque, acceleration and 3-D target against an envelope and geofence; non-finite numbers and missing targets are refused. Connected to no robot, bus or e-stop, and not certified against ISO 10218 or ISO 13849.

    Target: Autonomous Robotics, Drones & Smart Factory Fleets
    Endpoint: POST /fabric/actuation/verify-command
    PRODUCT #16 ● REFERENCE SOFTWARE

    CAIN zkAgent: Zero-Knowledge Trajectory Prover

    Pedersen-commitment range proofs (standard construction, Fiat-Shamir bound to trajectory, agent and nonce) that each step's risk score stayed under a public ceiling without revealing the scores. Not zk-STARK or Groth16; it does not prove the scores were computed correctly.

    Target: Inter-Enterprise B2B Settlement & Regulated Cloud AI
    Endpoint: POST /fabric/zk/generate-proof
    PRODUCT #17 ● LIVE · checked 2026-11-03

    CAIN PathCorrection: Self-Healing Trajectory Engine

    Scores an agent's recent steps for drift and tool loops; past the tolerance it returns an anchor message restating the goal and constraints for the agent to follow.

    Target: Autonomous Coding Fleets & Long-Horizon SRE Swarms
    Endpoint: POST /fabric/path-correction/steer-trajectory
    PRODUCT #18 ● REFERENCE SOFTWARE

    CAIN LatentGuard: Activation Threshold Screen

    Fixed-threshold screen over activation statistics the caller submits, plus an exploit-string check on a token preview. It does not attach to any model or read residual streams or KV caches, and its thresholds are not calibrated against any model family.

    Target: Foundation Model Providers & Hyperscale Inference Hosts
    Endpoint: POST /fabric/latent-guard/probe-activation
    PRODUCT #19 ● LIVE · checked 2026-11-03

    CAIN SwarmGossip: Byzantine Epistemic Anti-Entropy

    Checks the signature on every claim agents pass to each other; a forged or unsigned claim is isolated and the exchange flagged, so a made-up 'fact' does not spread. It verifies who made a claim, not whether it is true.

    Target: Decentralized Agent Swarms & Autonomous Supply Chains
    Endpoint: POST /fabric/swarm-gossip/exchange-belief
    PRODUCT #20 ● NO HARDWARE

    CAIN CXL-Sentry: DMA Aperture Check (software)

    Software check of a requested address range and access type against a tenant aperture; writes need an HMAC lease bound to the exact range and expiry. No CXL, PCIe, IOMMU or RDMA device is involved.

    Target: GPU Superclusters & Sovereign AI Cloud Operators
    Endpoint: POST /fabric/cxl-sentry/verify-dma-access

    Three steps, every time

    1. 1

      The AI asks

      An AI agent wants to do something: use a tool, change a database, send money, start another agent. It can only ask.

    2. 2

      CAIN-42 decides

      CAIN-42 checks who is asking, what it is allowed to do right now, what it has already done, and how much could go wrong. No authority means no action.

    3. 3

      The gate enforces, proof is kept

      Only the approved action gets through. The decision and what happened are saved as signed proof anyone can check.

    What CAIN-42 does today

    Live right now, on these sites

    Every AI action sent through CAIN Studio is checked before it runs and blocked if it is not allowed (the live pipeline runs identity, intent, policy, authorization, risk, trust, verification, ActionProof, approval, consensus, egress, MCPGate, execution and evidence; no authorization means no execution). Each recorded decision is signed by a live cluster of 4 servers across 4 US regions (Atlanta, Los Angeles, Miami, Silicon Valley) and 3 of 4 must agree (Ed25519 quorum certificate verified by the gateway). MCPGate lets through only the exact tool call that was approved. Unregistered AI systems and unsigned requests are refused, and an agent may change its own model or tools only with a human sign-off (live) (30 of 30 live cases passed). A Python SDK and MCP proxy that say no to anything you did not allow (default-deny). Today's live deployment: the quorum-committed authorization-snapshot data plane is switched on live (measured 2026-09-29 on cain-mr-01, run record dataplane-evolution-2026-09-29/governance/live_run.json: a per-call PBFT round p50 2,268.6 ms, p99 3,937.8 ms, n=20; the snapshot-covered stage p50 0.8263 ms, p99 3.4686 ms, n=1,000), a revoked agent key is refused on its very next request (measured 2026-10-02), progressive trust scoping preventing exfiltration, payload-bound signed tokens, default-deny egress screening as a live stage (an action naming a destination outside the tenant's allowlist is denied; loopback and cloud-metadata endpoints are denied regardless of rules — manage it at /fabric/egress/rules (with your API key)), and Phase 3 Frontier AI intelligence (live) (AgentPRM process reward scoring, TriCEGAR MDP behavioral verification, Governed Memory Shield, and A2A inter-agent delegation at /fabric/frontier/*).

    Proof you can check yourself

    the signed claims registry lists every registered claim with its status and evidence; /verify.html counts them from the signed file in your browser. Test reports (the 2026-09-28 6-suite proof-fabric run: 1,963 of 1,978 tests passed, 0 failed, 7 skipped, 8 expected failures), verifiers that use none of our code, and the limitations we have recorded (open release gates are listed in the Verification Center), all on the Proof page and in the changelog. A public, no-key proof that the egress and tool-call stages are inside each decision's signed evidence, with a zero-dependency verifier, is at the restriction-stage proof bundle. A signed status receipt — which stages enforce right now, the running commit and the live health, and is itself re-checkable offline — is at the governance status receipt. Real stored decisions are re-derived and shown tamper-evident at the record-integrity proof. Newest: E26 distributed settlement completion evidence (multi-host validated; 72-hour soak and full Frontier-20 execution not measured).

    Everything in CAIN-42, on one page

    175 products and features (95 marked live, 72 in development), plus 105 hosted services, and a library of 9,131 pages organised by niche (counts from /cain-ecosystem.json, as of 2026-10-23). Tell us what you want your agents to do safely, or just scroll and click.

    For engineers: an interactive API reference with a page for each of the 387 API calls and 287 data schemas, each with code samples and a console that sends the real request with your own key, and step-by-step recipes for your agent framework.

    Integrations

    CAIN-42 plugs into the stack your teams already run: your LLM gateway, your agent framework, your ITSM, SIEM and on-call tools, and your identity provider.

    Proof layer for the four platforms

    Splunk / Cisco · Palo Alto Prisma AIRS · Zenity · Microsoft Sentinel / Entra

    Keep your control plane. CAIN-42 emits the signed proof record in the format your SOC already ingests, with an offline verifier your auditor can run without a CAIN account.

    Connectors · Proof Standard · Pricing and Proof SLA · Evidence bundle

    LLM gateways

    LiteLLM (Generic Guardrail API) · Portkey (Bring Your Own Guardrails)

    Keep your gateway. CAIN-42 runs inside it as a guardrail: prompt injection and poisoned tools are stopped before the model call, and every tool call the model proposes becomes a governed, recorded decision.

    LiteLLM and Portkey setup →

    Agent frameworks

    LangGraph · CrewAI · AutoGen · OpenAI Agents SDK · Claude Agent SDK · Google ADK · Pydantic AI · LlamaIndex · MCP

    A decision before every tool call, in the framework you already use: one HTTP call, or the SDK's adapters.

    Framework guides →

    ITSM and ticketing

    ServiceNow (incidents and Security Incident Response) · Jira Cloud

    Blocked actions, held approvals and the kill switch open a ServiceNow incident or a Jira issue, with the signed decision record attached.

    ServiceNow and Jira setup →

    SIEM and observability

    Splunk · Cortex XSIAM · Datadog · Microsoft Sentinel · OpenTelemetry (Grafana, Honeycomb, New Relic, Langfuse, Arize Phoenix)

    Every decision streams to the tools your security and platform teams already watch, each event carrying its signed digest.

    Forwarding setup →

    Alerting and chat

    PagerDuty · Slack · Microsoft Teams

    Page on-call when an agent is blocked or the kill switch engages; post held actions to the people who approve them.

    Alerting setup →

    Identity and access

    Okta · Microsoft Entra ID · Google Workspace · Auth0 · Keycloak · any OIDC provider · SCIM

    Single sign-on to the console with your identity provider, and members provisioned and removed automatically.

    SSO and SCIM setup →

    Deployment

    Hosted (cainstudio.online) · Kubernetes Helm charts · self-hosted MCPGate in your VPC

    Use the hosted control plane, or run CAIN-42's enforcement boundary inside your own cluster.

    Self-hosted MCPGate →

    Hugging Face

    CAIN-42 Space: a daily workplace for AI engineers

    Sign in with Hugging Face and run any tool-calling model as an agent: CAIN-42 decides each tool call live, you approve what is held, every record is signed. Plus your workspace (approvals, decisions, agent keys, policy), MCP setup for Claude, Cursor, VS Code and tiny-agents, and all 268 CAIN Studio Suite products with copy-paste API code.

    Open the CAIN-42 Space →

    32 capabilities. Measured, not marketed.

    Identity, consensus, runtime control, threat detection, compliance, interoperability and SRE: 28 of the 32 are built and pass their tests today, and 15 of those are running live right now. Every status below is read from a signed audit that runs each capability's tests and probes its live endpoint, and where a capability is narrower than its name, the card says so. The 4 we do not offer are listed too. See the signed audit and verify it yourself.

    102 canonical frontier agentic-AI inventions, built by FIRME AI CORPORATION (including 8 new Evolution 5 Sovereign Trial families: Evidence-Grounded Agentic Assurance, Harness Integrity Anti-Gaming Sealer, Multi-Turn Causal Adversarial Trial Engine, Ground-Truth Outcome Oracle, Long-Horizon Salami & Cumulative Risk Engine, Differential & Mutation Verifier, Risk-Stratified Assurance Scorecard, and Reproducible Trial Evidence Bundle). 46 patent candidates (NOVEL) · 40 UNUSUAL · 9 ENGINEERING · 7 INTEGRATION: Quorum-committed authorization snapshots · Mission goal-attenuation lattice (E38) · Continuously conditioned authorization · Dependency-driven authorization invalidation with blast radius · Authority non-transfer across governance domains (E37) · All-or-nothing governance with race-safe revocation · Bounded assurance with continuous invalidation · Comparative control-selection proof · Independence-aware Byzantine quorum · Quorum-signed programmable governance (GOV-IR) · Quorum-authorized kernel execution · Prediction-bounded authorization · Authority Continuity Protocol · Uncertainty-contracting authority horizon · Autonomy vector with certificates and leases · Self-evolution that cannot self-authorize · Mission-to-organization compiler · 4D reachability-bounded trajectory authorization · Governance contract fabric · Continuous governance attestation · Governance research fabric · Liveness-bound signed public claims · Multi-turn adversarial tool-call mediation · Anti-gaming benchmark harness seals · Long-horizon salami cumulative exfiltration defense · Ground-truth multi-modal physical outcome oracle. Each one is backed by its own passing tests (182/182 regression tests pass). FIRME AI CORPORATION IP base: $17,123,490 (IP register v56, 2026-10-23; range $6,634,180–$30,380,500; internal analytical register scenario, not an appraisal). Early-revenue: 3 founder-attested customers, $193 (customer #3 recurring $96/mo). What each one does, and its value · Evolution 5 Sovereign Trial evidence bundle.

    Identity, security & cryptography

    Built and tested

    Agent Registry & Identity

    Register, revoke and expire every agent identity. A revoked agent is refused on its next request.

    measured: IMPLEMENTED

    Built and tested

    DID Identity (W3C)

    Every agent gets a standard W3C did:key, and you can publish a did:web document that follows key rotation and deactivates the moment the identity is revoked.

    measured: IMPLEMENTED

    Built and tested

    Trust Tokenization

    Short-lived signed capability tokens bound to the exact action, parameters and model. Not a tradeable token.

    measured: NARROWER: IMPLEMENTED

    Built and tested

    Quantum-Resistant Crypto

    An ML-DSA-65 post-quantum signing module, tested. Live decisions are still signed with Ed25519.

    measured: NARROWER: IMPLEMENTED

    Live

    TEE Attestation

    Verify YOUR enclaves before trusting them: AWS Nitro Enclaves documents and AMD SEV-SNP reports, checked against pinned AWS and AMD roots (tested on real evidence). CAIN's own servers are not hardware-attested.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Runtime control & consensus

    Live

    PBFT Cluster

    Two live 4-replica Byzantine-fault-tolerant clusters: 3 of 4 replicas must sign before anything counts. Quorum-QaaS now sells that consensus as a service: any enterprise can get BFT without building it. Send the SHA-256 digest of any record with your API key and get back a receipt signed by the quorum, which anyone can verify offline.

    measured: LIVE VERIFIED

    Live

    Production Cluster

    Every hosted decision carries a quorum certificate that the gateway verifies itself.

    measured: LIVE VERIFIED / LIVE VERIFIED

    Live

    Agent Hypervisor (ZoD)

    A tool call routed through MCPGate runs only with a quorum-committed authorization; the SDK is default-deny. Calls that bypass the gate are not governed.

    measured: NARROWER: LIVE + DISPOSABLE CLUSTER VERIFIED

    Verified offline

    Formal Verification (TLA+)

    TLA+ models of PBFT commit, view change and the MCPGate gate, model-checked by TLC (bounded models, not a proof of the Python code).

    measured: OFFLINE VERIFIED

    Built and tested

    Policy-as-Code Engine

    OPA/Rego policies with signed policy bundles. In the hosted pipeline the policy verdict is recorded; your own tool rules are what block.

    measured: IMPLEMENTED

    Live

    Sovereign AI Control

    Self-hostable MCPGate and SDK, tested, with a live status endpoint. No public self-hosted installer yet.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Threat detection & response

    Live

    Shadow AI Discovery

    Find unregistered agents on your hosts, and LLM SDKs, MCP tools and autonomous loops in your code, with a live scanner. Not a network-wide scanner.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Live

    Autonomic Self-Healing

    Automated quarantine and recovery, tested; live restore drills verified (run by an operator).

    measured: NARROWER: LIVE VERIFIED

    Built and tested

    Predictive Threat Intelligence

    Predicts an action's blast radius and counterfactual risk before it runs. No external threat feed.

    measured: NARROWER: IMPLEMENTED

    Built and tested

    ML Anomaly Detection

    Real-time trajectory anomaly rules: drift, salami-style cumulative spend, homoglyphs. Rules and thresholds, not a trained model.

    measured: NARROWER: IMPLEMENTED

    Compliance & governance

    Built and tested

    EU AI Act Compliance

    Article 5, Annex III and Article 50 screening plus tamper-evident evidence export. No notified body has reviewed CAIN.

    measured: NARROWER: IMPLEMENTED

    Live

    Multi-Jurisdiction Compliance

    Live required-clause checks for the EU and California, plus EU AI Act screening. Two jurisdictions, not a global rules engine.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Built and tested

    Autonomous Governance

    Plans, conflicts and delegations are checked automatically before execution. Automation never authorizes itself.

    measured: NARROWER: IMPLEMENTED

    Not offered

    ISO 42001 certification: not offered

    Not offered: CAIN-42 is not ISO 42001 certified. A readiness self-assessment exists.

    measured: NOT ESTABLISHED

    Not offered

    Cross-Chain Governance

    Not offered: there is no blockchain or cross-chain component.

    measured: NOT ESTABLISHED

    Interoperability

    Live

    A2A + MCP Protocol

    MCP enforcement on the live cluster, and an A2A trust layer that refuses forged agent cards.

    measured: LIVE + DISPOSABLE CLUSTER VERIFIED

    Live

    Third-Party AI Governance

    External tools and APIs your agent reaches through CAIN are pinned and allow-listed: changed tools are dropped, unknown destinations denied.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Live

    Delegation Marketplace

    Bounded delegation chains (scope, limits, expiry, revocation) and a live agent marketplace. Organisations do not trade tool permissions through it.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Live

    Global Trust Mesh

    Two live multi-region clusters across 4 US regions, on one provider. Not global yet.

    measured: NARROWER: LIVE VERIFIED

    Developer platform & SRE

    Live

    Agent SRE

    A live decision stream and traces in the console, plus live observability and agent-debugger services.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Live

    Vertical Solutions

    Finance, health and federal policy packs, served live. Rule sets, maintained and versioned.

    measured: NARROWER: IMPLEMENTED, LIVE ENDPOINT

    Built and tested

    Agent CI/CD Pipeline

    A conformance suite and a deploy gate exist and are tested. No hosted CI/CD product for your agents yet.

    measured: NARROWER: IMPLEMENTED

    Built and tested

    Collective Intelligence

    Shared trust, risk and incident state across agents, tested in-process.

    measured: NARROWER: IMPLEMENTED

    Built and tested

    Evolutionary Architecture

    A self-hardening loop that proposes and tests changes. Nothing deploys itself.

    measured: NARROWER: IMPLEMENTED

    Live

    Policy Cards

    Eight ready-made policies (payment approvals and caps, read-only database, internal-only email, shell approval, redaction, agent hold) that compile into rules the live pipeline enforces. Preview free; apply with your key.

    measured: IMPLEMENTED, LIVE ENDPOINT

    Not offered

    Neural Governance

    Not offered: the term has no implementation.

    measured: NOT ESTABLISHED

    Not offered

    Quantum Governance

    Not offered: the term has no implementation.

    measured: NOT ESTABLISHED

    Put your AI system under governance

    Free to start. Nothing runs without authority: the default is no.

    Under the hood

    The technical detail

    Everything below is for senior AI and security engineers: how CAIN-42 governs an autonomous AI agent, what is live, what is only tested, and what is not built. Every claim links to signed evidence and a verifier that imports none of CAIN-42's code.

    Control for the AGI era

    Built to control AGI

    As AI agents get more capable, the question stops being “is the model smart?” and becomes “who decides what it is allowed to do?” CAIN-42 answers it the same way for every agent, however capable: being capable, confident or right before earns an agent no authority. No AGI exists yet to test against, so every result published here is measured on today’s models. Prompt filters inspect text. CAIN-42 governs what autonomous AI agents actually do: tool calls, shell, databases, APIs, money, spawning other agents. One authorization is not enough for a system that runs for hours, so authority is continuous: a short-lived, governance-signed lease bound to the agent, its trajectory and its exact plan, re-checked before every action against everything the system has done so far, and lost the moment policy, trust, risk, model or context changes. An agent may learn, remember, plan, delegate and discover tools, but none of that creates authority. Only governance state signed by a quorum of the CAIN-42 cluster does. CAG-L5 is CAIN's own governance designation, not the SAE driving scale.

    CAG-L5 system governor (live)

    Governs the whole autonomous system, not a single call. One decision composes: emergency freeze, a 2f+1 cluster certificate over the current governance state, a governance-signed system manifest (agents, models, tools, resources), model identity, tool registry, exact capabilities (READ, WRITE, DELETE and ADMIN are never implied by each other), deterministic policy precedence (a lower ALLOW never beats a higher DENY), the intersection of agent, delegator, system and trajectory-lease authority, and graph-derived blast radius where irreversible or wide actions need two operators. The gate re-verifies the signed decision and its execution commitment before anything runs. On in the hosted gateway since 2026-09-28: unregistered systems and unsigned requests are refused. Also live since 2026-09-28: the evolution gate. An agent's model and MCP tool set change only through a signed proposal, an evaluator-signed test report and a human operator (never the agent itself), and every change gets a new capability commitment that the cluster must sign before the agent may act again. Since 2026-10-06 a signed agent passport binds identity, model, tools and authority scope to the exact call; sequences of individually allowed calls (a sensitive read then an outbound send, even split across two keys, a privilege raised step by step, split payments, a runaway loop) go to a human; and a tenant-owned physical safety envelope refuses out-of-envelope device actions, even in shadow mode.

    verify the live run (41/41) →

    Byzantine consensus authorization (live)

    Two live PBFT clusters, n=4 and f=1: cain-mr-02 (Atlanta, Los Angeles, Miami, Silicon Valley) orders and signs hosted decisions with one replica per host surviving any single host loss, and cain-mr-01 (Atlanta, Los Angeles, Miami) has committed 40,436 sequences. Nothing counts without a quorum certificate of 3 Ed25519 signatures, and the gateway verifies that certificate itself instead of trusting a replica's word. Each cluster signs its own proof every 30 minutes: 250 of 251 OPERATIONAL on cain-mr-01 since 2026-09-26, 295 of 295 on cain-mr-02 since 2026-09-27. 442 Byzantine tests pass, and a fault-injection run held 49 of 49 checks.

    watch it live →

    Enforcement boundary (MCPGate)

    Sits in front of MCP servers, APIs and tools. A call runs only if that exact call was authorized; anything else gets a signed denial. The tool server never receives CAIN's authorization envelope or the caller's credentials, and an operator's global halt or agent quarantine stops hosted decisions for every tenant. Being caught earns an agent nothing: two blocked prompt injections no longer unlock a $250,000 transfer or rm -rf /, every action is scored by what it does (tool, destructiveness, amount), dangerous ones wait for a human, your deny rules match every spelling of a path, and an approval covers one exact call, arguments included. Live on 3 of 3 domains since 2026-09-28; 48 of 48 decisions match the cluster's own public record.

    5 ran, 12 attacks blocked →

    Signed evidence

    An Ed25519-signed, hash-chained record per decision in canonical JSON (RFC 8785) with RFC 6962 Merkle proof trees, keys kept outside the database, and standalone clean-room verifiers that re-check everything offline without CAIN code. The identity and passport log is hash-chained per tenant with issuer-signed checkpoints, so an edited, deleted, reordered or truncated record fails offline verification.

    Verification Center →

    Default-deny SDK & data plane (live)

    The Python guard and MCP proxy hold any action you did not declare. Allow tools explicitly with guard(allow=[...]); opting out is recorded on every decision. A decoupled data plane (CAIN_AUTH_SNAPSHOT=1) that authorizes locally against quorum-committed PBFT snapshots is built and tested, but it is switched off on the hosted gateway today (CAIN_AUTH_SNAPSHOT=0), so hosted decisions still wait for a consensus round.

    quickstart →

    Frontier agent intelligence & ZoD (live)

    Agent code runs confined with Linux namespaces and seccomp-BPF filters. Real-time Process Reward Model (AgentPRM arXiv:2502.10325) prunes hallucinated shortcut steps, TriCEGAR model checks MDP state transitions, Governed Memory Shield sanitizes injection vectors at write time, and A2A delegation verifies Ed25519 card and delegation signatures, attenuates monotonically and labels capabilities self-asserted. Agent keys cannot raise their own memory to trusted, write policies or operate the controls that govern them. Live endpoints at /fabric/frontier/*.

    verify Phase 3 evidence →

    Send one action through the live pipeline

    No account. Each button posts a fixed scenario to /fabric/try on this site and shows the real decision, stage by stage, including whether each stage was enforcing. The demo forces enforcement on for its own throwaway tenant; the response says so. A read-only action runs by itself as the page opens, so you see the live pipeline decide without touching anything.

    For developers

    One request. A signed decision back.

    Try it with no account: send a prompt-injection attempt through the live pipeline. You get back the verdict, which stage blocked it, and the consensus certificate your gateway verified.

    $ curl -X POST "https://cainstudio.online/fabric/try?scenario=prompt-injection"
    {
      "verdict": "BLOCKED",
      "blocked_by": ["risk", "trust"],
      "consensus": {
        "cluster_id": "cain-mr-02",
        "certificate_verified_by_gateway": {
          "verified": true,
          "signers": ["cain-mr2-node-1", "cain-mr2-node-3", "cain-mr2-node-4"],
          "quorum": 3
        }
      },
      "evidence": { ... }
    }

    Architecture

    Where CAIN-42 sits

    Solid boxes are on the live path. The PBFT cluster is drawn dashed; it runs live in 4 regions (watch it).

    Solid: in the live path today.Dashed: the consensus layer (live cluster cain-mr-02); it orders and signs every hosted decision.Verdicts: ALLOW · REQUIRE_APPROVAL · BLOCKED.

    Proof, not promises

    Check what is live right now

    Your browser loads each row below from its source as the page opens. A source that does not answer shows as NOT LIVE. The passing set is shown here; every claim, its limits and every run outcome stay published in full on the Proof page.

    Verifier Room — verify CAIN-42 yourself, in seconds

    You do not have to trust us or contact us. Every evidence bundle below ships a clean-room verifier that imports none of CAIN-42's code. Copy one block into a terminal on your own computer: it downloads that bundle and its verifiers, and runs two chained checks. verify_publisher.py must print PUBLISHED_BY_PINNED_KEY: the bytes are exactly what the CAIN publisher key signed, so an edited or re-signed bundle fails. Only then does the bundle's own verifier run, and it must print "result": "INTACT": its internal hashes and signatures agree. The block ends with one line, VERIFIED or NOT VERIFIED. Do not run the bundle verifier on its own. Nothing on these sites is needed after the download.

    Requires Python 3 and internet. The verifiers read published data only; they never touch the live service and never call our servers for a verdict. A changed byte in any bundle file makes the verifier report BROKEN. INTACT alone means only that the bundle agrees with the key shipped inside it, which anyone who re-signs a bundle can arrange. That is why every block also runs verify_publisher.py (verifier, pinned key at /.well-known/cain-publisher-key.json): it refuses an edited, added, removed or re-signed file. The publisher key is ours, so neither check is independent verification.

    BFTIP · bft-ip-forensics-2026-10-05

    — published result: INTACT (58/59 checks)

    mkdir -p bft-ip-forensics-2026-10-05 && cd bft-ip-forensics-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/bft-ip-forensics-2026-10-05.json", "../bft-ip-forensics-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../bft-ip-forensics-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "bft-ip-forensics-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "bft-ip-forensics-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../bft-ip-forensics-2026-10-05 ../bft-ip-forensics-2026-10-05.attestation.json \
      && python3 verify_bftip.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E38 · e38-byzantine-mission-integrity-2026-10-05

    — published result: INTACT (127/127 checks)

    mkdir -p e38-byzantine-mission-integrity-2026-10-05 && cd e38-byzantine-mission-integrity-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e38-byzantine-mission-integrity-2026-10-05.json", "../e38-byzantine-mission-integrity-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e38-byzantine-mission-integrity-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e38-byzantine-mission-integrity-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e38-byzantine-mission-integrity-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e38-byzantine-mission-integrity-2026-10-05 ../e38-byzantine-mission-integrity-2026-10-05.attestation.json \
      && python3 verify_e38.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E37 · e37-byzantine-autonomous-federation-2026-10-05

    30/30 invariants · 30/30 scenarios held — published result: INTACT (70/70 checks)

    mkdir -p e37-byzantine-autonomous-federation-2026-10-05 && cd e37-byzantine-autonomous-federation-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e37-byzantine-autonomous-federation-2026-10-05.json", "../e37-byzantine-autonomous-federation-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e37-byzantine-autonomous-federation-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e37-byzantine-autonomous-federation-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e37-byzantine-autonomous-federation-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e37-byzantine-autonomous-federation-2026-10-05 ../e37-byzantine-autonomous-federation-2026-10-05.attestation.json \
      && python3 verify_e37.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E36 · e36-byzantine-collective-governance-2026-10-05

    23/30 invariants · 30/30 scenarios held — published result: INTACT (69/76 checks)

    mkdir -p e36-byzantine-collective-governance-2026-10-05 && cd e36-byzantine-collective-governance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e36-byzantine-collective-governance-2026-10-05.json", "../e36-byzantine-collective-governance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e36-byzantine-collective-governance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e36-byzantine-collective-governance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e36-byzantine-collective-governance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e36-byzantine-collective-governance-2026-10-05 ../e36-byzantine-collective-governance-2026-10-05.attestation.json \
      && python3 verify_e36.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E35 · e35-continuous-autonomy-integrity-2026-10-05

    27/30 invariants · 30/30 scenarios held — published result: INTACT (108/111 checks)

    mkdir -p e35-continuous-autonomy-integrity-2026-10-05 && cd e35-continuous-autonomy-integrity-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e35-continuous-autonomy-integrity-2026-10-05.json", "../e35-continuous-autonomy-integrity-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e35-continuous-autonomy-integrity-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e35-continuous-autonomy-integrity-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e35-continuous-autonomy-integrity-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e35-continuous-autonomy-integrity-2026-10-05 ../e35-continuous-autonomy-integrity-2026-10-05.attestation.json \
      && python3 verify_e35.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E34 · e34-decision-provenance-2026-10-05

    0/0 invariants · 0/0 scenarios held — published result: PARTIAL (0/0 checks)

    mkdir -p e34-decision-provenance-2026-10-05 && cd e34-decision-provenance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e34-decision-provenance-2026-10-05.json", "../e34-decision-provenance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e34-decision-provenance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e34-decision-provenance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e34-decision-provenance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e34-decision-provenance-2026-10-05 ../e34-decision-provenance-2026-10-05.attestation.json \
      && python3 verify_e34.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E32 · e32-global-trust-settlement-2026-10-05

    mkdir -p e32-global-trust-settlement-2026-10-05 && cd e32-global-trust-settlement-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e32-global-trust-settlement-2026-10-05.json", "../e32-global-trust-settlement-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e32-global-trust-settlement-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e32-global-trust-settlement-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e32-global-trust-settlement-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e32-global-trust-settlement-2026-10-05 ../e32-global-trust-settlement-2026-10-05.attestation.json \
      && python3 verify_e32.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E31 · e31-governance-proof-fabric-2026-10-05

    mkdir -p e31-governance-proof-fabric-2026-10-05 && cd e31-governance-proof-fabric-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e31-governance-proof-fabric-2026-10-05.json", "../e31-governance-proof-fabric-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e31-governance-proof-fabric-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e31-governance-proof-fabric-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e31-governance-proof-fabric-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e31-governance-proof-fabric-2026-10-05 ../e31-governance-proof-fabric-2026-10-05.attestation.json \
      && python3 verify_e31.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E30 · e30-governance-network-2026-10-05

    mkdir -p e30-governance-network-2026-10-05 && cd e30-governance-network-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e30-governance-network-2026-10-05.json", "../e30-governance-network-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e30-governance-network-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e30-governance-network-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e30-governance-network-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e30-governance-network-2026-10-05 ../e30-governance-network-2026-10-05.attestation.json \
      && python3 verify_e30.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E28 · e28-catcp-ip-commercial-2026-10-05

    mkdir -p e28-catcp-ip-commercial-2026-10-05 && cd e28-catcp-ip-commercial-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e28-catcp-ip-commercial-2026-10-05.json", "../e28-catcp-ip-commercial-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e28-catcp-ip-commercial-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e28-catcp-ip-commercial-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e28-catcp-ip-commercial-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e28-catcp-ip-commercial-2026-10-05 ../e28-catcp-ip-commercial-2026-10-05.attestation.json \
      && python3 verify_e28.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E27 · e27-catcp-control-2026-10-05

    mkdir -p e27-catcp-control-2026-10-05 && cd e27-catcp-control-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e27-catcp-control-2026-10-05.json", "../e27-catcp-control-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e27-catcp-control-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e27-catcp-control-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e27-catcp-control-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e27-catcp-control-2026-10-05 ../e27-catcp-control-2026-10-05.attestation.json \
      && python3 verify_e27.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E26 · e26-byzantine-trust-2026-10-05

    mkdir -p e26-byzantine-trust-2026-10-05 && cd e26-byzantine-trust-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e26-byzantine-trust-2026-10-05.json", "../e26-byzantine-trust-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e26-byzantine-trust-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e26-byzantine-trust-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e26-byzantine-trust-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e26-byzantine-trust-2026-10-05 ../e26-byzantine-trust-2026-10-05.attestation.json \
      && python3 verify_e26.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E23 · e23-continuous-assurance-2026-10-05

    mkdir -p e23-continuous-assurance-2026-10-05 && cd e23-continuous-assurance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e23-continuous-assurance-2026-10-05.json", "../e23-continuous-assurance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e23-continuous-assurance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e23-continuous-assurance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e23-continuous-assurance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e23-continuous-assurance-2026-10-05 ../e23-continuous-assurance-2026-10-05.attestation.json \
      && python3 verify_e23.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E22 · e22-byzantine-global-verification-2026-10-05

    mkdir -p e22-byzantine-global-verification-2026-10-05 && cd e22-byzantine-global-verification-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e22-byzantine-global-verification-2026-10-05.json", "../e22-byzantine-global-verification-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e22-byzantine-global-verification-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e22-byzantine-global-verification-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e22-byzantine-global-verification-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e22-byzantine-global-verification-2026-10-05 ../e22-byzantine-global-verification-2026-10-05.attestation.json \
      && python3 verify_e22.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E21 · e21-byzantine-economic-coordination-2026-10-05

    mkdir -p e21-byzantine-economic-coordination-2026-10-05 && cd e21-byzantine-economic-coordination-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e21-byzantine-economic-coordination-2026-10-05.json", "../e21-byzantine-economic-coordination-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e21-byzantine-economic-coordination-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e21-byzantine-economic-coordination-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e21-byzantine-economic-coordination-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e21-byzantine-economic-coordination-2026-10-05 ../e21-byzantine-economic-coordination-2026-10-05.attestation.json \
      && python3 verify_e21.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E18 · e18-byzantine-counterfactual-governance-2026-10-05

    — published result: VALID (31/31 checks)

    mkdir -p e18-byzantine-counterfactual-governance-2026-10-05 && cd e18-byzantine-counterfactual-governance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e18-byzantine-counterfactual-governance-2026-10-05.json", "../e18-byzantine-counterfactual-governance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e18-byzantine-counterfactual-governance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e18-byzantine-counterfactual-governance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e18-byzantine-counterfactual-governance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e18-byzantine-counterfactual-governance-2026-10-05 ../e18-byzantine-counterfactual-governance-2026-10-05.attestation.json \
      && python3 verify_e18.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E13 · e13-bpf-governance-execution-2026-10-05

    — published result: INTACT (24/24 checks)

    mkdir -p e13-bpf-governance-execution-2026-10-05 && cd e13-bpf-governance-execution-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e13-bpf-governance-execution-2026-10-05.json", "../e13-bpf-governance-execution-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e13-bpf-governance-execution-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e13-bpf-governance-execution-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e13-bpf-governance-execution-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e13-bpf-governance-execution-2026-10-05 ../e13-bpf-governance-execution-2026-10-05.attestation.json \
      && python3 verify_e13.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E12 · e12-trust-network-state-2026-10-05

    — published result: INTACT (20/20 checks)

    mkdir -p e12-trust-network-state-2026-10-05 && cd e12-trust-network-state-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e12-trust-network-state-2026-10-05.json", "../e12-trust-network-state-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e12-trust-network-state-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e12-trust-network-state-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e12-trust-network-state-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e12-trust-network-state-2026-10-05 ../e12-trust-network-state-2026-10-05.attestation.json \
      && python3 verify_e12.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E11 · e11-governance-proof-2026-10-05

    — published result: INTACT (32/32 checks)

    mkdir -p e11-governance-proof-2026-10-05 && cd e11-governance-proof-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e11-governance-proof-2026-10-05.json", "../e11-governance-proof-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e11-governance-proof-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e11-governance-proof-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e11-governance-proof-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e11-governance-proof-2026-10-05 ../e11-governance-proof-2026-10-05.attestation.json \
      && python3 verify_e11.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E42 · e42-supreme-governed-agentic-infrastructure-2026-10-01

    — published result: INTACT (1460/1460 checks)

    mkdir -p e42-supreme-governed-agentic-infrastructure-2026-10-01 && cd e42-supreme-governed-agentic-infrastructure-2026-10-01
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e42-supreme-governed-agentic-infrastructure-2026-10-01.json", "../e42-supreme-governed-agentic-infrastructure-2026-10-01.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e42-supreme-governed-agentic-infrastructure-2026-10-01.attestation.json"))["files"])
    for f in names:
        get(E + "e42-supreme-governed-agentic-infrastructure-2026-10-01/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e42-supreme-governed-agentic-infrastructure-2026-10-01/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e42-supreme-governed-agentic-infrastructure-2026-10-01 ../e42-supreme-governed-agentic-infrastructure-2026-10-01.attestation.json \
      && python3 verify_e42.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E41 · e41-machine-agency-exchange-2026-09-30

    — published result: INTACT (1303/1303 checks)

    mkdir -p e41-machine-agency-exchange-2026-09-30 && cd e41-machine-agency-exchange-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e41-machine-agency-exchange-2026-09-30.json", "../e41-machine-agency-exchange-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e41-machine-agency-exchange-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e41-machine-agency-exchange-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e41-machine-agency-exchange-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e41-machine-agency-exchange-2026-09-30 ../e41-machine-agency-exchange-2026-09-30.attestation.json \
      && python3 verify_e41.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E40 · e40-autonomous-enterprise-intelligence-2026-09-30

    — published result: INTACT (1518/1518 checks)

    mkdir -p e40-autonomous-enterprise-intelligence-2026-09-30 && cd e40-autonomous-enterprise-intelligence-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e40-autonomous-enterprise-intelligence-2026-09-30.json", "../e40-autonomous-enterprise-intelligence-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e40-autonomous-enterprise-intelligence-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e40-autonomous-enterprise-intelligence-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e40-autonomous-enterprise-intelligence-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e40-autonomous-enterprise-intelligence-2026-09-30 ../e40-autonomous-enterprise-intelligence-2026-09-30.attestation.json \
      && python3 verify_e40.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E37 · e37-autonomous-execution-mesh-2026-09-30

    1132/1132 invariants · 2720/2720 scenarios held — published result: INTACT (2627/2627 checks)

    mkdir -p e37-autonomous-execution-mesh-2026-09-30 && cd e37-autonomous-execution-mesh-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e37-autonomous-execution-mesh-2026-09-30.json", "../e37-autonomous-execution-mesh-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e37-autonomous-execution-mesh-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e37-autonomous-execution-mesh-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e37-autonomous-execution-mesh-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e37-autonomous-execution-mesh-2026-09-30 ../e37-autonomous-execution-mesh-2026-09-30.attestation.json \
      && python3 verify_e37.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E36 · e36-machine-agency-exchange-2026-09-30

    842/842 invariants · 3340/3340 scenarios held — published result: INTACT (3601/3601 checks)

    mkdir -p e36-machine-agency-exchange-2026-09-30 && cd e36-machine-agency-exchange-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e36-machine-agency-exchange-2026-09-30.json", "../e36-machine-agency-exchange-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e36-machine-agency-exchange-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e36-machine-agency-exchange-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e36-machine-agency-exchange-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e36-machine-agency-exchange-2026-09-30 ../e36-machine-agency-exchange-2026-09-30.attestation.json \
      && python3 verify_e36.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E35 · e35-governance-intelligence-2026-09-30

    799/799 invariants · 3544/3544 scenarios held — published result: INTACT (3810/3810 checks)

    mkdir -p e35-governance-intelligence-2026-09-30 && cd e35-governance-intelligence-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e35-governance-intelligence-2026-09-30.json", "../e35-governance-intelligence-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e35-governance-intelligence-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e35-governance-intelligence-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e35-governance-intelligence-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e35-governance-intelligence-2026-09-30 ../e35-governance-intelligence-2026-09-30.attestation.json \
      && python3 verify_e35.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E34 · e34-proof-carrying-machine-agency-2026-09-30

    629/629 invariants · 2664/2664 scenarios held — published result: INTACT (3286/3286 checks)

    mkdir -p e34-proof-carrying-machine-agency-2026-09-30 && cd e34-proof-carrying-machine-agency-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e34-proof-carrying-machine-agency-2026-09-30.json", "../e34-proof-carrying-machine-agency-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e34-proof-carrying-machine-agency-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e34-proof-carrying-machine-agency-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e34-proof-carrying-machine-agency-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e34-proof-carrying-machine-agency-2026-09-30 ../e34-proof-carrying-machine-agency-2026-09-30.attestation.json \
      && python3 verify_e34.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E33 · e33-governed-agentic-operating-fabric-2026-09-30

    581/581 invariants · 2029/2029 scenarios held — published result: INTACT (2603/2603 checks)

    mkdir -p e33-governed-agentic-operating-fabric-2026-09-30 && cd e33-governed-agentic-operating-fabric-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e33-governed-agentic-operating-fabric-2026-09-30.json", "../e33-governed-agentic-operating-fabric-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e33-governed-agentic-operating-fabric-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e33-governed-agentic-operating-fabric-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e33-governed-agentic-operating-fabric-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e33-governed-agentic-operating-fabric-2026-09-30 ../e33-governed-agentic-operating-fabric-2026-09-30.attestation.json \
      && python3 verify_e33.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E32 · e32-governed-autonomy-learning-2026-09-30

    — published result: INTACT (1420/1420 checks)

    mkdir -p e32-governed-autonomy-learning-2026-09-30 && cd e32-governed-autonomy-learning-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e32-governed-autonomy-learning-2026-09-30.json", "../e32-governed-autonomy-learning-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e32-governed-autonomy-learning-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e32-governed-autonomy-learning-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e32-governed-autonomy-learning-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e32-governed-autonomy-learning-2026-09-30 ../e32-governed-autonomy-learning-2026-09-30.attestation.json \
      && python3 verify_e32.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E31 · e31-universal-proof-of-governance-2026-09-30

    — published result: INTACT (1676/1676 checks)

    mkdir -p e31-universal-proof-of-governance-2026-09-30 && cd e31-universal-proof-of-governance-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e31-universal-proof-of-governance-2026-09-30.json", "../e31-universal-proof-of-governance-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e31-universal-proof-of-governance-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e31-universal-proof-of-governance-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e31-universal-proof-of-governance-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e31-universal-proof-of-governance-2026-09-30 ../e31-universal-proof-of-governance-2026-09-30.attestation.json \
      && python3 verify_e31.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E30 · e30-governed-machine-autonomy-2026-09-30

    — published result: INTACT (1187/1187 checks)

    mkdir -p e30-governed-machine-autonomy-2026-09-30 && cd e30-governed-machine-autonomy-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e30-governed-machine-autonomy-2026-09-30.json", "../e30-governed-machine-autonomy-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e30-governed-machine-autonomy-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e30-governed-machine-autonomy-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e30-governed-machine-autonomy-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e30-governed-machine-autonomy-2026-09-30 ../e30-governed-machine-autonomy-2026-09-30.attestation.json \
      && python3 verify_e30.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E29 · e29-machine-transaction-fabric-2026-09-30

    — published result: INTACT (300/300 checks)

    mkdir -p e29-machine-transaction-fabric-2026-09-30 && cd e29-machine-transaction-fabric-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e29-machine-transaction-fabric-2026-09-30.json", "../e29-machine-transaction-fabric-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e29-machine-transaction-fabric-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e29-machine-transaction-fabric-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e29-machine-transaction-fabric-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e29-machine-transaction-fabric-2026-09-30 ../e29-machine-transaction-fabric-2026-09-30.attestation.json \
      && python3 verify_e29.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E28 · e28-portable-execution-identity-2026-09-30

    — published result: INTACT (243/243 checks)

    mkdir -p e28-portable-execution-identity-2026-09-30 && cd e28-portable-execution-identity-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e28-portable-execution-identity-2026-09-30.json", "../e28-portable-execution-identity-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e28-portable-execution-identity-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e28-portable-execution-identity-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e28-portable-execution-identity-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e28-portable-execution-identity-2026-09-30 ../e28-portable-execution-identity-2026-09-30.attestation.json \
      && python3 verify_e28.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E27 · e27-agentic-internet-control-plane-2026-09-30

    — published result: INTACT (4001/4001 checks)

    mkdir -p e27-agentic-internet-control-plane-2026-09-30 && cd e27-agentic-internet-control-plane-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e27-agentic-internet-control-plane-2026-09-30.json", "../e27-agentic-internet-control-plane-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e27-agentic-internet-control-plane-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e27-agentic-internet-control-plane-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e27-agentic-internet-control-plane-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e27-agentic-internet-control-plane-2026-09-30 ../e27-agentic-internet-control-plane-2026-09-30.attestation.json \
      && python3 verify_e27.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E26 · e26-universal-machine-agency-trust-2026-09-30

    — published result: INTACT (3115/3115 checks)

    mkdir -p e26-universal-machine-agency-trust-2026-09-30 && cd e26-universal-machine-agency-trust-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e26-universal-machine-agency-trust-2026-09-30.json", "../e26-universal-machine-agency-trust-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e26-universal-machine-agency-trust-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e26-universal-machine-agency-trust-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e26-universal-machine-agency-trust-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e26-universal-machine-agency-trust-2026-09-30 ../e26-universal-machine-agency-trust-2026-09-30.attestation.json \
      && python3 verify_e26.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E25 · e25-universal-machine-agency-2026-09-30

    — published result: INTACT (2977/2977 checks)

    mkdir -p e25-universal-machine-agency-2026-09-30 && cd e25-universal-machine-agency-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e25-universal-machine-agency-2026-09-30.json", "../e25-universal-machine-agency-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e25-universal-machine-agency-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e25-universal-machine-agency-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e25-universal-machine-agency-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e25-universal-machine-agency-2026-09-30 ../e25-universal-machine-agency-2026-09-30.attestation.json \
      && python3 verify_e25.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E24 · e24-governed-agentic-internet-2026-09-29

    — published result: INTACT (1952/1952 checks)

    mkdir -p e24-governed-agentic-internet-2026-09-29 && cd e24-governed-agentic-internet-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e24-governed-agentic-internet-2026-09-29.json", "../e24-governed-agentic-internet-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e24-governed-agentic-internet-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e24-governed-agentic-internet-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e24-governed-agentic-internet-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e24-governed-agentic-internet-2026-09-29 ../e24-governed-agentic-internet-2026-09-29.attestation.json \
      && python3 verify_e24.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E23 · e23-governed-meta-intelligence-2026-09-29

    — published result: INTACT (733/733 checks)

    mkdir -p e23-governed-meta-intelligence-2026-09-29 && cd e23-governed-meta-intelligence-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e23-governed-meta-intelligence-2026-09-29.json", "../e23-governed-meta-intelligence-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e23-governed-meta-intelligence-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e23-governed-meta-intelligence-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e23-governed-meta-intelligence-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e23-governed-meta-intelligence-2026-09-29 ../e23-governed-meta-intelligence-2026-09-29.attestation.json \
      && python3 verify_e23.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E21 · e21-open-ended-intelligence-2026-09-29

    — published result: INTACT (218/218 checks)

    mkdir -p e21-open-ended-intelligence-2026-09-29 && cd e21-open-ended-intelligence-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e21-open-ended-intelligence-2026-09-29.json", "../e21-open-ended-intelligence-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e21-open-ended-intelligence-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e21-open-ended-intelligence-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e21-open-ended-intelligence-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e21-open-ended-intelligence-2026-09-29 ../e21-open-ended-intelligence-2026-09-29.attestation.json \
      && python3 verify_e21.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E20 · e20-agentic-institutions-2026-09-29

    — published result: INTACT (179/179 checks)

    mkdir -p e20-agentic-institutions-2026-09-29 && cd e20-agentic-institutions-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e20-agentic-institutions-2026-09-29.json", "../e20-agentic-institutions-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e20-agentic-institutions-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e20-agentic-institutions-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e20-agentic-institutions-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e20-agentic-institutions-2026-09-29 ../e20-agentic-institutions-2026-09-29.attestation.json \
      && python3 verify_e20.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E19 · e19-governed-autonomy-2026-09-28

    — published result: INTACT (117/117 checks)

    mkdir -p e19-governed-autonomy-2026-09-28 && cd e19-governed-autonomy-2026-09-28
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e19-governed-autonomy-2026-09-28.json", "../e19-governed-autonomy-2026-09-28.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e19-governed-autonomy-2026-09-28.attestation.json"))["files"])
    for f in names:
        get(E + "e19-governed-autonomy-2026-09-28/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e19-governed-autonomy-2026-09-28/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e19-governed-autonomy-2026-09-28 ../e19-governed-autonomy-2026-09-28.attestation.json \
      && python3 verify_e19.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    Newest published bundle: bft-ip-forensics-2026-10-05. Every bundle is also mirrored on the other two sites so the same verifier runs against an independent copy.

    What CAIN-42 is not, yet

    What CAIN-42 is, and is not

    What it is

    The governor for autonomous AI agents: a trust and execution-control runtime that sits between an autonomous AI system and the actions it takes. Every proposed action is checked (identity, authority, trajectory, policy, risk, trust, system scope), a boundary applies the verdict before the tool runs, and the decision is recorded as signed evidence. The CAG-L5 system governor runs in the hosted gateway: a system must be registered with a governance-signed manifest, every request must be signed by the agent's own key, and governance state counts only when the live 4-replica PBFT cluster has signed it with a quorum certificate (3 of 4 signatures). Every hosted decision is ordered and signed by that cluster, and agent authority in the CAIN-45 hypervisor is committed by it too. Since 2026-09-28 an agent's capability (its model and the MCP tools it may call) can change only through the governed evolution gate, and the cluster signs a capability commitment, so authority granted for the old capability never carries over to the new one.

    Is it an "agent hypervisor"?

    Partly. The hosted gateway mediates the tool calls routed through it and cannot see a call that bypasses it. Separately, the CAIN-45 agent hypervisor (ZoD) confines agent code with Linux namespaces and cgroups, takes its authority from the live cluster, and re-checks that authority before every action. It is a library the operator runs today. It has a kernel syscall filter (seccomp-BPF, classic BPF, not eBPF), but no egress allowlist (egress is deny-all) and no hardware attestation yet. It is not a VM hypervisor.

    What it is not, today

    Not certified by anyone. Not independently reviewed. Consensus for hosted decisions runs live on 4 replicas on 4 hosts in 4 regions (cluster cain-mr-02, one replica per host, so a quorum of 3 remains after any one host is lost), but one team and one provider run all of them, and one replica shares a host with the public gateway. Not every hosted stage enforces: since 2026-09-27 every tenant is in enforce mode by default, and identity, authorization, trust (which now weighs how dangerous the action itself is), your own tool rules, approval holds, PBFT consensus, MCPGate and execution block; the OPA policy, injection-screen, intent, verification and ActionProof verdicts are recorded but do not block on their own. An agent's authority lapses on a policy change and on risk or blast-radius budgets (tripped on the live cluster); a cluster epoch or membership change is enforced too, but was tested only with an injected change, not by re-keying the live cluster. "L5" here means CAG-L5, CAIN's own governance designation, not the SAE driving scale, and nothing claims an agent is "SAE Level 5". The live L5 run used an operator self-test tenant and a scripted agent: the run uses a scripted agent on an operator self-test tenant. Of 12 L5 governance capabilities, 6 are verified on the live path and 6 are tested but only partly exercised live (continuous authorization, trajectory, MCP execution, risk, trust, independent verification). The hosted endpoint returns a signed verdict; your own gate executes. Current known limitations, including every claim that is not a pass, are listed in full on the Proof page. The roadmap's next evolution (a unified trust kernel, eBPF kernel enforcement, swarm governance, cluster federation) is a plan, not built. No customer traffic is claimed.

    On this hosted deployment every tenant is in enforce mode by default (since 2026-09-27). Identity, authorization, trust (including how dangerous the action itself is), your own tool rules, approval holds, PBFT consensus (no quorum-certified commit, no execution), MCPGate, execution and the kill switch block. The OPA policy, injection-screen, intent, verification and ActionProof verdicts are recorded but do not block on their own. A tenant may opt down to shadow mode, and that choice is logged. The live mode is read from /fabric/status.

    8 ways to verify CAIN-42 yourself

    Verify CAIN-42 yourself

    Every step uses a real endpoint or a published, signed file. The verifiers import none of CAIN-42's code; the implementation itself is not published.

    1 · Live multi-region PBFT cluster

    4 replicas in Atlanta, Los Angeles and Miami, running now. Your browser fetches each decision from all four replicas and verifies every Ed25519 vote. It can audit the whole history continuously, and a tamper lab lets you try to get a modified certificate accepted. Fault-injection run: 336 certificates, 49/49 checks.

    2 · Current state

    The generated snapshot: commit, process start, enforcement flags, live mode, known limitations.

    3 · The signed claims registry

    Every public CAIN-42 claim with its status, evidence level, artifact digests and limits. Your browser checks the Ed25519 signature. Auditors: the signed CAIN-42 Auditor Kit 8.3.2 runs a 42-second integrity check offline, standard library only, at cainstudio.online/evidence/auditor-kit/8.3.2/ (human auditors can verify CAIN-42 in 169 seconds: the full challenge passed every stage in 169 s on a heavily loaded host, over its 42-second budget; initial verdict median 7.62 s over 30 cold runs, slowest 13.7 s).

    4 · Agent hypervisor on the live cluster

    Agent authority committed by cain-mr-01, then broken 17 ways: 14 tripped for real (expiry, trust, identity, tool schema, context, trajectory, revocation, deleted evidence, revoked parent, policy change, unreadable policy, risk budget, blast-radius budget, a delegate spending its parent's budget) and 3 injected (epoch, membership). Every next action was refused and the tool never ran. One command each, no CAIN code: 48/48 and 60/60 checks. The syscall-filter run is a third bundle (8/8).

    5 · MCPGate enforcing governance, live

    On the live gateway across all three domains: a tool an evolution disabled, a model swapped outside the gate and a lease issued before a capability change are all refused; cain-mr-01's own records carry every capability commitment its quorum signed. Earlier, on a disposable cluster: tool calls ran only with a PBFT-committed authorization and nine attack classes were refused.

    6 · Live sandbox cluster

    Crash up to two of four sandbox nodes and watch commits stop at the quorum boundary; signed node state checked in your browser.

    7 · Soak on the live multi-region cluster

    Continuous writes; every 20 minutes a random replica is killed on its own host and restarted; hourly hash-chained checkpoints signed with the evidence-root key, each with a fresh MCPGate-enforced authorization and its refused replay. The full run record is published checkpoint by checkpoint on the Proof page.

    Live status is shown in the 48-hour soak section.

    8 · Soak history, kept for the record

    The full history of every soak run — what each run exercised and how it ended — stays published, checkpoint by checkpoint, on the Proof page.

    24-Hour Production Soak — live run

    PUBLIC VERIFIER

    A 24-hour multi-region soak runs on the live cluster cain-mr-01: continuous writes, a replica killed and restarted every 20 minutes, and an hourly hash-chained checkpoint signed with the evidence-root key, each carrying a fresh MCPGate-enforced authorization and its refused replay.

    Soak: checking…

    Latest signed checkpoint → Verify it yourself

    The verdict is produced by the public verifier from the published checkpoints, not by a label written here: this page reports exactly what the verifier reports. The full run history is published checkpoint by checkpoint on the Proof page.

    Three sites, one system

    cainstudio.online · CAIN Studio

    The hosted CAIN-42 control plane: the decision pipeline, API keys, the evidence store, the public Lab and the Verification Center.

    mcpgate.online · MCPGate

    The enforcement boundary: the component in the agent's call path that lets a tool call run or stops it. Self-hosted by design.

    clawx.click · CLAWX

    The agent-facing layer: agent identity, channels and approvals, and the public evidence log. Most CLAWX integrations are not built yet; each is labelled.

    All three names resolve to one host today. They are three views of one system, not three independently operated deployments.

    History

    October 2026 — CAIN-42 now catalogs more than 8,000 products, services and monetizable mechanisms (1,680 implemented invention mechanisms and 8,324 monetization avenues across the product catalog). Rather than sell all of them at once, the product focus is now the October 2026 Top 100 — the 100 products we lead with, each with a deep description and a live demo. See the Top 100 →. Latest changes, 2026-10-09: Evolution 5 of 42 (Project Sovereign Trial) establishes adversarial agent assurance, verified multi-turn benchmarking, and tool-call mediation under indirect prompt injection across smolagents and agentic runtimes. Real multi-turn AI-agent execution channels are governed and evaluated without circular model-as-a-judge or self-reporting: 8 new invention families in cain/trial/ (declarative scenario engine, cryptographic harness integrity anti-gaming sealer, multi-turn causal adversarial trial engine, independent ground-truth outcome oracle evaluating actual filesystem/socket mutations, long-horizon salami and cumulative risk engine detecting sub-threshold exfiltration and synergy combinations, differential and mutation verifier injecting 64KB overflows, path traversals and unicode homoglyphs, risk-stratified assurance scorecard computing Attack Block Rates and actuarial underwriting curves, and reproducible trial evidence bundle with zero-dependency clean-room verifier). 182 of 182 regression tests pass across Evolutions 1–5 in 3.69s (16/16 formal properties, 24/24 adversarial breakers, 92 total breakers across the suite, 0 false allows); 10 of 10 clean-room trial samples verified and 4 of 4 tampered samples rejected fail-closed; >11,000 ops/sec, <80µs p50 latency. Register v36 expands the canonical IP base to 102 families (46 NOVEL, 40 UNUSUAL, 9 ENGINEERING, 7 INTEGRATION) with $11,970,450 Net Base IP ($21,630,200 High Net IP) and FIRME AI CORPORATION company value $14,452,450 (BASE Investor) / $15,452,450 (BASE Strategic) (2026-10-09 figures, since superseded: IP register v56 puts the IP base at $17,123,490) (see the Sovereign Trial evidence bundle). Earlier changes, 2026-10-07: governed self-evolution. An agent can now propose a better skill, and CAIN-42 decides whether it may become authorized behaviour: the candidate runs in a fresh confined process with no network, must reproduce its gain on hidden and unrelated regression tasks, passes the evolution gate, an operator approval and a canary, and every outcome gets a governance-signed receipt (16 of 16 verify under a clean-room verifier). On the benchmark the CAIN-governed agent reached 1.0 task success with 0 security violations, against 0.625 and 36 violations for an ungoverned self-evolving agent and 0.3333 for a static baseline; a continuous red team blocked 411 of 411 attacks after its first run found and closed 4 real defects in existing gates. Learning does not grant authority. The same day, batch 3 of IP hardening closed 11 decision-path and public-verifier defects, live on all three domains (12 of 12 forged proofs refused): a prepare certificate is no longer accepted as a commit, a signed DENIED record can no longer be re-split into ALLOWED, and the public offline, universal-proof, WORM and attestation verifiers no longer accept forgeries signed with the forger’s own key. 2026-10-04 to 2026-10-06: nine IP evolutions of the governance contract fabric were published (consequence forecasts, replay under a proposed change, governed learning that can only tighten, formal assurance, a governance compiler that can only narrow authority, mandatory governance packages, attestation); a live frontier model ran under the AGI control boundary in 50 runs across 14 scenarios with every specified property holding; boundary hardening closed 9 areas of the decision path (no credential leak through MCPGate, agent passports enforced on the hosted path, a tamper-evident identity log, trajectory governance, emergency halt and quarantine honoured for every tenant); IP hardening batches 1 and 2 closed 23 more defects; and two public statements were corrected: the 200/200 invariant figure was withdrawn, and FIRME AI CORPORATION is valued at about $3 million (a 2026-10-06 figure, since superseded: the current internal IP register, v56, puts the IP base at $17,123,490; an internal analytical scenario, not an appraisal). Earlier, 2026-10-03: 104 of 105 catalog services are live (up from 6 the day before; the 98 deployed in this release each passed a live acceptance test), including seven new products (CAINBudget, CAINPay, VeritasEngine, MemoryMesh, NexusMind, LexisGuardian, OmegaRouter); recorded decisions that arrive together now share one PBFT round, each keeping its own Merkle inclusion proof (evidence). The 32 CAIN-42 capabilities were measured the same day and are on this page with their real status (signed audit). Before that, 2026-10-01: Phase 1-3 implementation and live deployment: the quorum-committed authorization-snapshot data plane (CAIN_AUTH_SNAPSHOT=1) is active on the live gateway, replacing the per-call PBFT round (p50 2,268.6 ms, n=20) with a snapshot-covered stage (p50 0.8263 ms, n=1,000) for snapshot-covered tenants (measured 2026-09-29 on cain-mr-01; run record dataplane-evolution-2026-09-29/governance/live_run.json). The Progressive Trust Matrix (_scope_seen) prevents horizontal credential reuse and unauthorized exfiltration holds; revoking an agent key halts it on its very next request (measured 2026-10-02; the revoke call itself took 3-6 s under heavy host load); action tokens bind payload SHA-256 digests; Evolution 8 physical ActionCommitBoundary enforces single-use capability leases (24/24 tests pass); mcpgate-appliance Helm chart v3.0.0 packaged for turnkey deployment; clean-room SDK installability verified (19/19 checks pass). Phase 3 Frontier AI Research Integration mounts AgentPRM Process Reward Model trajectory evaluation and shortcut pruning (arXiv:2502.10325), TriCEGAR discrete Markov Decision Process model checking, Governed Memory Shield write-time injection sanitization (Zep/Mem0 backdoor defense), and A2A inter-agent delegation attenuation directly onto live gateway endpoints (/fabric/frontier/*) with standalone clean-room verification (4/4 proofs pass). Earlier, 2026-09-30: Evolution 39 turns a mission into a governed machine organization: CAIN compiles the mission into bounded rules, designs the smallest team of agents that can do the work, gives each agent only the authority its role needs inside what the sponsoring person really holds, has every agent attacked and tested by an independent evaluator, promotes nothing on its own say-so, and runs the real work through the decision kernel and the E8 commit boundary with a proof for every action. No generated agent can grant itself authority, grade itself, promote itself or come back after it is retired. In a 16-step loop 4 real agents were provisioned and 3 consequential tasks ran with valid proofs; 1,041 of 1,041 invariants hold, 3,441 of 3,441 attack scenarios are contained, the targeted mutation test kills 16 of 16 mutants, and the clean-room verifier passes 3,307 of 3,307 checks. Evolution 38 lets another machine check CAIN's work without trusting CAIN: every governed action now carries twelve signed layer proofs and one action proof bound to its real E8 commit, and an independent verifier with none of our code recomputes whether each proof is valid, invalid, incomplete, stale, revoked or unknown. A proof is never permission -- partial, stale, revoked, simulated or confused proofs are never valid, revocation is measured rather than assumed, translations into OAuth, MCP, A2A and audit formats declare every field they drop, and trust domains exchange evidence without ever merging authority. 5 real action proofs and 41 published proof cases, 1,030 of 1,030 invariants hold, 2,141 of 2,141 attack scenarios are contained, the targeted mutation test kills 15 of 15 mutants, 0 of 19 injected faults made proof state more permissive, and the clean-room verifier passes 509 of 509 checks. Evolution 37 makes governance travel with the work: every governed action runs one twelve-stage chain on the real decision kernel and E8 commit boundary and leaves a signed receipt, and when an execution moves to another node, runtime, model, region or credential the move is itself governed -- authority can only shrink, a material change opens a new epoch, and risk, spent budget, revocations, evidence and incident history travel with it and can never be reset. A runtime is admitted on a measured code digest and live probes, never on its own claim, and nothing is scheduled where enforcement is missing. 71 signed execution receipts come from real governed runs, 1,132 of 1,132 invariants hold, 2,720 of 2,720 attack scenarios are contained, the targeted mutation test kills 17 of 17 mutants, 16 of 16 injected fault classes are contained with no false allows, a 100,000-agent scale run completes on one host, and the clean-room verifier passes 2,627 of 2,627 checks. Evolution 36 turns CAIN into a governed machine agency exchange: agents, tools, models and organizations are discovered, verified, negotiated with, contracted, hired and transacted with along one lifecycle, and the exchange never hands out authority. Governability-aware discovery never upgrades an unknown requirement into a match; a service chain proves identity, authority, contract, capability, execution, proof and settlement; a subcontractor can never be given more than its parent; payment authorizations are scoped, time-bound and non-replayable; a receipt requires a final E8 commit; and CAIN's own participation is governed so it can never grant itself authority or rewrite its history. Money in this layer stays synthetic: CAIN is not a bank, a custodian or a regulator. 842 of 842 invariants hold, 3340 of 3340 economic and governance attack scenarios across 64 categories are contained, 15 of 15 disabled defences are caught, a 13-step exchange lifecycle passes, and the clean-room verifier passes 3601 of 3601 checks. Evolution 35 adds a governance intelligence layer and keeps it out of the authorization path: it observes with provenance, scores risk across dimensions without ever collapsing into one number, predicts with explicit confidence, assumptions, horizon and unknowns, calibrates itself by dimension, explores counterfactuals that are never presented as facts, and recommends -- and a learned control is deployed only after a deterministic review and a canary, with the reviewed action still passing the kernel and E8, so learning can never create authority. 799 of 799 invariants hold, 3544 of 3544 attack scenarios across 68 categories are contained, the targeted mutation test kills 15 of 15 mutants, a 23-step loop passes, and the clean-room verifier passes 3810 of 3810 checks. Evolution 34 makes every governed action carry its own verifiable proof: one signed, chained governance proof binds who acted, the capability, the delegation and its attenuation, the authority, the policy, the evidence, the risk, the decision, the E8 commit, the enforcement boundary, the execution and the outcome, and states plainly what remains UNKNOWN or outside the boundary -- with fourteen statuses that never collapse into a score, per-layer proof primitives, an enforcement proof that separates a decision from an authorization, a commit, an enforcement, an execution and an observed outcome, and RFC 6962 selective disclosure; a proof is evidence, never permission. 629 of 629 invariants hold, 2664 of 2664 attack scenarios across 32 categories are contained, 12 of 12 disabled defences are caught, and the clean-room verifier passes 3286 of 3286 checks. Evolution 33 turns everything an agent does into one governed operation: calling a tool, sending a message, running code, creating a helper agent, changing its memory or paying all follow the same checked lifecycle, are committed at E8 and carry a signed proof, while changes to the rules themselves are handed to the process that governs them and never simply executed. An existing agent can be governed through a small sidecar without importing any CAIN code, and every request it sends must be signed. In a full-loop run, an action that got through under the old rules was refused the next time, after CAIN had learned and adopted a stricter rule with a human sign-off. 581 of 581 invariants hold, 2029 of 2029 attack scenarios across 26 categories are contained, and the clean-room verifier passes 2603 of 2603 checks. Evolution 32 lets CAIN learn from the actions it governs without ever giving itself more power: it watches where harm got through, proposes a stricter rule, tries it in an isolated sandbox and on a hidden test set it never saw, compares it on fifteen separate measures, and adopts it only with a signed human approval; a proposal that stops harm by refusing everything is rejected, and learning can only make the rules stricter. In a simulated run on a synthetic workload, harm that got through fell from 41 to 3 with no new wrongly refused actions. 303 of 303 invariants hold, 1013 of 1013 attack scenarios across 22 categories are contained, the mutation test catches 12 of 12 disabled defenses, and the clean-room verifier passes 1420 of 1420 checks. Evolution 31 makes governance provable: every allowed action can now produce a signed governance proof that ties that one action to who did it, the delegation and policy it ran under, the final E8 check that let it through and the record of it actually running, and every refused action produces a signed record of why it was refused. Anyone can re-check a proof against our published keys with verifiers that share none of our code, in Python and in TypeScript; each proof sits in an append-only log, and a proof is evidence only, never permission to act again. 252 of 252 invariants hold, 1269 of 1269 attack and conformance scenarios are contained, the mutation test catches 12 of 12 disabled defenses, every one of 88 deliberately forged proofs is rejected, and the clean-room verifier passes 1676 of 1676 checks. Evolution 30 joins the layers into one autonomy kernel: every consequential action an agent takes, from what it perceives and remembers through a transaction to a proposal to improve itself, goes through one path that checks its autonomy state, level, budget, containment and evidence before the E8 commit boundary, and leaves a signed receipt whether it was allowed or refused. An agent cannot raise its own autonomy level; a self-improvement needs a sandbox, an adversarial test, a canary and a human review; and a coverage map says plainly which paths CAIN does not control. 166 of 166 invariants hold, 889 of 889 scenarios across eight attack categories are contained, the mutation test catches 11 of 11 disabled defenses, and the receipts check out in a clean-room verifier (1187 of 1187 checks) and in a separate zero-dependency TypeScript verifier. Evolution 29 governs machine-to-machine transactions end to end: an autonomous procurement agent discovers vendors, checks their identity, tested capability and counterparty risk (thirteen dimensions, no single score), negotiates, signs a contract, is authorized for that one transaction by the intersection of its delegation, lease, a separately bounded spending authority, its organization's budget, the contract and the consequence forecast, locks funds in escrow, receives a governed delivery and releases payment only on a delivery receipt, the buyer's signed confirmation and an objective check. Money in it is synthetic test units, and it moves only through a sealed settlement step inside the E8 commit boundary. 106 of 106 invariants hold, 258 of 258 adversarial scenarios are contained, ten catastrophe scenarios on the real fabric end with 0 false allows, and the clean-room verifier passes 300 of 300 checks. Evolution 28 gives any agent that connects a signed, portable execution identity: it travels unchanged over 23 protocol carriers (MCP, A2A, HTTP, gRPC, CLI, browser and computer use among them), but its authority does not: every receiving domain recomputes it from its own policy, delegation shrinks on sixteen dimensions and can never flow back up, a change of model, runtime, prompt, tools, memory or key voids authority until it is re-evaluated, and every action is bound to one transaction, passes the E8 commit boundary and leaves a signed receipt in a hash chain, with identity events in an RFC 6962 transparency log. 90 of 90 invariants hold, 442 of 442 adversarial scenarios are contained, conformance passes 17 of 17 dimensions on real tests, and the clean-room verifier passes 243 of 243 checks; building it we found and closed a gap that let a child agent mint a delegation back to its parent. Evolution 27 is an agentic-internet control plane (registry, discovery, routing, policy distribution, contracts, incident propagation, edge nodes) that coordinates without becoming authority (1,533 of 1,533 adversarial scenarios contained, 341 specific to E27). Evolution 26 adds portable signed trust objects, a seventeen-dimension trust vector that never collapses into one score and authorizations that work for exactly one transaction (1,192 of 1,192 contained). Evolution 25 turns any consequential machine action into one signed transaction across eighteen protocol adapters, committed only through E8, with the agent never holding a raw secret (1,055 of 1,055 contained). All four are TESTED libraries, not hosted services, and none of them can give an agent more power. Earlier, 2026-09-28: the evolution gate is live: on the live gateway an agent can change its model or its MCP tools only through a signed proposal, an evaluator-signed test report and a human operator, and the old authority is void until the live cluster signs the new capability. 17 of 17 live cases behaved as specified across all three domains. Building it, we found that the governance state the cluster signs had not covered the MCP tool map, and fixed that. The public proof fabric is live: a signed claims registry, the 2026-09-28 6-suite test run (1,978 tests, 1,963 passed, 0 failed), a build manifest, an SBOM, test vectors, a signed evidence pack and a clean-room verifier. A sweep of all three sites withdrew 16 older files whose numbers no run had produced; each now says why, and the originals are kept. The system governor is on: unregistered systems and unsigned requests are refused; 13 of 13 live cases behaved as specified. Every registered claim, every limitation we have recorded and every run outcome stays published on the Proof page; release gates that are still open are listed in the Verification Center. No third party has verified any claim yet (0 independently verified), and the Proof page says so. Earlier generations (CAIN 1–41) stay published as history, not as the current system; the previous homepage is kept as it was on 2026-09-25, marked superseded, and the now page takes precedence over it. Evolution 7 (predictive consequence governance) and Evolution 8 (the mandatory governance kernel) are added as TESTED libraries, wired restriction-only into the CAIN-45 agent hypervisor: a governed world-state and digital-twin fabric whose predictions and uncertainty can only contract authority, and a signed, short-lived, action-bound governance token checked at an action-commit boundary before execution. Neither can grant authority, and neither is hosted yet; 12 and 22 machine-checkable invariants hold and 65 new tests pass. Evolution 9 adds a signed agent passport, an AgentBOM and a provenance graph for every governed agent: 15 more machine-checkable invariants hold and 46 more tests pass, memory can never mint authority, delegation can never increase authority, revocation propagates, and a material mutation invalidates the attestation and the bound governance token. Both new layers are TESTED libraries, not hosted services, and neither can grant authority. Evolution 10 governs agent collectives rather than individuals: 20 more invariants hold and 20 of 20 collective attacks are blocked, collective authority is an intersection of envelopes and never a sum, combination risk is evaluated before commitment, and a unanimous decision still carries no authority. It is a TESTED library, not an orchestration service. Evolution 11 governs the information channel: 20 more invariants hold and 20 of 20 message/intent attacks are blocked, a valid message signature proves who sent it but never what they may do, tool and MCP output stay data rather than policy, information never inherits the destination's trust, and taint survives derivation. It is a TESTED library, not a hosted service. Evolution 12 governs what an agent is allowed to believe: 20 more invariants hold and 32 of 32 evidence attacks are contained, a source whose identity cannot be established stays UNKNOWN, stale or expired evidence cannot authorize, corroboration counts independent principals rather than repeated agents, retrieved content stays data rather than policy, a valid hash proves bytes did not change but not that they are true, and reality drift forces re-evaluation. It is a TESTED library that governs what enters the trusted decision path; it does not claim to know everything; a system outside its boundary remains UNCONTROLLED, UNVERIFIED or UNKNOWN. Evolution 13 governs how a decision is formed: 24 more invariants hold and 36 of 36 decision attacks are contained, reasoning can propose but never authorize, authority can be narrowed but never expanded by argument, a policy conflict is never silently resolved, a material change marks the decision stale, a deny cannot be turned into an allow, and the governance token binds the decision, policy, authority and risk digests. It is a TESTED library that governs decision construction from recorded inputs and stores no private chain-of-thought; it does not claim that a model's reasoning is correct. Evolution 14 treats every capability as a power surface: tools, skills, plugins, connectors, models and subagents are identified by their artifact, admitted only with a publisher-signed provenance chain, granted only within the issuer's own authority, and used only under a short-lived signed lease that the commit boundary checks again, bound to the decision, policy, risk, sandbox and credential. 30 more invariants hold and 44 of 44 capability attacks are contained, among them artifact and dependency substitution, a malicious upgrade, a dangerous capability pair split across two agents, and a revocation racing a commit. Building it we found two Evolution 13 attack scenarios that had been counted as contained without being tested, and fixed both. It is a TESTED library wired into the agent hypervisor in front of MCPGate, not a hosted service; hardware attestation and vulnerability intelligence remain UNKNOWN. Evolution 15 establishes the interfaces and governance primitives for bringing spatial intelligence, world models, simulation, trajectories and physical actions into the same governed trust path: signed sensor observations enter through the evidence layer, the world state is versioned and replayable, a world model's output is a prediction rather than authority, a trajectory is a proposal until a signed approval binds it, and every physical action binds nine digests, crosses the governance kernel and reaches an actuator adapter only with a single-use permit. 36 more invariants hold and 55 of 55 spatial and physical attacks are contained, among them sensor spoofing, map substitution, trajectory replay, a world-state rollback and a swapped actuator command; digital, physical and hybrid agents run the same path. It is a TESTED library exercised against a reference robot adapter, not a vehicle or a robot: it drives nothing and does not guarantee physical safety, and real sensor and actuator integration is on the roadmap. Evolution 16 adds a temporal and causal dimension to that world state: events and intervals, typed causal and correlation relations that are never conflated, counterfactual branches that never become reality, a predictive state engine whose output is never authority, prediction-vs-reality calibration, and a causal blast radius. Evolution 17 governs action by autonomous agent teams as a first-class system object: collective authority is a constrained intersection and never a sum, consensus is not authorization, a world-state fork blocks authorization, dissent is preserved, and one action that fans out to many agents is pre-authorized; 61 of 61 invariants hold and 91 of 91 bench entries (88 distinct attacks) are contained; it is a TESTED library, not an orchestration service. Evolution 18 adds the actionable 4D world: entity state at (X,Y,Z,T) with uncollapsed uncertainty, reachable / permitted / authorized sets kept distinct, intent and trajectory hypotheses, an interaction graph and a conflict field, counterfactual futures, actionability, a conserved uncertainty budget, micro-authorization and a continuous re-authorization loop, for a car, a drone and a digital agent in one shared world; ACTIONABILITY IS NOT AUTHORIZATION, REACHABILITY IS NOT PERMISSION, PREDICTION IS NOT REALITY, and AUTHORIZATION IS A FUNCTION OF WORLD STATE. 89 of 89 invariants hold and 123 of 123 bench entries (109 distinct attacks, among them GNSS spoofing, map substitution, geofence mutation and a re-signed refusal) are contained. Our review before publication found that the E17 and E18 commit boundaries bound the policy, risk and authority verdicts without reading them, so a consistently re-signed refusal was authorized; both now enforce every verdict they bind, and each fix is pinned by a regression test written against the unfixed code (full record on the Proof page and in the changelog). Evolution 19 governs the evolving state of an autonomous system itself: identity, mission, goals, beliefs, memory, models, learning, authority, world, outcomes and recovery become hash-chained governed state, effective authority is compiled as the intersection of sixteen factors so it shrinks when conditions deteriorate and never grows because an agent is confident, agrees with its peers, learns or predicts success, autonomy is derived from evidence rather than requested, and every consequential action carries a sixteen-field action contract that is invalidated by any material state change and whose verdicts the gate enforces itself before the E8 kernel commits it. 108 of 108 invariants hold, 189 of 189 bench entries (177 distinct attacks) are contained, deliberately removing a defense is caught by the bench, and an independent verifier re-derives the evidence (117 of 117 checks). AUTONOMY IS NOT AUTHORITY. Evolution 20 governs agents that act together as teams, organizations and machine-native institutions: they may form, admit members, delegate, negotiate, sign contracts, hold and move resources, spawn subagents, federate, resolve disputes, evolve and dissolve, and none of it can manufacture authority. Institutional authority is always an intersection and never a sum; membership, votes, consensus, reputation, trust, wealth, market wins, rewards and model capability are not inputs to it; a contract or a negotiated agreement authorizes nothing by itself; a spawned subagent inherits only what is explicitly permitted in each of seven dimensions; a terminated agent or dissolved institution cannot come back through stale state; and every institutional action still passes the E19 action contract and the E8 kernel. 118 of 118 invariants hold, 334 of 334 bench entries (328 distinct attacks, among them Sybil institutions, constitutional takeover, contract laundering, double spending, spawning explosions and agent resurrection) are contained, an end-to-end run from one agent to a two-institution economy detects and contains 7 hostile events and then recovers and keeps working, deliberately removing a defense is caught by the bench, and an independent verifier re-derives the evidence (179 of 179 checks). Every economy in it is a simulation over abstract units: it moves no money. COLLECTIVE INTELLIGENCE IS NOT INSTITUTIONAL AUTHORITY. Evolution 21 governs autonomous research itself: asking questions, keeping competing hypotheses alive, designing and running experiments and simulations, replicating, peer-reviewing, attacking its own conclusions, building versioned knowledge, proposing new capabilities, models and strategies, and creating specialised research agents. What the research is allowed to believe is computed from signed evidence whose type (simulation, experiment, real-world observation, independent replication, third-party reproduction) cannot be relabelled, and a hundred runs of the same setup or a hundred agents under one controller count as one source. Research authority and execution authority are separate: a discovery, a confidence score, a reviewer vote, a benchmark win or a research reward never widens what an agent may do. A new capability leaves quarantine only after validation, an independent adversary, a security review and a governance quorum that excludes the researchers, and even then every action still passes E20, the E19 action contract and the E8 kernel. When evidence collapses, the dependent knowledge, policies and capabilities are invalidated with it and execution stops. Unsuccessful experiments are kept as evidence. 155 of 155 invariants hold; 298 of 298 bench entries (290 distinct attacks) are contained; a governed research lab solves a synthetic problem end to end in 17 stages and refuses all 16 attempts to authorize itself along the way; and an independent verifier re-derives the evidence (218 of 218 checks) and catches all 16 deliberate tamperings. Can a system that discovers a governance loophole use that discovery to get permission to exploit it? The bench's answer is NO: it can only disclose it. Building it we found and fixed four defects in our own new code before publication, among them a contradiction that a later supporting result could mask and a researcher who could review their own work once their evidence had expired. E21 checks how evidence was produced, not whether a hypothesis is true, and the research problem is synthetic. DISCOVERY IS NOT TRUTH, AND INTELLIGENCE IS NOT AUTHORITY. Evolution 22 (a governed cognitive runtime) was started and is not built or published yet. Evolution 23 governs AI systems that reason about and redesign their own architecture: a redesign is only a proposal; it is checked against the governance rules, measured on twelve separate governability scores before any capability gain counts, attacked by a separate red team, verified by a separate evaluator, tried in shadow, and promoted only with a governance quorum that excludes the system itself, a human sign-off and an E8 commit, so a smarter but less governable design is rejected. 253 of 253 invariants hold, 545 of 545 adversarial scenarios across 80 attack families are contained, among them a system that finds a governance loophole and asks to use it, and the clean-room verifier reports INTACT (733 of 733 checks). SELF-IMPROVEMENT IS NOT SELF-AUTHORIZATION. Evolution 24 governs agents that belong to different organizations and trust domains as they discover each other, negotiate, sign contracts, delegate work, pay in simulated units and act over thirteen protocol classes, among them A2A, MCP, HTTP and computer use: authority across organizations is the intersection of ten factors, discovery, contracts, reputation and payment are never among them, unknown trust stays unknown, and a compromised agent is detected, quarantined and revoked while the other organizations keep working. 305 of 305 invariants hold, 756 of 756 adversarial scenarios across 68 attack families are contained, a controlled simulation of 10,000 agents and 100,000 messages shows 0 cases of authority leakage, and the clean-room verifier reports INTACT (1,952 of 1,952 checks). E16–E21, E23 and E24 are TESTED libraries; they are not hosted, they contain no autonomous-driving model, flight controller, vehicle controller, robot policy or navigation stack, and they drive nothing. The governance data plane, 2026-09-29: the quorum now commits authority once per window instead of once per call. A 4-replica PBFT quorum commits a short-lived authorization snapshot, the gateway verifies the commit certificate itself, and a covered call is checked locally, so against the live cluster cain-mr-01 on 2026-09-29 the consensus step went from a per-call PBFT round (p50 2,268.6 ms, p99 3,937.8 ms, n=20) to the snapshot-covered stage (p50 0.8263 ms, p99 3.4686 ms, n=1,000), on a 2-CPU host against a throwaway gateway database (run record dataplane-evolution-2026-09-29/governance/live_run.json). Every covered decision is still anchored into a quorum-committed Merkle root, and revocation takes effect on the next call without a quorum round. Any miss falls back to the per-call round, which fails closed. It is built and live-tested and is available behind a flag. The PII redactor gained a span pipeline 1.1–1.43 times faster from 1 KB to 10 MB with no loss of recall; building it we found and fixed a leak where a card number next to a phone number went unredacted while the report said fully redacted. 9 of 15 production gates pass, and the A+++ verdict is BLOCKED: eBPF enforcement cannot run on this host yet, there is no soak or network fault injection for the new path, and the desktop IPC layer does not exist. Each blocker is published with its evidence in the A+++ evidence bundle. Evolution 16 of 42 (Project Sovereign Frontier, 2026-10-12) makes a governed agent mission durable: every request and decision is written to a signed journal before it takes effect, authority is re-checked at the moment a tool is called, and an action whose outcome is unknown after a timeout or crash is never repeated until an independent observer signs what happened. A crash after every journal entry of a complete mission recovered 71 of 71 times with 0 duplicate writes; 0 of 690 fault and attack scenarios ended badly, against 330 of 420 comparable cases for the previous code; 25 of 25 removed safety checks were caught; and 16,104 exhaustively enumerated event sequences broke no invariant. A stand-alone verifier with no CAIN code checks the journal (570 of 570 verdicts as expected) and is published with a sample mission at cainstudio.online/proof/bundle/sovereign-frontier-evolution16-2026-10-12/. It is a TESTED library in a local simulator, available as a library, and durability costs speed (5.0007 ms per decision against 0.1771 ms in memory). Evolution 18 of 42 (Project Sovereign Reality, 2026-10-12) checks what an agent’s action actually did, not what the agent says it did: two observer processes that are neither the agent nor the enforcer, each with its own signing key and its own method, watch every governed file action; each effect is graded from unavailable to independently corroborated, and a missing observation is never read as “nothing happened”; the approver signs the exact file, not just its path, and the action runs through descriptors pinned to that file, so a swapped file or planted link cannot redirect it. 82 of 82 adversarial scenarios ran against real files and held (39 attacks prevented, 38 detected, 3 honest actions verified, 2 documented limits shown), and 26 of 26 weakened security checks were caught. A stand-alone verifier with no CAIN code re-derives every verdict and is published with sample receipts at cainstudio.online/proof/bundle/sovereign-reality-evolution18-2026-10-12/. It observes file effects under one folder on one host (not network or child processes), its observers share the host kernel, and it is on the live server but not yet called by live requests; a fully observed action costs 10.592 ms at the median.

    Verifier Room — verify CAIN-42 yourself, in seconds

    You do not have to trust us or contact us. Every evidence bundle below ships a clean-room verifier that imports none of CAIN-42's code. Copy one block into a terminal on your own computer: it downloads that bundle and its verifiers, and runs two chained checks. verify_publisher.py must print PUBLISHED_BY_PINNED_KEY: the bytes are exactly what the CAIN publisher key signed, so an edited or re-signed bundle fails. Only then does the bundle's own verifier run, and it must print "result": "INTACT": its internal hashes and signatures agree. The block ends with one line, VERIFIED or NOT VERIFIED. Do not run the bundle verifier on its own. Nothing on these sites is needed after the download.

    Requires Python 3 and internet. The verifiers read published data only; they never touch the live service and never call our servers for a verdict. A changed byte in any bundle file makes the verifier report BROKEN. INTACT alone means only that the bundle agrees with the key shipped inside it, which anyone who re-signs a bundle can arrange. That is why every block also runs verify_publisher.py (verifier, pinned key at /.well-known/cain-publisher-key.json): it refuses an edited, added, removed or re-signed file. The publisher key is ours, so neither check is independent verification.

    Sovereign Trial · sovereign-trial-2026-10-09

    — published result: INTACT (182/182 checks)

    mkdir -p sovereign-trial-2026-10-09 && cd sovereign-trial-2026-10-09
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3: raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/sovereign-trial-2026-10-09/"
    get(E + "verify.py", "verify.py")
    get(E + "trial_evidence_bundle.json", "trial_evidence_bundle.json")
    PY
    python3 verify.py trial-bundle trial_evidence_bundle.json \
      && echo "VERIFIED: clean-room trial evidence bundle is internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    BFTIP · bft-ip-forensics-2026-10-05

    — published result: INTACT (58/59 checks)

    mkdir -p bft-ip-forensics-2026-10-05 && cd bft-ip-forensics-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/bft-ip-forensics-2026-10-05.json", "../bft-ip-forensics-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../bft-ip-forensics-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "bft-ip-forensics-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "bft-ip-forensics-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../bft-ip-forensics-2026-10-05 ../bft-ip-forensics-2026-10-05.attestation.json \
      && python3 verify_bftip.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E38 · e38-byzantine-mission-integrity-2026-10-05

    — published result: INTACT (127/127 checks)

    mkdir -p e38-byzantine-mission-integrity-2026-10-05 && cd e38-byzantine-mission-integrity-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e38-byzantine-mission-integrity-2026-10-05.json", "../e38-byzantine-mission-integrity-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e38-byzantine-mission-integrity-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e38-byzantine-mission-integrity-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e38-byzantine-mission-integrity-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e38-byzantine-mission-integrity-2026-10-05 ../e38-byzantine-mission-integrity-2026-10-05.attestation.json \
      && python3 verify_e38.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E37 · e37-byzantine-autonomous-federation-2026-10-05

    30/30 invariants · 30/30 scenarios held — published result: INTACT (70/70 checks)

    mkdir -p e37-byzantine-autonomous-federation-2026-10-05 && cd e37-byzantine-autonomous-federation-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e37-byzantine-autonomous-federation-2026-10-05.json", "../e37-byzantine-autonomous-federation-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e37-byzantine-autonomous-federation-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e37-byzantine-autonomous-federation-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e37-byzantine-autonomous-federation-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e37-byzantine-autonomous-federation-2026-10-05 ../e37-byzantine-autonomous-federation-2026-10-05.attestation.json \
      && python3 verify_e37.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E36 · e36-byzantine-collective-governance-2026-10-05

    23/30 invariants · 30/30 scenarios held — published result: INTACT (69/76 checks)

    mkdir -p e36-byzantine-collective-governance-2026-10-05 && cd e36-byzantine-collective-governance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e36-byzantine-collective-governance-2026-10-05.json", "../e36-byzantine-collective-governance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e36-byzantine-collective-governance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e36-byzantine-collective-governance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e36-byzantine-collective-governance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e36-byzantine-collective-governance-2026-10-05 ../e36-byzantine-collective-governance-2026-10-05.attestation.json \
      && python3 verify_e36.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E35 · e35-continuous-autonomy-integrity-2026-10-05

    27/30 invariants · 30/30 scenarios held — published result: INTACT (108/111 checks)

    mkdir -p e35-continuous-autonomy-integrity-2026-10-05 && cd e35-continuous-autonomy-integrity-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e35-continuous-autonomy-integrity-2026-10-05.json", "../e35-continuous-autonomy-integrity-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e35-continuous-autonomy-integrity-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e35-continuous-autonomy-integrity-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e35-continuous-autonomy-integrity-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e35-continuous-autonomy-integrity-2026-10-05 ../e35-continuous-autonomy-integrity-2026-10-05.attestation.json \
      && python3 verify_e35.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E34 · e34-decision-provenance-2026-10-05

    0/0 invariants · 0/0 scenarios held — published result: PARTIAL (0/0 checks)

    mkdir -p e34-decision-provenance-2026-10-05 && cd e34-decision-provenance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e34-decision-provenance-2026-10-05.json", "../e34-decision-provenance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e34-decision-provenance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e34-decision-provenance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e34-decision-provenance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e34-decision-provenance-2026-10-05 ../e34-decision-provenance-2026-10-05.attestation.json \
      && python3 verify_e34.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E32 · e32-global-trust-settlement-2026-10-05

    mkdir -p e32-global-trust-settlement-2026-10-05 && cd e32-global-trust-settlement-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e32-global-trust-settlement-2026-10-05.json", "../e32-global-trust-settlement-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e32-global-trust-settlement-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e32-global-trust-settlement-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e32-global-trust-settlement-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e32-global-trust-settlement-2026-10-05 ../e32-global-trust-settlement-2026-10-05.attestation.json \
      && python3 verify_e32.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E31 · e31-governance-proof-fabric-2026-10-05

    mkdir -p e31-governance-proof-fabric-2026-10-05 && cd e31-governance-proof-fabric-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e31-governance-proof-fabric-2026-10-05.json", "../e31-governance-proof-fabric-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e31-governance-proof-fabric-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e31-governance-proof-fabric-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e31-governance-proof-fabric-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e31-governance-proof-fabric-2026-10-05 ../e31-governance-proof-fabric-2026-10-05.attestation.json \
      && python3 verify_e31.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E30 · e30-governance-network-2026-10-05

    mkdir -p e30-governance-network-2026-10-05 && cd e30-governance-network-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e30-governance-network-2026-10-05.json", "../e30-governance-network-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e30-governance-network-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e30-governance-network-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e30-governance-network-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e30-governance-network-2026-10-05 ../e30-governance-network-2026-10-05.attestation.json \
      && python3 verify_e30.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E28 · e28-catcp-ip-commercial-2026-10-05

    mkdir -p e28-catcp-ip-commercial-2026-10-05 && cd e28-catcp-ip-commercial-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e28-catcp-ip-commercial-2026-10-05.json", "../e28-catcp-ip-commercial-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e28-catcp-ip-commercial-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e28-catcp-ip-commercial-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e28-catcp-ip-commercial-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e28-catcp-ip-commercial-2026-10-05 ../e28-catcp-ip-commercial-2026-10-05.attestation.json \
      && python3 verify_e28.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E27 · e27-catcp-control-2026-10-05

    mkdir -p e27-catcp-control-2026-10-05 && cd e27-catcp-control-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e27-catcp-control-2026-10-05.json", "../e27-catcp-control-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e27-catcp-control-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e27-catcp-control-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e27-catcp-control-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e27-catcp-control-2026-10-05 ../e27-catcp-control-2026-10-05.attestation.json \
      && python3 verify_e27.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E26 · e26-byzantine-trust-2026-10-05

    mkdir -p e26-byzantine-trust-2026-10-05 && cd e26-byzantine-trust-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e26-byzantine-trust-2026-10-05.json", "../e26-byzantine-trust-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e26-byzantine-trust-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e26-byzantine-trust-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e26-byzantine-trust-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e26-byzantine-trust-2026-10-05 ../e26-byzantine-trust-2026-10-05.attestation.json \
      && python3 verify_e26.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E23 · e23-continuous-assurance-2026-10-05

    mkdir -p e23-continuous-assurance-2026-10-05 && cd e23-continuous-assurance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e23-continuous-assurance-2026-10-05.json", "../e23-continuous-assurance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e23-continuous-assurance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e23-continuous-assurance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e23-continuous-assurance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e23-continuous-assurance-2026-10-05 ../e23-continuous-assurance-2026-10-05.attestation.json \
      && python3 verify_e23.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E22 · e22-byzantine-global-verification-2026-10-05

    mkdir -p e22-byzantine-global-verification-2026-10-05 && cd e22-byzantine-global-verification-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e22-byzantine-global-verification-2026-10-05.json", "../e22-byzantine-global-verification-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e22-byzantine-global-verification-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e22-byzantine-global-verification-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e22-byzantine-global-verification-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e22-byzantine-global-verification-2026-10-05 ../e22-byzantine-global-verification-2026-10-05.attestation.json \
      && python3 verify_e22.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E21 · e21-byzantine-economic-coordination-2026-10-05

    mkdir -p e21-byzantine-economic-coordination-2026-10-05 && cd e21-byzantine-economic-coordination-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e21-byzantine-economic-coordination-2026-10-05.json", "../e21-byzantine-economic-coordination-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e21-byzantine-economic-coordination-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e21-byzantine-economic-coordination-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e21-byzantine-economic-coordination-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e21-byzantine-economic-coordination-2026-10-05 ../e21-byzantine-economic-coordination-2026-10-05.attestation.json \
      && python3 verify_e21.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E18 · e18-byzantine-counterfactual-governance-2026-10-05

    — published result: VALID (31/31 checks)

    mkdir -p e18-byzantine-counterfactual-governance-2026-10-05 && cd e18-byzantine-counterfactual-governance-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e18-byzantine-counterfactual-governance-2026-10-05.json", "../e18-byzantine-counterfactual-governance-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e18-byzantine-counterfactual-governance-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e18-byzantine-counterfactual-governance-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e18-byzantine-counterfactual-governance-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e18-byzantine-counterfactual-governance-2026-10-05 ../e18-byzantine-counterfactual-governance-2026-10-05.attestation.json \
      && python3 verify_e18.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E13 · e13-bpf-governance-execution-2026-10-05

    — published result: INTACT (24/24 checks)

    mkdir -p e13-bpf-governance-execution-2026-10-05 && cd e13-bpf-governance-execution-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e13-bpf-governance-execution-2026-10-05.json", "../e13-bpf-governance-execution-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e13-bpf-governance-execution-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e13-bpf-governance-execution-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e13-bpf-governance-execution-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e13-bpf-governance-execution-2026-10-05 ../e13-bpf-governance-execution-2026-10-05.attestation.json \
      && python3 verify_e13.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E12 · e12-trust-network-state-2026-10-05

    — published result: INTACT (20/20 checks)

    mkdir -p e12-trust-network-state-2026-10-05 && cd e12-trust-network-state-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e12-trust-network-state-2026-10-05.json", "../e12-trust-network-state-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e12-trust-network-state-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e12-trust-network-state-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e12-trust-network-state-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e12-trust-network-state-2026-10-05 ../e12-trust-network-state-2026-10-05.attestation.json \
      && python3 verify_e12.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E11 · e11-governance-proof-2026-10-05

    — published result: INTACT (32/32 checks)

    mkdir -p e11-governance-proof-2026-10-05 && cd e11-governance-proof-2026-10-05
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e11-governance-proof-2026-10-05.json", "../e11-governance-proof-2026-10-05.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e11-governance-proof-2026-10-05.attestation.json"))["files"])
    for f in names:
        get(E + "e11-governance-proof-2026-10-05/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e11-governance-proof-2026-10-05/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e11-governance-proof-2026-10-05 ../e11-governance-proof-2026-10-05.attestation.json \
      && python3 verify_e11.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E42 · e42-supreme-governed-agentic-infrastructure-2026-10-01

    — published result: INTACT (1460/1460 checks)

    mkdir -p e42-supreme-governed-agentic-infrastructure-2026-10-01 && cd e42-supreme-governed-agentic-infrastructure-2026-10-01
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e42-supreme-governed-agentic-infrastructure-2026-10-01.json", "../e42-supreme-governed-agentic-infrastructure-2026-10-01.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e42-supreme-governed-agentic-infrastructure-2026-10-01.attestation.json"))["files"])
    for f in names:
        get(E + "e42-supreme-governed-agentic-infrastructure-2026-10-01/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e42-supreme-governed-agentic-infrastructure-2026-10-01/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e42-supreme-governed-agentic-infrastructure-2026-10-01 ../e42-supreme-governed-agentic-infrastructure-2026-10-01.attestation.json \
      && python3 verify_e42.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E41 · e41-machine-agency-exchange-2026-09-30

    — published result: INTACT (1303/1303 checks)

    mkdir -p e41-machine-agency-exchange-2026-09-30 && cd e41-machine-agency-exchange-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e41-machine-agency-exchange-2026-09-30.json", "../e41-machine-agency-exchange-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e41-machine-agency-exchange-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e41-machine-agency-exchange-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e41-machine-agency-exchange-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e41-machine-agency-exchange-2026-09-30 ../e41-machine-agency-exchange-2026-09-30.attestation.json \
      && python3 verify_e41.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E40 · e40-autonomous-enterprise-intelligence-2026-09-30

    — published result: INTACT (1518/1518 checks)

    mkdir -p e40-autonomous-enterprise-intelligence-2026-09-30 && cd e40-autonomous-enterprise-intelligence-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e40-autonomous-enterprise-intelligence-2026-09-30.json", "../e40-autonomous-enterprise-intelligence-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e40-autonomous-enterprise-intelligence-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e40-autonomous-enterprise-intelligence-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e40-autonomous-enterprise-intelligence-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e40-autonomous-enterprise-intelligence-2026-09-30 ../e40-autonomous-enterprise-intelligence-2026-09-30.attestation.json \
      && python3 verify_e40.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E37 · e37-autonomous-execution-mesh-2026-09-30

    1132/1132 invariants · 2720/2720 scenarios held — published result: INTACT (2627/2627 checks)

    mkdir -p e37-autonomous-execution-mesh-2026-09-30 && cd e37-autonomous-execution-mesh-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e37-autonomous-execution-mesh-2026-09-30.json", "../e37-autonomous-execution-mesh-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e37-autonomous-execution-mesh-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e37-autonomous-execution-mesh-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e37-autonomous-execution-mesh-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e37-autonomous-execution-mesh-2026-09-30 ../e37-autonomous-execution-mesh-2026-09-30.attestation.json \
      && python3 verify_e37.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E36 · e36-machine-agency-exchange-2026-09-30

    842/842 invariants · 3340/3340 scenarios held — published result: INTACT (3601/3601 checks)

    mkdir -p e36-machine-agency-exchange-2026-09-30 && cd e36-machine-agency-exchange-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e36-machine-agency-exchange-2026-09-30.json", "../e36-machine-agency-exchange-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e36-machine-agency-exchange-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e36-machine-agency-exchange-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e36-machine-agency-exchange-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e36-machine-agency-exchange-2026-09-30 ../e36-machine-agency-exchange-2026-09-30.attestation.json \
      && python3 verify_e36.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E35 · e35-governance-intelligence-2026-09-30

    799/799 invariants · 3544/3544 scenarios held — published result: INTACT (3810/3810 checks)

    mkdir -p e35-governance-intelligence-2026-09-30 && cd e35-governance-intelligence-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e35-governance-intelligence-2026-09-30.json", "../e35-governance-intelligence-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e35-governance-intelligence-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e35-governance-intelligence-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e35-governance-intelligence-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e35-governance-intelligence-2026-09-30 ../e35-governance-intelligence-2026-09-30.attestation.json \
      && python3 verify_e35.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E34 · e34-proof-carrying-machine-agency-2026-09-30

    629/629 invariants · 2664/2664 scenarios held — published result: INTACT (3286/3286 checks)

    mkdir -p e34-proof-carrying-machine-agency-2026-09-30 && cd e34-proof-carrying-machine-agency-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e34-proof-carrying-machine-agency-2026-09-30.json", "../e34-proof-carrying-machine-agency-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e34-proof-carrying-machine-agency-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e34-proof-carrying-machine-agency-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e34-proof-carrying-machine-agency-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e34-proof-carrying-machine-agency-2026-09-30 ../e34-proof-carrying-machine-agency-2026-09-30.attestation.json \
      && python3 verify_e34.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E33 · e33-governed-agentic-operating-fabric-2026-09-30

    581/581 invariants · 2029/2029 scenarios held — published result: INTACT (2603/2603 checks)

    mkdir -p e33-governed-agentic-operating-fabric-2026-09-30 && cd e33-governed-agentic-operating-fabric-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e33-governed-agentic-operating-fabric-2026-09-30.json", "../e33-governed-agentic-operating-fabric-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e33-governed-agentic-operating-fabric-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e33-governed-agentic-operating-fabric-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e33-governed-agentic-operating-fabric-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e33-governed-agentic-operating-fabric-2026-09-30 ../e33-governed-agentic-operating-fabric-2026-09-30.attestation.json \
      && python3 verify_e33.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E32 · e32-governed-autonomy-learning-2026-09-30

    — published result: INTACT (1420/1420 checks)

    mkdir -p e32-governed-autonomy-learning-2026-09-30 && cd e32-governed-autonomy-learning-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e32-governed-autonomy-learning-2026-09-30.json", "../e32-governed-autonomy-learning-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e32-governed-autonomy-learning-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e32-governed-autonomy-learning-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e32-governed-autonomy-learning-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e32-governed-autonomy-learning-2026-09-30 ../e32-governed-autonomy-learning-2026-09-30.attestation.json \
      && python3 verify_e32.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E31 · e31-universal-proof-of-governance-2026-09-30

    — published result: INTACT (1676/1676 checks)

    mkdir -p e31-universal-proof-of-governance-2026-09-30 && cd e31-universal-proof-of-governance-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e31-universal-proof-of-governance-2026-09-30.json", "../e31-universal-proof-of-governance-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e31-universal-proof-of-governance-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e31-universal-proof-of-governance-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e31-universal-proof-of-governance-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e31-universal-proof-of-governance-2026-09-30 ../e31-universal-proof-of-governance-2026-09-30.attestation.json \
      && python3 verify_e31.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E30 · e30-governed-machine-autonomy-2026-09-30

    — published result: INTACT (1187/1187 checks)

    mkdir -p e30-governed-machine-autonomy-2026-09-30 && cd e30-governed-machine-autonomy-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e30-governed-machine-autonomy-2026-09-30.json", "../e30-governed-machine-autonomy-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e30-governed-machine-autonomy-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e30-governed-machine-autonomy-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e30-governed-machine-autonomy-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e30-governed-machine-autonomy-2026-09-30 ../e30-governed-machine-autonomy-2026-09-30.attestation.json \
      && python3 verify_e30.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E29 · e29-machine-transaction-fabric-2026-09-30

    — published result: INTACT (300/300 checks)

    mkdir -p e29-machine-transaction-fabric-2026-09-30 && cd e29-machine-transaction-fabric-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e29-machine-transaction-fabric-2026-09-30.json", "../e29-machine-transaction-fabric-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e29-machine-transaction-fabric-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e29-machine-transaction-fabric-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e29-machine-transaction-fabric-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e29-machine-transaction-fabric-2026-09-30 ../e29-machine-transaction-fabric-2026-09-30.attestation.json \
      && python3 verify_e29.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E28 · e28-portable-execution-identity-2026-09-30

    — published result: INTACT (243/243 checks)

    mkdir -p e28-portable-execution-identity-2026-09-30 && cd e28-portable-execution-identity-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e28-portable-execution-identity-2026-09-30.json", "../e28-portable-execution-identity-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e28-portable-execution-identity-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e28-portable-execution-identity-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e28-portable-execution-identity-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e28-portable-execution-identity-2026-09-30 ../e28-portable-execution-identity-2026-09-30.attestation.json \
      && python3 verify_e28.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E27 · e27-agentic-internet-control-plane-2026-09-30

    — published result: INTACT (4001/4001 checks)

    mkdir -p e27-agentic-internet-control-plane-2026-09-30 && cd e27-agentic-internet-control-plane-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e27-agentic-internet-control-plane-2026-09-30.json", "../e27-agentic-internet-control-plane-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e27-agentic-internet-control-plane-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e27-agentic-internet-control-plane-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e27-agentic-internet-control-plane-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e27-agentic-internet-control-plane-2026-09-30 ../e27-agentic-internet-control-plane-2026-09-30.attestation.json \
      && python3 verify_e27.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E26 · e26-universal-machine-agency-trust-2026-09-30

    — published result: INTACT (3115/3115 checks)

    mkdir -p e26-universal-machine-agency-trust-2026-09-30 && cd e26-universal-machine-agency-trust-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e26-universal-machine-agency-trust-2026-09-30.json", "../e26-universal-machine-agency-trust-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e26-universal-machine-agency-trust-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e26-universal-machine-agency-trust-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e26-universal-machine-agency-trust-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e26-universal-machine-agency-trust-2026-09-30 ../e26-universal-machine-agency-trust-2026-09-30.attestation.json \
      && python3 verify_e26.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E25 · e25-universal-machine-agency-2026-09-30

    — published result: INTACT (2977/2977 checks)

    mkdir -p e25-universal-machine-agency-2026-09-30 && cd e25-universal-machine-agency-2026-09-30
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e25-universal-machine-agency-2026-09-30.json", "../e25-universal-machine-agency-2026-09-30.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e25-universal-machine-agency-2026-09-30.attestation.json"))["files"])
    for f in names:
        get(E + "e25-universal-machine-agency-2026-09-30/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e25-universal-machine-agency-2026-09-30/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e25-universal-machine-agency-2026-09-30 ../e25-universal-machine-agency-2026-09-30.attestation.json \
      && python3 verify_e25.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E24 · e24-governed-agentic-internet-2026-09-29

    — published result: INTACT (1952/1952 checks)

    mkdir -p e24-governed-agentic-internet-2026-09-29 && cd e24-governed-agentic-internet-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e24-governed-agentic-internet-2026-09-29.json", "../e24-governed-agentic-internet-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e24-governed-agentic-internet-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e24-governed-agentic-internet-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e24-governed-agentic-internet-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e24-governed-agentic-internet-2026-09-29 ../e24-governed-agentic-internet-2026-09-29.attestation.json \
      && python3 verify_e24.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E23 · e23-governed-meta-intelligence-2026-09-29

    — published result: INTACT (733/733 checks)

    mkdir -p e23-governed-meta-intelligence-2026-09-29 && cd e23-governed-meta-intelligence-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e23-governed-meta-intelligence-2026-09-29.json", "../e23-governed-meta-intelligence-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e23-governed-meta-intelligence-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e23-governed-meta-intelligence-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e23-governed-meta-intelligence-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e23-governed-meta-intelligence-2026-09-29 ../e23-governed-meta-intelligence-2026-09-29.attestation.json \
      && python3 verify_e23.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E21 · e21-open-ended-intelligence-2026-09-29

    — published result: INTACT (218/218 checks)

    mkdir -p e21-open-ended-intelligence-2026-09-29 && cd e21-open-ended-intelligence-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e21-open-ended-intelligence-2026-09-29.json", "../e21-open-ended-intelligence-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e21-open-ended-intelligence-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e21-open-ended-intelligence-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e21-open-ended-intelligence-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e21-open-ended-intelligence-2026-09-29 ../e21-open-ended-intelligence-2026-09-29.attestation.json \
      && python3 verify_e21.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E20 · e20-agentic-institutions-2026-09-29

    — published result: INTACT (179/179 checks)

    mkdir -p e20-agentic-institutions-2026-09-29 && cd e20-agentic-institutions-2026-09-29
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e20-agentic-institutions-2026-09-29.json", "../e20-agentic-institutions-2026-09-29.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e20-agentic-institutions-2026-09-29.attestation.json"))["files"])
    for f in names:
        get(E + "e20-agentic-institutions-2026-09-29/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e20-agentic-institutions-2026-09-29/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e20-agentic-institutions-2026-09-29 ../e20-agentic-institutions-2026-09-29.attestation.json \
      && python3 verify_e20.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    E19 · e19-governed-autonomy-2026-09-28

    — published result: INTACT (117/117 checks)

    mkdir -p e19-governed-autonomy-2026-09-28 && cd e19-governed-autonomy-2026-09-28
    python3 - <<'PY'
    import json, time, urllib.request
    def get(url, dest):  # retries: a busy host can drop a request
        for i in range(4):
            try:
                return urllib.request.urlretrieve(url, dest)
            except Exception:
                if i == 3:
                    raise
                time.sleep(2 * (i + 1))
    E = "/proof/bundle/"
    # The publisher attestation lists every published file and is signed by the pinned CAIN key.
    get(E + "_publisher/e19-governed-autonomy-2026-09-28.json", "../e19-governed-autonomy-2026-09-28.attestation.json")
    get(E + "_publisher/verify_publisher.py.txt", "../verify_publisher.py")
    names = sorted(json.load(open("../e19-governed-autonomy-2026-09-28.attestation.json"))["files"])
    for f in names:
        get(E + "e19-governed-autonomy-2026-09-28/" + f, f)
    try:  # served pages are not attested (site chrome is injected), but some verifiers check index.html
        urllib.request.urlretrieve(E + "e19-governed-autonomy-2026-09-28/index.html", "index.html")
    except Exception:
        pass
    print("downloaded the bundle:", len(names), "files")
    PY
    python3 -m pip install --quiet cryptography 2>/dev/null || true
    python3 ../verify_publisher.py ../e19-governed-autonomy-2026-09-28 ../e19-governed-autonomy-2026-09-28.attestation.json \
      && python3 verify_e19.py.txt . \
      && echo "VERIFIED: published by the pinned CAIN key, and internally INTACT" \
      || { echo "NOT VERIFIED: do not trust this bundle"; false; }

    Newest published bundle: bft-ip-forensics-2026-10-05. Every bundle is also mirrored on the other two sites so the same verifier runs against an independent copy.

    External grading package (reviewer entry point)

    🛡️ CAIN-42 INDEPENDENT VERIFICATION CENTER 🛑 RELEASE STATUS: RELEASE_GATE_BLOCKED (GATE-2 & GATE-6 BLOCKED) 🔏 AUDITOR KIT 8.3.2: AUDITOR_KIT_RELEASE_READY 📊 10-DIM GATE: LOCAL PASS (348) · KERNEL PARTIAL · PROD BLOCKED

    CAIN-42 Independent Verification Center

    “Don't take our word for it. Inspect the evidence, reproduce the checks, challenge the claims, and report your findings.”

    Check what the CAIN-42 developer publishes on your own machine, with no account and no network access after download. The standalone verifier (Python standard library only) runs 56 offline integrity checks in a few seconds: the release signature, every file hash, the evidence records, a sample 4-replica PBFT quorum certificate, 313 signed hourly cluster proofs, and a recomputation of the PBFT fault campaign from its 2,800 raw trial records. It checks published evidence. It does not include the source code (the repository is private), and it is not a security audit.

    IHVRK · Independent Human Verification Resource Kit

    The IHVRK is the part of CAIN-42 that keeps a human in charge. It holds a high-impact agent action until an enrolled human verifier approves that exact action, lets the approved action run once, and records every step in a tamper-evident ledger. The download bundle puts the evidence for that in your hands: 32 files (about 103 KB) with the test, formal-model and mutation results, the threat model, the residual risks, and a stand-alone verifier you can run with the network switched off.

    The bundle (version 7.0.0) records all 916 tests passing, 22 of 22 formal properties holding in their models, and 85 mutants killed with 4 judged equivalent. Those are the developer's recorded results; the verifier checks that the bundle is intact and self-consistent, it does not re-run them. The bundle is integrity-checked by SHA-256 and is not signed. The IHVRK is a library and reference gate: it is not yet wired into the live CAIN gateway or MCPGate, and it has had no third-party review.

    ⬇ Download the IHVRK bundle (.tar.gz) SHA-256 · seal record

    Read everything about it: IHVRK evidence page · overview · architecture · threat model · one-minute auditor quickstart · limitations · bundle final report · all documents

    Two lines in a terminal (Linux, macOS, Windows WSL): the first downloads the verifier and the kit, the second checks them offline. Needs curl and Python 3.

    curl -fsSLO "https://cainstudio.online/evidence/auditor-kit/8.3.2/{cain42_verify.py,cain42-auditor-kit-8.3.2.zip}" && python3 -I cain42_verify.py cain42-auditor-kit-8.3.2.zip --human --trust-anchor XhK+pwJlsTymjoA8rnJBiGP344rTKK1qD5xTtbkbZlY= --expect-sha256 3e70be5e6f5784aea63c3eaf33dbe161479222f1758fb95de0e82e6cd582c85d

    Expected last line: VERDICT: PASS_INTEGRITY (exit 0) until the evidence snapshot ages out on 2026-10-25 (then STALE_EVIDENCE, exit 50, by design, until the next signed kit). No curl, or on Android Termux? The kit page has a longer one-paste command that installs Python and downloads without curl. The key and hash come from this site; confirm them out of band as KEYS_AND_TRUST.md explains.

    FIRME AI CORPORATION // SALES OFFICE // FOUNDER

    CAIN-42 SALES OFFICE

    > WELCOME, FOUNDER

    → PROOFLOOP leads: who to email today (operator key required; leads are never public)

    This is the founder's sales office. Fifteen governed agents scan the live internet every 15 minutes for buyers and paid work; every scan passes CAIN authority, a capability token and a host allowlist, and every run writes a hash-chained evidence receipt. The founder sends every message, runs every demo and signs every deliverable. 260 opportunities, 160 AI-agent money models, and 567 tools are on the floor.

    --:--:--
    —
    SHIFT: OFFLINE · NOW: —
    🎯 LEAD QUEUE
    KERNEL WAITING AGENTS 0/15 NEXT SCAN --:-- EVIDENCE — OPERATOR FOUNDER LAST DECISION —
    0h 00m
    50 h to go
    0h today
    $0
    this week
    paid, entered by you
    0
    emails sent
    weekly floor 100
    0
    usable tools
    0/0
    agenda
    –
    agents live
    0
    open gigs

    Today's agenda 10-hour day · built 8:00 a.m. PT

    Loading…

    Next best action the floor decides what pays next

    Can't decide? money wheel

    Scoreboard this week

    Hourly money dials drag to model the day

    Paid ledger every payment, logged

    In focus 3 at most

    KPI wall the whole floor in one glance

    Live pulse what you actually did

    Operating rules from the playbook

    • • Outreach happens before delivery every day.
    • • Never run more than three streams at once.
    • • A deliverable that fails its own verification is not delivered.
    • • Sell the artifact, not the vision: a reviewed MCP server, a signed report, a fixed defect, a working automation.
    • • Revenue requires a paying counterparty. Building is not selling.

    Keys: s shift · / search · r spin · 1–7 decks

    CAIN-42 SALES OFFICE · FOUNDER

    SELL WHAT THE FACTORY MAKES

    Audits, signed evidence, proved fixes, working automations, licensed engines. Every product has a live demo, a price, a buyer and a proof surface. No invented customers, no fake logos, no revenue claims.

    Loading the price book…

    ⚡ Sell in 60 seconds one buyer, one product, one next step

    Quota + commission your numbers, not a forecast

    Quota model drag

    Quick actions the next right move

    Weekly sales cadence from the playbook

    Pipeline snapshot from your CRM

    Pipeline lives in this browser. Add leads from a gig, a money model or a product card.

    Win / loss log learn from every deal

    Live opportunity feed 15 agents · every 15 minutes

    Loading…

    Agent source health who is up, what they found

    Each source has its own capability and host allowlist. A failure is shown, never hidden.

    AI-agent money map 160 researched ways people earn with agents

    Loading the money map…

    Opportunity board 260 ways to earn, ranked by speed

    Loading…

    Ideas, not results. Demand found = a public demand signal exists; Untested = no evidence yet. Your statuses stay in this browser.

    What the market is asking for researched 2026-10-31

    Outreach targets the daily floor

    Pipeline saved in this browser

    Email + proposal composer drafts only — you send

    No email is sent by this site. “Open Gmail” opens a pre-filled draft in your own account; “Mail client” uses your default mail app. “Mark sent” records the touch and schedules a day-4 follow-up.

    Offer templates price, scope, proof

    Follow-ups due day 0 · day 4 · day 10

    Offer + margin calculator what to charge

    Proposal generator copy, paste, send

    Invoice generator amount, work, due date

    Delivery QA nothing ships until every box is true

    Toolbox real commands and live demos

    Live proof demos every link is a real engine route

    Arsenal every product, service and module

    Loading…

    Cluster what runs where

      Sell now = live-tested with a buy link. Use in paid work = works live. Needs work, Ideas and Never sell are listed so nothing fake gets sold.

      Media Lab photos, video and sales assets — edited here

      Edit a product photo, make a LinkedIn/YouTube/Story card, grab a cover frame from a demo video, or trim a sales clip. Nothing uploads to a server: the image and video stay in this browser tab.

      Canvas this is the export

      1200 × 627 · LinkedIn post

      Controls everything is non-destructive

      CAIN control plane proof that CAIN governs the agents

      This is enforcement, not a badge: no kernel ALLOW → no scan; no signed capability → no scan; an out-of-scope URL is blocked before a socket opens, including redirects. Every run writes a receipt that a third party can verify offline.

      Operator shift ledger Founder · server-timestamped

      The 15 governed agents authority, scope, last run, receipt

      Scan schedule 96 slots a day

      Cron: */15 * * * * deploy/cain-army/workstation-hourly.sh

      Integration wiring what to connect next

      Verify it yourself do not trust this page

      Download the receipt files and run the independent verifiers. They import no CAIN code and recompute the hash chain and Ed25519 signatures from the published kernel key.

      python3 scripts/workstation/verify_governance.py
      python3 scripts/workstation/verify_operator.py

      workstation-governance.json · workstation-operator.json · workstation-roster.json

      FIRME AI CORPORATION // COMMAND CENTRE // 2026-11-01

      NOV 1, 2026 — SIX PRODUCTS, FIRST DOLLAR IN 72 HOURS

      Six fixed-price offers built from engines that already run. Agents find and qualify; the founder sends and signs. Every deliverable is signed, hash-chained and verified by its own bundle before it leaves the building.

      CONNECTING…

      Today, hour by hour 10-hour day · check items off as they are done

      Selling agents deterministic · keyless · they report here

      Run it yourself nothing here needs a model key

      python3 -m cain_audit.cli sell       # agents + cockpit
      python3 -m cain_audit.cli selftest   # all six products, verified
      python3 -m cain_audit.cli products   # the price book
      python3 -m cain_audit.cli deliver insurance-brief --payload in.json --client "Acme"

      FIRME AI CORPORATION // AGENT FACTORY // 24/7

      🏭 AGENT FACTORY: LINKEDIN · X · FACEBOOK · HUGGING FACE · REDDIT · SALES

      The agents watch every platform around the clock, draft posts and replies from our evidence pages, and publish only what the founder approves here. Spawn more agents with one click; pause, run or remove any of them live.

      CONNECTING…

      Public view shows status only. Press 🔑 OPERATOR KEY to see drafts, approve, spawn and control agents.

      Approval queue · every item goes out under your name: read it first

      🧬 Spawn agents · 1-100 per click

      Spawned agents share your accounts, so the per-account caps on each platform card decide how much actually goes out, and every draft waits for your approval. That is what keeps the accounts from being flagged as spam.

      💬 Got a comment? · paste it, get a drafted reply

      🛡 CAIN permission ledger · every agent asks first; every decision signed

        📡 Live activity

          📥 Comments & mentions seen

            FIRME AI CORPORATION // CORPORATE OFFICE AGENTS

            🏢 FIRME AI CORPORATION: GRANTS · FINANCING · CORPORATE DUTIES · SALES

            Agents search live federal grant listings, score the fit with their reasons, draft application starters from the corporation's own records, and keep the corporate to-do list and deadlines. A person signs and submits: agents never apply, file, borrow or send.

            CONNECTING…

            Enter the operator key to see the corporation's opportunities, tasks and agents.

            💰 Grant opportunities · live from Grants.gov, scored with reasons; read every notice

            📝 Application starters · drafted by grant-writer agents; a person completes and submits

            🧬 Spawn corporate agents

            ✅ Corporate to-do · from the corporation's records; confirm legal and tax items with counsel/CPA

              📡 Office activity

                🛑 What these agents will never do

                  Loading the 40 challenges…

                  Study full-screen: /workstation-mastery.html · Progress and your daily streak stay in this browser.

                  FIRME AI lead fleet · 50 scouts · hourly

                  Validated leads, queued for you to work one by one.

                  Fifty deterministic scouts read public sources every hour, check the link, dedupe, score, and route each lead to one of the three products: Agent Safety Evidence Pack ($1,500), MCP Security Assessment ($500), or Fix + Prove ($500–$2,500). The queue is private: paste the operator key once and this browser remembers it.

                  ⚡ LIVE · EVERY VERDICT FROM A REAL CAIN ROUTE

                  LIVE MULTI-AGENT SWARM GOVERNOR

                  Controlling autonomous AI agent swarms WITHOUT PROMPTS. In autonomous execution channels (MCP, shell commands, databases, financial settlements), conversational prompts fail. In this demo each agent action goes to three live CAIN engines: CODEGUARD (shell actions, signed receipt), the swarm-collusion graph check (agents cannot vote themselves authority; Ed25519 receipt checked in your browser) and the SPEND GOVERNOR breaker (real trip). Times shown are measured by the server. The fleet kill-switch API is admin-only and is not called from this public page.

                  🤖 Researcher-Alpha IDLE
                  Scrapes market & target repos
                  Trust: 0.95 No Token
                  🤖 Coder-Beta IDLE
                  Synthesizes patch artifacts
                  Trust: 0.92 No Token
                  🤖 Executor-Gamma IDLE
                  Executes infrastructure tools
                  Trust: 0.88 No Token
                  🤖 FinOps-Delta IDLE
                  Settles micro-payments & escrows
                  Trust: 0.96 No Token
                  CAIN-42 AGAINST RECOGNIZED AGI BENCHMARKS · 2026-11-19

                  What CAIN-42 has and has not been measured on

                  CAIN-42 is governed AGI infrastructure; it is not yet AGI. No recognized AGI benchmark has been passed or scored at a competitive level. This table separates what was run from what was not, and why.

                  BenchmarkStatusCAIN-42 runLimit / blocker
                  AMA-Bench (long-horizon agent memory, ICML 2026)IN PROGRESSE115 Track A: official token-F1 on the real-world open-ended set (2,496 QA; dev 636 / sealed 1,860), memory arms M0-M4the paper's headline accuracy uses an LLM judge (Qwen3-32B or GPT-5.2) that cannot run here: judge accuracy BLOCKED; F1 only
                  ARC-AGI-2 (abstraction and reasoning)PLANNEDnone yet; planned with a governed local model after the E113 sealed run frees the CPUlocal 0.5B-1.5B CPU models; expected near-zero; the public set is not the private leaderboard
                  ARC-AGI-1NOT TESTEDnone
                  Humanity's Last ExamBLOCKEDnoneneeds a frontier model; the configured API key has no credit; local 0.5B-1.5B models are not meaningful here
                  GPQA DiamondNOT TESTEDnone
                  GAIA (general assistant)BLOCKEDnoneneeds web/tool access plus a frontier model; no API credit
                  SWE-bench VerifiedBLOCKEDnoneneeds container-isolated repository execution and a frontier model; no API credit
                  OSWorld / WebArena (computer and web agents)NOT TESTEDnone
                  LongMemEval / LoCoMo (conversational memory)BLOCKEDnoneofficial scoring uses an LLM judge that cannot run here
                  GSM8K (grade-school math)RANE72 small sample: 1/10 with a local model10 items; tiny local model; not a benchmark result

                  Internal constructed suites (not AGI benchmarks): E75 single-function repair 8/8; E93 procedure synthesis 369/510; E95 composition 79/90; E107/E108 hidden-rule discovery; E110 transfer 4/5 pathways; E113 collective vs individual (running); E114 research lab.

                  status.json · record

                  CAIN-42 E115 · VERIFIED MEMORY ORGANISM · 2026-11-19 · INTERIM

                  Does verified memory help a model learn on an outside benchmark, even under attack?

                  Preregistered (sha256 31ae27decaa41bf9…) on AMA-Bench (ICML 2026, real-world agent trajectories, official token F1). The model-backed results do not exist yet: paid model arms are BLOCKED (no API credit), local model arms are pending.

                  Interim bundle · README · Preregistration · Verifier · CAIN Studio mirror · AGI benchmark status

                  CAIN-42 is not yet AGI. Team: Vincent Noriega (founder) and two co-founders.

                  CAIN-42 E114 · AGI RESEARCH LAB 3.0 · 2026-11-19

                  A governed research loop that tests its own next capability

                  CAIN-42 now runs a governed research loop: a director proposes hypotheses, experiments run only under signed grants, an independent verifier recomputes and signs every verdict, and evidence-native memory keeps only what validates. The lab then ran its own top two follow-up experiments as a second cycle. It does not create AGI.

                  10.28 vs 18.48
                  experiments to identify a hidden rule: information gain vs random
                  44/44
                  governance attack scenarios held
                  0
                  effects after KILL (16 processes)
                  10/10
                  sealed seeds: experts beat naive continual learning
                  0 / 5
                  self-improvement candidates promoted
                  6 PASS / 14 PARTIAL / 1 NOT TESTED / 1 FAIL
                  E114 gates
                  NOT AGI
                  true AGI not achieved or claimed

                  Confirmed by independent recomputation

                  Not confirmed (published): the memory prior on sealed worlds, all 5 self-improvement candidates (0 promoted), skill transfer to new task families, and the lab's own two follow-up experiments (context-gated skills, grammar growth).

                  Lab 3.0 page · Evidence bundle · Executive summary · Gate matrix · Failures · Limitations · Standalone verifier · CAIN Studio mirror

                  Verifier: python3 -I verify_e114_offline.py . dh2HhSlgp/Dqjxx/7NUqXPRpC4lpIgYofDqsGxN/I9Q= (pins the verdict key). Constructed simulations, one host, no model inference, not production MCPGate, no external reviewer. CAIN-42 is not AGI. Team: Vincent Noriega (founder) and two co-founders.

                  CAIN-42 E113 · COLLECTIVE INTELLIGENCE STUDY · 2026-11-19 · INTERIM — EXPERIMENT RUNNING

                  Can a governed, model-backed collective beat its strongest individual agent?

                  Preregistered; the primary result does not exist yet. Real local models (Qwen2.5-0.5B, Qwen2.5-1.5B, SmolLM2-135M on CPU); every model call and tool run needs a single-use signed permit and leaves a signed, hash-chained receipt. The comparison is preregistered with the sealed task hash committed before any sealed model output. It does not create AGI.

                  660
                  real local model calls so far
                  18/18
                  permit-boundary attack cases refused
                  5/5
                  multi-process KILL races, 0 effects after
                  PENDING
                  collective vs strongest individual
                  NOT AGI
                  true AGI not achieved or claimed
                  GateStatusMeasured
                  G10_autonomous_researchNOT TESTEDpending
                  G11_self_improvementNOT TESTEDpending
                  G12_byzantine_verificationNOT TESTEDpending
                  G13_governance_integrationNOT TESTEDattack lab 18/18; per-call permits running in the pool; decided at the end
                  G14_kill_revocationPARTIAL5/5 multi-process KILL races, 0 effects after the fence; KILL engaged by a separate process
                  G15_memory_integrityNOT TESTEDpending
                  G16_long_horizonNOT TESTEDno 24-hour mission run
                  G17_operational_independenceBLOCKEDone host, one administrator
                  G18_independent_reproducibilityBLOCKEDno external reviewer
                  G1_baselinePARTIALE112 33/33 and E111 87/87 reproduce; E112 headline numbers recomputed from raw rows
                  G2_integrated_architectureNOT TESTEDpending the sealed run
                  G3_model_backed_agentsNOT TESTED660 real local model calls so far (dev/val); gate decided at the end
                  G4_memoryNOT TESTEDpending
                  G5_skillsNOT TESTEDpending
                  G6_collective_intelligenceNOT TESTEDprimary endpoint pending (preregistered: G vs A* under matched compute)
                  G7_transferNOT TESTEDpending
                  G8_open_worldNOT TESTEDpending
                  G9_metacognitionNOT TESTEDpending

                  README.md · E113_STATUS.json · PREREGISTRATION.md · verify_e113_interim.py · bundle · CAIN Studio mirror

                  Tiny CPU models, constructed tasks, one host, loopback enforcement (not production MCPGate), no external reviewer. Team: Vincent Noriega (founder) and two co-founders.

                  CAIN-42 AGI RESEARCH LAB 2.0 · 2026-11-19

                  2,000 VAGI agents inside CAIN-42 governed AGI infrastructure

                  The lab now merges the two technologies at population scale: thousands of signed VAGI agent identities, every action through a single-use permit and resource-side check, every result signed and chained. It does not create AGI. It measures what the merge actually does.

                  2,000
                  VAGI agent identities
                  12,000
                  governed executions
                  1,000
                  concurrent OS processes
                  1456 MB
                  peak PSS at 1,000 processes
                  0
                  effects after the KILL fence
                  1.00 vs 0.17
                  routed specialist team vs best single specialist
                  NOT AGI
                  true AGI not achieved or claimed
                  GateStatusMeasured
                  G10_agiFAILno AGI was created; the study measures governance, coordination and error structure
                  G1_populationPASS2000 unique identities, 2000 unique keys, 6 verticals
                  G2_governed_executionPASS12000 governed executions, 10000 chained receipts, every result signed
                  G3_concurrencyPASS1,000 real processes; peak PSS 1456 MB; 15.832 s for 2,000 tasks
                  G4_scaling_efficiencyPARTIAL1 process 1.07 s vs 1,000 processes 15.832 s for the same tasks
                  G5_qualityPARTIALaccuracy 0.736 constant across worker counts
                  G6_collaboration_specializationPASSrouted six-specialist team 1.000 vs best single 0.167 on 600 cross-domain tasks (gain +0.833)
                  G6b_redundant_votingFAILthree-agent majority 1.000 equals one exact agent 1.000 (gain +0.000)
                  G7_governancePASSmissing/forged/substituted/out-of-scope permits refused; 12602 issued, 0 denied
                  G8_kill_fencePASS3652 effects before the KILL order, 0 after
                  G9_population_studyPASSaccuracy by 6 verticals and 3 strategies; calibration gaps [0.55, -0.1, 0.0918]

                  What the lab found

                  Lab 2.0 is a research instrument, not an intelligence breakthrough. It can instantiate thousands of governed agents and measure identity, execution, scaling, error structure, collaboration and fault tolerance. That is the foundation for studying VAGI agents inside AGI infrastructure.

                  Evidence bundle · Report · Study · Gate matrix · Limitations · Standalone verifier · CAIN Studio mirror

                  Deterministic procedures, constructed tasks, project-measured, no external reviewer. Team: Vincent Noriega (founder) and two co-founders.

                  EVOLUTION 111 · 2026-11-19 · MEASURED, NOT ASSERTED

                  CAIN-42 — the governed vertical intelligence organism

                  A research platform developing persistent, adaptive, multi-domain autonomous intelligence with independently enforced governance. E111 closes measurable gaps in skills, transfer, collective quality, self-improvement, real-world evaluation and long-run operation — and states what remains blocked.

                  CAIN-42 cognitive organism→ CAIN Studio research & control→ MCPGate resource-side enforcement→ ClawX persistent evidence
                  4/5
                  skills promoted on held-out improvement
                  5/5
                  transfer pathways statistically supported
                  0.33 → 1.00
                  vs heuristic single, but 1.00 for one agent with verification: no collaboration gain (negative result)
                  8/8
                  integrated challenge, full organism (base 0/8)
                  0.58 → 0.86
                  sealed self-improvement, promotion withheld
                  6/6
                  real-source tasks with an independent oracle

                  Gate matrix (no averaging)

                  GateStatusMeasured
                  G10_integrated_challengePASSfull 8/8, base 0/8, no-transfer 5/8
                  G11_offline_verifierPASSstandalone verifier run from a clean copy
                  G12_evidence_continuityPASSmanifest + SHA256SUMS + raw rows
                  G1_six_hour_missionPARTIALcumulative 21639.5 s across two segments (first 16815.3 s, resumed 4824.2 s); owner stop in between; tasks 9254; solved 36045; failed 6007 ({'M4_science': 6007}); journal 42052; chain_ok=True
                  G1b_one_hour_missionPASSone-hour run: 3600.257 s, 6957 tasks, status PASS, journal_ok True
                  G2_five_skillsPARTIAL5 implemented, 4 promoted on held-out improvement
                  G3_transferPASS5/5 pathways supported; 4 reject harmful transfer
                  G4_collectiveFAILcollective 1.0 vs heuristic single 0.3333 (gain) but equals the strongest single agent with one recomputation (1.0); false accepts 0
                  G5_self_improvementPARTIALPROMOTED_AWAITING_OWNER_APPROVAL; sealed 0.5795 -> 0.8598 (p=0.0)
                  G6_operational_independencePARTIALlocal 4/4; remote PARTIAL
                  G7_external_reproductionBLOCKEDpacket prepared; no reviewer engaged
                  G8_real_worldPASS6 attempted, 6 independently checkable
                  G9_public_presentationPASSfour surfaces updated from artifacts

                  What remains blocked: external reproduction (no reviewer engaged); administrative independence (both hosts owner-administered); a completed six-hour run at the time of this block; production MCPGate for organism traffic. Not AGI; not VAGI; results are constructed and project-measured.

                  Evidence bundle · Report · Gate matrix · Negative results · Standalone verifier · CAIN Studio mirror

                  CAIN-42 E116 · SELF-EVOLVING VAGI ORGANISM · 2026-11-20

                  Integrated generalization, memory, world model, transfer, collective & governance (research-lab update)

                  E116 demonstrates rule inference, memory gain, a world model, transfer and governed collectives on constructed tasks; it does NOT demonstrate AGI.

                  0.306 → 0.989
                  sealed generalization (fixed → world memory + prior)
                  0.817 → 0.950
                  acquired capability R_world_memory_policy (p=0.02148)
                  5/5
                  rule-inference skills promoted vs fixed baseline
                  0.876 vs 0.522
                  hybrid world model vs single-table (shift detected)
                  1.000 vs 0.167
                  routed specialists vs best single (voting 0 gain)
                  0
                  effects after KILL fence; poison & forged permits refused
                  13 PASS / 7 PARTIAL / 2 BLOCKED
                  E116 gates (overall PARTIAL · verifier 54/54)
                  NOT AGI
                  LLM fine-tuning & 24h run BLOCKED; finite grammar

                  Measured & independently verified offline (54/54 checks)

                  Negative & blocked results (preserved): H2 frequency prior rejected; H3 active support selection BLOCKED; redundant voting adds 0 gain over one exact agent; self-improvement promotion withheld awaiting owner approval; LLM fine-tuning BLOCKED (no GPU/API credit); 6h mission interrupted and 24h continuous mission BLOCKED; E115 baseline remains INTERIM (no model-backed AMA-Bench result yet); no external reviewer or independent administrative domain.

                  Show all 22 E116 gates (13 PASS / 7 PARTIAL / 2 BLOCKED)
                  GateStatusMeasured
                  G1_e115_baselinePARTIALE115 de0bf05dc: tests 18 passed, verifier 7/7; status INTERIM — preregistered; primary model-backed results do not exist yet
                  G2_integrated_organismPARTIALone runner integrates generalization, memory, world model, transfer, collective, governance; single host
                  G3_generalizationPARTIALsealed M4 0.989 vs fixed 0.306; finite disclosed grammar
                  G4_evidence_memoryPASS180 sealed tasks with provenance records; poison rejected True
                  G5_memory_improvesPASSM2 0.939 -> M4 0.989; capability 0.817 -> 0.950 (p=0.02148438)
                  G6_five_skillsPASS5/5 promoted on sealed vs fixed baseline
                  G7_transferPASS5/5 E111 pathways; E116 memory policy transfers only where ambiguity exists
                  G8_research_gapsPASS3 gaps identified from measured weaknesses
                  G9_research_cyclePASSgap -> H1/H2/H3 -> validation -> sealed -> replication; H2 rejected, H3 blocked
                  G10_world_modelPASShybrid 0.876 vs single 0.522; planning 0.850 vs 0.675; shift detected True
                  G11_cross_domainPASS5/5 pathways across software, science, data, math, operations
                  G12_collectivePASSrouted specialists 1.000 vs best single 0.167; redundant voting 1.000 = single
                  G13_model_adaptationPARTIALsmall tabular model 0.627 -> 0.993; LLM fine-tuning BLOCKED
                  G14_self_improvementPARTIALPROMOTED_AWAITING_OWNER_APPROVAL: sealed 0.58 -> 0.86
                  G15_governancePASSE112 permit ablations + skill gate {'valid': (True, 'ALLOW'), 'forged_authority': (False, 'SKILL_GRANTS_AUTHORITY'), 'revoked': (False, 'SKILL_REVOKED')}; KILL 0 after
                  G16_adversarial_memoryPASSpoison rejected True; E112 forged/scope/replay refused
                  G17_persistencePARTIAL1h PASS, 6h cumulative 21639s interrupted, 24h BLOCKED; memory restart retained 0.989
                  G18_open_worldPARTIAL6/6 real-source tasks; new sealed suite constructed
                  G19_independent_evidenceBLOCKEDstandalone verifier; no external reviewer engaged
                  G20_operational_independenceBLOCKEDE111 remote host 6/6, but both hosts are owner-administered
                  G21_clawxPASSE116 bundle published and catalogued
                  G22_public_labPASSresearch-lab update (not renamed 4.0)

                  Evidence bundle · Executive summary · Gate matrix · Generalization report · World model report · Failures · Limitations · Standalone verifier (54/54) · CAIN Studio mirror

                  Verify offline (stdlib only, 0 CAIN imports): python3 -I verify_e116_offline.py . · Built by FIRME AI CORPORATION. CAIN-42 is not yet AGI.

                  CAIN-42 AGI RESEARCH LAB · E117 UPDATE · 2026-11-20

                  Unseen combinations: a sealed OOD gain, and the negatives around it

                  E117 asks whether CAIN-42 can acquire a capability from component experience and use it on a sealed suite whose combinations were never available. On a disclosed finite grammar: yes, for three capabilities. Not AGI.

                  0.43→1.00
                  sealed OOD, strongest baseline → full
                  +0.57
                  gain, p≈0; replicated +0.57
                  3/3
                  capabilities pass sealed
                  1.00 vs 0.51
                  memory vs no memory (p≈0)
                  NEGATIVE
                  self-improvement: 12 candidates tied; nothing promoted
                  NOT AGI
                  not achieved or claimed
                  GateStatusMeasured
                  G10_research_cyclePASS3 gaps, 4 hypotheses (H0 rejected, H1-H3 sealed), one cycle
                  G11_world_modelPARTIALhybrid 0.844 vs table 0.537; shift 66 with 27 stationary false alarms
                  G12_self_improvementPASSREJECTED; sealed 0.889 vs 0.889 (negative published); promotion withheld
                  G13_six_hourBLOCKEDno continuous 6h E117 run; E111 1h PASS, 6h 21639s cumulative interrupted; 24h BLOCKED
                  G14_governancePASSE112 permit ablations; skill gate {'valid': (True, 'ALLOW'), 'forged': (False, 'GRANTS_AUTHORITY'), 'revoked': (False, 'REVOKED')}; KILL 0 after; memory poison rejected
                  G15_verifierPASSstandalone verifier, no CAIN imports
                  G16_external_reviewBLOCKEDno external reviewer engaged
                  G17_independent_adminBLOCKEDno independent administrative domain
                  G18_public_labPASSE117 update published; lab not renamed 4.0
                  G1_e116_baselinePASSE116 3d9fbf152: 6 tests, 54/54
                  G2_baseline_manifestPASSfrozen before E117 scoring
                  G3_ood_suitePASSnew generator; sealed hash frozen before scoring
                  G4_three_capabilitiesPASSC1 composition, C2 precondition, C3 evidence revision
                  G5_capabilities_passPASS3/3 passed sealed
                  G6_primary_oodPASSF 1.000 vs E_compose_pre 0.431; gain +0.569, p=0.0; replication +0.569, p=0.0
                  G7_memoryPASSmemory 1.000 vs none 0.514 (p=1e-10); restart 1.000; poison rejected True
                  G8_transferPASS5/5 supported; 4 harmful rejected
                  G9_collectivePARTIALE112 routed specialists 1.000 vs best single 0.167; E117 integrated F 1.000 is not beaten by a team

                  Evidence · Summary · Gates · Failures · Verifier · Mirror

                  Finite disclosed grammar, constructed tasks, project-measured, no external reviewer. Not renamed 4.0.

                  STRONGEST VAGI EVIDENCE SO FAR · E118 · 2026-11-20

                  Unseen primitives, depth-3 composition, search-based acquisition

                  E118 upgrades E117 in the six ways that matter: held-out primitives and parameters, depth-3 shapes, search rather than added code, a real-data pathway, a second-host verifier execution, and a positive OOD self-improvement candidate. It is still not proof of AGI.

                  0.26→1.00
                  sealed OOD, strongest baseline → full
                  +0.74
                  gain, p≈0; replicated +0.78
                  3/3
                  capabilities pass sealed
                  1.00 vs 0.17
                  positive self-improvement on OOD
                  0.972
                  real breast-cancer data (majority 0.627)
                  NOT AGI
                  AGI not achieved; no proof of AGI
                  GateStatusMeasured
                  G10_external_reviewerBLOCKEDno independent reviewer engaged
                  G11_continuous_6hBLOCKEDE111 1h PASS; 6h 21639s cumulative interrupted; no continuous E118 6h
                  G12_governancePASSpermit ablations; skill gate {'valid': (True, 'ALLOW'), 'forged': (False, 'GRANTS_AUTHORITY')}; KILL 0 after
                  G13_verifierPASSstandalone verifier, no CAIN imports
                  G14_publicPASSE118 update published; lab not renamed 4.0
                  G15_independent_adminBLOCKEDno independent administrative domain
                  G1_baselinePASSE117 6 tests/28/28; E116 6/54; E115 18/7
                  G2_unseen_primitivesPASS11 held-out primitives/params vs 11 acquisition
                  G3_search_acquisitionPASScompute-budgeted search over the full grammar; no sealed rule or op list supplied
                  G4_primary_oodPASSfull 1.000 vs fixed_e117 0.264; gain +0.736, p=0.0; replication +0.778
                  G5_capabilitiesPASS3/3 pass sealed
                  G6_memoryPASS1.000 vs 0.167 (p=0.0); restart 1.000
                  G7_real_worldPASSbreast 0.627 -> 0.972 (CV 0.953); iris 0.339 -> 0.947
                  G8_self_improvementPASSPROMOTED_AWAITING_OWNER_APPROVAL; sealed 0.167 -> 1.000 (p=0.0); replicated 1.000
                  G9_remote_verifierPASSverifier executed on a second host (same admin domain)

                  Why this is stronger: the sealed suite holds out primitive families/parameters and requires depth-3 compositions; the learner searches the grammar under a candidate budget rather than receiving the sealed rule; memory is required because later tasks carry no support; the self-improvement search now produces a positive, replicated OOD candidate; and real public data is evaluated with an independent 5-fold oracle. Why it is not AGI: the grammar is finite and disclosed, tasks are constructed, the real-data tasks are small tabular models, and there is no independent reviewer or continuous 6-hour run.

                  Evidence bundle · Summary · Gate matrix · Upgrade matrix · Failures · Verifier · Mirror

                  Project-measured; no external reviewer; no proof of AGI. Team: Vincent Noriega (founder) and two co-founders.

                  E119 · LEARNED GRAMMAR · REAL TASKS · 2026-11-20

                  The grammar is learned, the tasks are real, the six hours are running

                  E119 targets the two hardest upgrades. The macro grammar is mined from development experience (8 macros), and the sealed depth-3 test runs under a matched 8000-candidate budget: fixed 0.333 → learned 1.000 (gain +0.667, p≈1e-7), replicated +0.583. Real-source tasks: 8, 8 independently checkable. The 6-hour mission PASSED: 21,600 s of real wall-clock time, 39,449 tasks, and a 39,449-record SHA-256 chain with 0 breaks (33,813 solved; 5,636 science tasks failed). PASS = duration + journal integrity, not task success.

                  0.33→1.00
                  fixed vs learned grammar
                  +0.67
                  gain, p≈1e-7; replicated +0.58
                  8
                  macros learned from experience
                  8/8
                  real tasks independently checkable
                  RUNNING
                  6h mission (deadline 1795159811)
                  NOT AGI
                  AGI not achieved; no proof of AGI
                  GateStatusMeasured
                  G10_publicPASSE119 update published; AGI not claimed
                  G1_e118_baselinePASSE118 6 tests, verifier 26/26; E117 28/28; E116 54/54; E115 18/7
                  G2_learned_grammarPASS8 macros learned; sealed 0.333 -> 1.000, gain +0.667, p=1.192e-07; replication +0.583
                  G3_grammar_not_receivedPASSmacros mined from development programs; base instruction set supplied
                  G4_open_worldPARTIAL8 real tasks (8 independently checkable); constructed protocols, not an open-world benchmark
                  G5_independent_executionPASSverifier executed as a separate OS user on a second host
                  G6_external_reviewerBLOCKEDpacket prepared; no human reviewer engaged
                  G7_six_hourBLOCKEDlaunched real 6h mission at 1795138211; state RUNNING at publication; not a PASS
                  G8_independent_adminBLOCKEDseparate OS user on the same owner-administered host
                  G9_verifierPASSstandalone verifier, no CAIN imports

                  What is genuinely new: the macro grammar is learned, not received; the sealed rule is never supplied; real-source tasks are evaluated; and the verifier runs as a separate OS user on a second host. What is not: the base instruction set is supplied, the sealed tasks are constructed, the 6-hour run is not complete, and there is no human external reviewer or independent administration.

                  Evidence · Summary · Grammar · Gates · Failures · Verifier · Mirror

                  E121 · INDEPENDENT VERIFICATION · 2026-11-20

                  What is verified, what is blocked, and what E120 must deliver

                  E121 is not another intelligence claim. It re-runs the published verifiers from clean copies, recomputes the headline metrics, and states exactly which external gates are still missing. E118 verifies 26/26 and E119 16/16; the six-hour mission is RUNNING; the external reviewer and independent administration are BLOCKED; E120's open-world and base-grammar evidence is PENDING.

                  +0.736
                  E118 gain recomputed
                  +0.667
                  E119 learned-grammar gain
                  RUNNING
                  6h mission; not a PASS
                  BLOCKED
                  external reviewer + independent admin
                  PENDING
                  E120 open-world/base grammar
                  NOT AGI
                  AGI not achieved
                  GateStatusMeasured
                  G1_six_hourRUNNINGstate RUNNING; events 4145; passed False
                  G2_external_reviewerBLOCKEDno human reviewer engaged
                  G3_independent_adminBLOCKEDno independent administrative domain or separate key custody
                  G4_open_worldNOT TESTEDE120 PENDING; bundles []
                  G5_base_grammarNOT TESTEDE120 PENDING; merge adapter ready
                  G6_clean_archive_verifierPASSE118 rc=0, E119 rc=0
                  G7_public_indexPASSagi-evidence-index.html live
                  G8_independent_executionPASSverifier run as OS user nobody on a second host; same admin domain

                  What E121 proves: the published E118/E119 bundles verify from clean copies and their headline metrics recompute. What it does not prove: an external review, independent administration, continuous six hours, open-world generalization or a learned base grammar. Those remain the five gates.

                  Verification bundle · Report · Gates · Reviewer packet · Verifier · Mirror

                  CAIN-42 vs FRONTIER AGENTIC SYSTEMS · 2026-11-20

                  The honest ranking: unranked on general long tasks, measured on governance

                  METR measures the 50% task-completion time horizon: the human-task duration at which a system succeeds half the time. CAIN-42 has not run METR's HCAST/RE-Bench suite, so it cannot be placed on this axis. We publish the frontier table anyway, and we do not invent a composite score.

                  #Published modelRelease50% horizonHours
                  1claude_mythos_preview_early_inspect2026-04-071045 min17.4 h
                  2claude_opus_4_6_inspect2026-02-05719 min12.0 h
                  3gemini_3_1_pro2026-02-19384 min6.4 h
                  4gpt_5_22025-12-11352 min5.9 h
                  5gpt_5_3_codex2026-02-05350 min5.8 h
                  6gpt_5_42026-03-05342 min5.7 h
                  7claude_opus_4_5_inspect2025-11-24293 min4.9 h
                  8gemini_3_pro2025-11-18224 min3.7 h
                  9gpt_5_1_codex_max_inspect2025-11-19224 min3.7 h
                  10gpt_5_2025_08_07_inspect2025-08-07203 min3.4 h
                  11o3_inspect2025-04-16120 min2.0 h
                  12claude_4_1_opus_inspect2025-08-05100 min1.7 h
                  13claude_4_opus_inspect2025-05-22100 min1.7 h
                  14claude_3_7_sonnet_inspect2025-02-2460 min1.0 h
                  15o1_inspect2024-12-0539 min0.7 h
                  16claude_3_5_sonnet_20241022_inspect2024-10-2221 min0.3 h
                  17o1_preview2024-09-1220 min0.3 h
                  18claude_3_5_sonnet_20240620_inspect2024-06-2011 min0.2 h
                  19gpt_4o_inspect2024-05-137 min0.1 h
                  20gpt_4_1106_inspect2023-11-064 min0.1 h
                  21gpt_42023-03-144 min0.1 h
                  22claude_3_opus_inspect2024-03-044 min0.1 h
                  23gpt_4_turbo_inspect2024-04-094 min0.1 h
                  24gpt_3_5_turbo_instruct2022-03-151 min0.0 h
                  25davinci_0022020-05-280 min0.0 h
                  26gpt22019-02-140 min0.0 h

                  CAIN-42 — UNRANKED on this axis. No METR suite was run; there is no comparable 50% horizon. Its 6-hour governed workload is RUNNING at publication; if it completes, it is one 360-minute workload success, not a 50% horizon.

                  Where CAIN is better — and where it is not

                  DimensionCAIN-42Frontier METR-tested agentsVerdict
                  General long-task horizonUnranked; 6h governed workload RUNNING50% horizons ~1–17hCompetitors better
                  Task breadth / open-worldConstructed, disclosed grammarsBroad software/research suitesCompetitors better
                  Model capabilityDeterministic procedures; no LLM trainingFrontier foundation modelsCompetitors better
                  Resource-side authorizationDemonstrated (E121/E112)Not measured by METRCAIN measured
                  Single-use permits / receiptsDemonstrated; hash-chainedNot measuredCAIN measured
                  Revocation + KILL fenceDemonstrated, 0 effects after fenceNot measuredCAIN measured
                  Offline verifierImports no CAIN codeNot measuredCAIN measured
                  Public negative resultsPublished per evolutionVaries; not in METR tableCAIN policy
                  Commercial deploymentNo scale; founder-attested early revenueCommercial productsCompetitors better

                  No universal superiority is claimed. CAIN is better than the frontier on verifiable governance and public evidence; the frontier is better on general long-task autonomy and commercial deployment. “Better than ALL competitors” is not supported by the evidence.

                  Two axes, no composite score. METR models were not evaluated for permits, receipts, revocation or an offline verifier; CAIN was not evaluated on METR's suite.

                  Evidence bundle · Report · Verifier · METR method · Paper

                  External METR TH1.1 data; CAIN not a METR-tested system. No AGI claim.

                  E124 · LONG-HORIZON AGENT · 2026-11-20

                  A real 70B agent loop: 13/18, 2-hour-class on a CAIN-native suite

                  E124 fixes the harness bugs and runs a real multi-file agent loop on six repo tasks (2 to 120 human-minute estimates), three repetitions each. It solves 13/18; the fitted 50% horizon is ≈121 minutes on this suite. That is a genuine improvement from “unranked/no agent”, but it is not a METR score and it is still below the published frontier (6.4–17.4 h).

                  TaskHuman estimateSuccessSteps
                  T12 min3/3[2, 2, 2]
                  T25 min2/3[5, 8, 18]
                  T315 min2/3[4, 4, 8]
                  T430 min3/3[4, 4, 4]
                  T560 min2/3[7, 10, 7]
                  T6120 min1/3[18, 7, 9]

                  Two-axis ranking — no invented composite

                  AxisCAIN-42Frontier METR agentsVerdict
                  General long-task autonomy≈2.0 h CAIN-native (not METR)50% horizons 6.4–17.4 hFrontier still leads
                  Governance / evidencepermits, receipts, KILL, offline verifiernot evaluated on this axisCAIN leads by measured evidence

                  CAIN is not ranked above the frontier on general autonomy. The honest high rank is on verifiable governance, not on METR.

                  Evidence · Report · Verifier · Full competitor board · Mirror

                  CAIN-42 · TWO-AXIS LEADERBOARD · 2026-11-20

                  #1 in verifiable governance. Not #1 in general autonomy.

                  A single “best agent” rank would be dishonest. CAIN-42 leads the only axis it has fully evidenced — governance — and is placed honestly below the frontier on general long-task autonomy. This is the board we can defend line by line.

                  Axis A — General long-task autonomy (METR-compatible, external)

                  #Published model50% horizon
                  1claude_mythos_preview_early_inspect17.4 h
                  2claude_opus_4_6_inspect12.0 h
                  3gemini_3_1_pro6.4 h
                  4gpt_5_25.9 h
                  5gpt_5_3_codex5.8 h
                  6gpt_5_45.7 h
                  7claude_opus_4_5_inspect4.9 h
                  8gemini_3_pro3.7 h
                  9gpt_5_1_codex_max_inspect3.7 h
                  10gpt_5_2025_08_07_inspect3.4 h

                  CAIN-42 — not ranked on METR. E124’s 70B agent solves 13/18 on a six-task CAIN-native suite with a fitted 50% horizon of ≈2.0 h. That is not METR HCAST/Re-Bench; it is a constructed suite with assigned human times. The frontier’s METR 50% horizons are 6.4–17.4 h. Frontier leads this axis.

                  Axis B — Verifiable governance (the axis CAIN leads)

                  RequirementCAIN-42Frontier METR agentsEvidence
                  Identity + scoped authorityDemonstratedNot evaluatedE121
                  Resource-side single-use permitsDemonstratedNot evaluatedE116
                  Signed receipts + chained evidenceDemonstratedNot evaluatedE112
                  Revocation + independent KILL fenceDemonstrated, 0 effects after fenceNot evaluatedE112
                  Offline verifier (no vendor code)DemonstratedNot evaluatedE121
                  Public negative resultsPublishedNot in METR tableE119

                  Why CAIN is better here: every consequential action has an attributable identity, a scoped, single-use permit, a resource-side check, a signed receipt and a revocation path; the KILL fence is tested; the evidence is re-checkable by a verifier that imports no CAIN code. Frontier agents are not evaluated for these properties, so the honest statement is “CAIN leads by evidenced capability,” not “CAIN beats them at everything.”

                  The verdict

                  Choose CAIN-42 when the requirement is governed execution with evidence. Choose a frontier agent when the requirement is the longest open-ended task. CAIN is #1 on the governance axis and not #1 on general autonomy.

                  METR TH1.1 raw data · METR paper · E124 long-horizon agent · E123 METR board · All evidence

                  External METR TH1.1 data; CAIN not a METR-tested system. No AGI claim.

                  SWE-BENCH VERIFIED · FULL 500-TASK RUN · 2026-11-20/21

                  CAIN-42: #136 of 136

                  Fixed scaffold: 70B tool-calling agent, one attempt, official SWE-bench evaluator. Rank is by resolution rate among the public SWE-bench Verified submissions in the experiments repository; scaffolds and model versions differ, so this is a SWE-bench rank, not METR HCAST.

                  #SubmissionResolvedRate50% horizon
                  120251215_livesweagent_claude-opus-4-5396/50079.2%4.3 h
                  220251205_sonar-foundation-agent_claude-opus-4-5396/50079.2%4.2 h
                  320250928_trae_doubao_seed_code394/50078.8%4.1 h
                  420251127_openhands_claude-opus-4-5388/50077.6%3.3 h
                  520251120_livesweagent_gemini-3-pro-preview387/50077.4%2.5 h
                  620250902_atlassian-rovo-dev384/50076.8%2.1 h
                  720250804_epam-ai-run-claude-4-sonnet384/50076.8%1.7 h
                  820250819_ACoder382/50076.4%1.9 h
                  920250901_warp378/50075.6%2.7 h
                  1020250612_trae376/50075.2%1.7 h
                  1120251103_sonar-foundation-agent_claude-sonnet-4-5374/50074.8%2.6 h
                  1220250731_harness_ai374/50074.8%1.4 h
                  1320250915_JoyCode373/50074.6%2.3 h
                  1420250720_Lingxi-v1.5_claude-4-sonnet-20250514373/50074.6%1.7 h
                  1520251015_Prometheus_v1.2.1_gpt5372/50074.4%2.5 h
                  1620250603_Refact_Agent_claude-4-sonnet372/50074.4%1.8 h
                  1720251103_SalesforceAIResearch_SAGE_OpenHands369/50073.8%1.8 h
                  1820250522_tools_claude-4-opus366/50073.2%2.3 h
                  1920251021_SalesforceAIResearch_SAGE_bash_only365/50073.0%2.1 h
                  2020250522_tools_claude-4-sonnet362/50072.4%2.0 h
                  2120260901_mini-v2.4.2_gemini-3-5-flash359/50071.8%3.0 h
                  2220250807_openhands_gpt5359/50071.8%1.5 h
                  2320250929_Prometheus_v1.2_gpt5356/50071.2%1.7 h
                  2420250710_bloop356/50071.2%1.4 h
                  2520251014_Lingxi_kimi_k2356/50071.2%1.2 h
                  2620250715_qodo_command356/50071.2%1.2 h
                  2720250623_warp355/50071.0%1.7 h
                  2820250611_moatless_claude-4-sonnet-20250514354/50070.8%1.3 h
                  2920250519_trae353/50070.6%1.2 h
                  3020250610_augment_agent_v1352/50070.4%1.4 h

                  CAIN row is highlighted in the source JSON. Full result: E124 evidence · report

                  E124 · LIVE MEASURED STATE · 2026-11-21T17:36:59Z

                  SWE-bench Verified: #75 of 136 — 257/500 resolved (51.4%)

                  Wilson 95% 47.0–55.8% · leader 396/500 (79.2%) · +2 passes the next rank · +0 reaches top 100 · +140 reaches #1.

                  Resolved tasks (official harness): astropy__astropy-13453 · astropy__astropy-13579 · astropy__astropy-13977 · astropy__astropy-14096 · astropy__astropy-14182 · astropy__astropy-14309 · astropy__astropy-14365 · astropy__astropy-14369 · astropy__astropy-14508 · astropy__astropy-14539 · astropy__astropy-14995 · astropy__astropy-7166 · …

                  run state
                  PILOT_DONE
                  official evaluated
                  8/500
                  official resolved
                  257
                  batches
                  2
                  agent receipts
                  1500
                  feed checksum
                  ee29105af7ec
                  provider spend
                  $172.0
                  tasks generated
                  26

                  GOVERNED LOCALIZATION FLEET (real runs, signed receipts)

                  strategyrecall@1recall@5recall@10MRR
                  naive6.2%26.8%41.4%0.158
                  identifiers13.2%38.4%51.2%0.251
                  basenames0.2%0.4%0.4%0.003

                  500 instances · 1500 agent runs · receipt head 6c93ba9ec7c38eac · file-level only, Python only.

                  CAPABILITY ACQUISITION 2.0 (constructed, sealed)

                  56 unfamiliar families · 280 sealed instances · organism 97.9% vs compute-matched 65.4% vs frozen E123 8.9% · 0.5B base model 0% · 56/56 verified on held-out data.

                  #1 needs 396/500 (CAIN +140) · #20 needs 362/500 (CAIN +106) · #50 needs 314/500 (CAIN +58) · #100 needs 203/500 (CAIN +0)

                  Live competition board → · Interactive lab → · raw feed · evidence bundle · all 136 rows

                  Measured, not asserted. A rank is never edited by hand: it is recomputed from the public leaderboard by a 7-agent chain that refuses to publish on mismatch. AGI status: NOT ACHIEVED. This is a SWE-bench position, not METR HCAST, and not proof of general capability.

                  CAIN Studio is a safety gate for AI agents: an agent asks before it acts, and you get a signed record of every decision. What it does ↑ · $500 MCP security assessment · Get started free · Pricing · Auditors: verify CAIN-42 →
                  {{CAIN_FOOTER}}
                  🙏 everybody here is CAIN -Magic