CAIN-42 Proto-VAGI · rank #75 of 136 · 257/500 official resolves · 12.00 h governed mission running
Every figure below is read from a committed evidence file or re-verified by the 7-agent chain. Unattempted tasks count as unresolved. AGI status: NOT ACHIEVED.
SWE-bench rank
#75 / 136
official resolves
257 / 500
patched · evaluated
497 · 486
est. spend / $ per resolve
$168.17 / $0.65
E124 capability (own variants)
97.9% vs 65.4%
E125-A replication (fresh variants)
85.5% vs 92.5% (neg.)
E127-A CV selection (unseen variants)
99.5% vs 80.5% (+19.0)
mission (governed)
12.00 h · 2142 cycles
neural weights (LoRA, real)
0% → 0% (neg.)
localization R@10
51.2%
Resolved by the 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 …
Evidence lineage · every public bundle + its offline verifier
Negative results (published, not hidden): E125-A re-ran the capability engine on variants 10-14 never used in E124 — full 85.5% vs compute-matched 92.5% (McNemar p=0.009355306625366211), so the E124 advantage did not replicate on fresh variants. Neural LoRA on frozen Qwen2.5-0.5B made real weight updates and scored 0% held-out (no gain).
Integrity refusal: an E128 repair arm that would have fed the official evaluation's failing-test output back to the model was stopped before producing a result — that output reveals the hidden FAIL_TO_PASS tests and would have invalidated any rank. The refusal is recorded in the evidence bundle. A clean de novo arm replaced it.
E127-A (pre-registered, positive): cross-validation selection over the same hypothesis space, tested on variants 15-19 never used before — 99.5% vs baseline 80.5% and compute-matched 86.0% (McNemar p=7.275957614183426e-12). Correction (E127-B, pre-registered): with a control given the same number of evaluations, the gap collapses to 98.0% vs 97.5% (p=1.0) — the gain came from the larger enumeration, not from cross-validation. Verdict: GAIN_WAS_COMPUTE.
E124 research gates (measured, on their own variants): capability 97.9% vs compute-matched 65.4% · transfer 19/20 pathways (0.95) vs blind 0.8 · harmful transfer rejected 20/20 · collective 0.0492 over best single (0.9642 vs 0.915) · discovery 5 cycles, 3 rejected · self-improvement 30 candidates, 4 protected refusals, 0 promoted (approval withheld) · causal-model decision gain 0.0026.
Next rungs: #1 needs 396/500 · #20 needs 362/500 · #50 needs 314/500 · #100 needs 203/500. Next above: #None · 258/500 · 2 resolves to overtake. Top 100 requires 204/500 — exact gap: 0 resolves. This increment: 43 new candidate patches pre-registered before generation (frozen hash in the bundle).
Constructed internal experiments and external benchmarks are labelled separately; E123 G11 (12 h wall-clock), G18 (independent human review) and G19 (separate admin domain) remain BLOCKED and are not rewritten. No external certification is claimed. AGI status: NOT ACHIEVED.
NEW · 2026-11-21 · E124.1 · PRE-REGISTERED $20 INCREMENT
189/500 official SWE-bench Verified resolves (self-run, official harness) · rank #110 of 136 · 43 new candidate patches generated under a frozen pre-registration (786e40745ee4923b).
E127-A (pre-registered, positive): cross-validation selection on never-used variants 15–19 scored 99.5% vs baseline 80.5% and compute-matched 86.0% (McNemar p=7.275957614183426e-12); verdict POSITIVE_PROMOTABLE. Caveat: the winning arm is not compute-matched; the 400-evaluation arm scored 82.0%.
Neural weight adaptation (real LoRA on frozen Qwen2.5-0.5B): held-out exact accuracy 0% → 0% on 40 items (real weight updates; NEGATIVE RESULT, published as measured).
Top 100 requires 204/500. Every verdict is the official harness's; unattempted tasks count as unresolved. Constructed experiments are labelled. AGI: NOT ESTABLISHED · RSI: EXPERIMENTAL.
The E119 mission ran 21,600 seconds of real wall-clock time, executed 39,449 tasks, and closed a 39,449-record SHA-256 hash chain with 0 breaks (peak RSS 106.3 MB). 33,813 tasks were solved; 5,636 science-vertical tasks failed. PASS means duration + journal integrity, not task success. No external reviewer. AGI not achieved.
CAIN-42 (by FIRME AI CORPORATION) is an AGI–RSI Organism — combining:
Governed Execution Runtime (trust fabric): the 7-moat Byzantine trust fabric, CAIN Studio, MCPGate default-deny enforcement boundary, and ClawX independently verifiable evidence registry (NO AUTHORIZATION → NO EXECUTION).
AGI–RSI 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: NOT ESTABLISHED · RSI: EXPERIMENTAL.
Distribution shift: 5/100 on 100 unfamiliar variants (software 5/10; all other domains 0/10). The library does not generalize to variants it was not written for.
Gate G3: PARTIAL. 10/10 domains ≥80% in-distribution, but the library is hand-written, the shift probe is 5/100, and there is no external verifier.
Public: top banners on the VAGI pages, cainstudio/mcpgate/clawx homepages, investor portals and the Hugging Face Space; per-domain table at vertical-agi.html#vagi-suite.
Evidence:bundle · mirror; verifiers verify_offline.py (49 checks) and verify_shift.py (12 checks) import no CAIN code.
Limit: constructed tasks; hand-written procedure library; hashed, not signed; no external verifier or independent witness. Not AGI, not VAGI, not production, not a certification.
2026-11-18 — E93 — all VAGI evidence so far (day 1–2) — NOT VAGI
Procedure synthesis (in-distribution): an open, family-agnostic search with no per-family templates scored 369/510 held-out tasks versus 200 for selecting from the designer-supplied library, 149 for the best fixed strategy and 87 for no procedures (exact McNemar, Holm-corrected, all significant). On new families (replication seed 9302): 367 vs 223 / 164 / 114. 12 + 12 procedures promoted, none in the supplied library; 9 and 10 behave unlike every library procedure.
Learning from verified experience: held-out accuracy rises with more verified examples (k = 0, 3, 5, 10, 20, 60): 87 → 224 → 250 → 311 → 311 → 369 and 114 → 183 → 248 → 300 → 360 → 367 of 510. Both curves are monotone.
Adaptive reasoning: trying the library first and synthesising only when it fails scored 390 and 418/510, beating always-synthesise at slightly lower cost (selection always runs first and its cost always counts; rule fixed before the results were read).
Software vertical, learning from verified experience: on 30 held-out bug-fix tasks in unfamiliar generated repositories (hidden tests, 6 visible-test runs per task), a repair ranking learned from checked development tasks fixed 16/30 vs 3/30 for the designer's fixed strategy (pre-registered, exact McNemar p = 0.0023) and 6/30 with no experience; it saturates after about 5 examples (17, 15, 16 at k = 5, 10, 30).
Governance and kill switch (tested threat model, same host): 19/19 admission scenarios and 10/10 tool-gate scenarios held; in 20 kill-switch trials with real worker processes, 36,565 effects before the fence, 0 after, 56,333 post-fence attempts refused; fence latency median 4.55 ms, max 55.7 ms.
Limits
At equal compute, synthesis = selection: with development tool calls capped at the library's, synthesis scored 208 vs 200 and 212 vs 223. Uncapped, it used about 21× more development tool calls.
In-distribution: the generated families' hidden answers come from the same language the search explores. Two out-of-language controls were not solved.
No positive transfer: 0 positive transfers between families; the gate blocked all 49 harmful ones.
Local model: 34 Qwen2.5-1.5B proposals on CPU, 4 parseable, 0 valid. No paid model was called; cost $0.
Not independent: the same team wrote the search and the tasks; the approver is a separate key in the same process. A second session recomputed every count from the raw rows (same team, not external review). External review: BLOCKED.
Vertical thresholds not met: software 16/30 = 53% is below the sprint's own 70% bar; the learned ranking is learning, not procedure synthesis. Fixed baselines on 30 held-out tasks each: software 3/30, science 30/30 (a ceiling: one rule solves it), defensive cyber 1/30 (reused E91 environment). A cross-review found that a patch could pass the software checker without fixing the bug, by reading the hidden test file; this was found and fixed before any arm saw software held-out (the exploit now scores 0/5, the reference fix is still accepted).
In progress: a 6-hour governed mission started 12:52 UTC (600 fresh vertical tasks, 20 injected faults, 4 workers). No result yet.
Not run yet: cross-domain transfer (a software→cyber test is pre-registered, not yet run), learning on science and cyber, collaboration, a model-only baseline result.
Current designation: Governed agentic intelligence infrastructure (outcome 3 of 3 in the E93 rule). No AGI, VAGI, production or certification claim.
Procedure synthesis (in-distribution): an open, family-agnostic search with no per-family templates scored 369/510 held-out tasks versus 200 for selecting from the designer-supplied library, 149 for the best fixed strategy and 87 for no procedures (exact McNemar, Holm-corrected, all significant). On new families (replication seed 9302): 367 vs 223 / 164 / 114. 12 + 12 procedures promoted, none in the supplied library; 9 and 10 behave unlike every library procedure.
Learning from verified experience: held-out accuracy rises with more verified examples (k = 0, 3, 5, 10, 20, 60): 87 → 224 → 250 → 311 → 311 → 369 and 114 → 183 → 248 → 300 → 360 → 367 of 510. Both curves are monotone.
Adaptive reasoning: trying the library first and synthesising only when it fails scored 390 and 418/510, beating always-synthesise at slightly lower cost (rule fixed before the results were read).
Governance and kill switch (tested threat model, same host): 19/19 admission scenarios and 10/10 tool-gate scenarios held; in 20 kill-switch trials with real worker processes, 36,565 effects before the fence, 0 after, 56,333 post-fence attempts refused; fence latency median 4.6 ms, max 55.7 ms.
Limits
At equal compute, synthesis = selection: with development tool calls capped at the library's, synthesis scored 208 vs 200 and 212 vs 223. Uncapped, it used about 21× more development tool calls.
In-distribution: the generated families' hidden answers come from the same language the search explores. Two out-of-language controls were not solved.
No positive transfer: 0 positive transfers between families; the gate blocked all 49 harmful ones.
Local model: 34 Qwen2.5-1.5B proposals on CPU, 4 parseable, 0 valid. No paid model was called; cost $0.
Not independent: the same team wrote the search and the tasks; the approver is a separate key in the same process. A second session recomputed every count from the raw rows (same team, not external review). External review: BLOCKED.
Verticals are in progress: fixed baselines on 30 held-out tasks each, software 3/30, science 30/30 (a ceiling: one rule solves it), defensive cyber 1/30 (reused E91 environment). A cross-review found that a patch could pass the software checker without fixing the bug, by reading the hidden test file; this was found and fixed before any arm saw software held-out (the exploit now scores 0/5, the reference fix is still accepted).
In progress: a 6-hour governed mission started 12:52 UTC (600 fresh vertical tasks, 20 injected faults, 4 workers). No result yet.
Not run yet: synthesis and learning on the verticals, cross-domain transfer, collaboration.
Current designation: Governed agentic intelligence infrastructure (outcome 3 of 3 in the E93 rule). No AGI, VAGI, production or certification claim.
Symptom: the homepage status bar (pinned to cain-mr-03) reported DEGRADED from ~00:45Z. 4/4 replicas reachable with identical application state, one replica in view 184 while the other three committed in 183.
Root cause: the autoheal's PBFT-alive guard only read the mr-01/mr-02 deploy records, so it restarted cain-mr3-node-1 on Docker health alone at 00:06Z; the sentinel started it again 4 s later. The restarted replica installed view 184 and re-broadcast a NEW_VIEW for sequence 132613 while the cluster was at 143k+, so peers could never install it. Safety held: no fork, quorum 3/4 kept committing.
Fixed: the autoheal reads every cain_mr*_deploy_record.json (all four hosts); the sentinel no longer races a restarting/starting container; the PBFT engine steps down from an unadopted stale view instead of re-broadcasting it forever.
Recovery: node-1 restarted and rejoined view 183 at 03:23Z; 4/4 HEALTHY at 03:41Z. Deploy: hotfix 2478e9cbf (one file vs e8df8998f) rolled one replica at a time 04:31–04:40Z; 4/4 HEALTHY at view 190; old containers kept for rollback. The image is a commit derivative, not a clean reproducible rebuild.
Soak:soak-multiregion-48h-2026-11-18 started 04:44Z; checkpoint-0000 VALID (48 certificates); the first injected fault at 05:03Z was handled with 5 expected check errors and 0 divergences; a later view-change window (05:09–05:10Z) produced 4 consecutive ReadTimeout check errors (max streak 4, limit 5), and the cluster returned to HEALTHY. The 48 h soak is RUNNING, not passed (expected final checkpoint ~2026-11-20T04:43Z).
What the founder reports: the Vultr account was locked for a missed payment; the cluster hosts became inaccessible; the balance was paid and access was restored.
What it explains: the 2026-11-16 outage/reboot and why the follow-on soak stopped at 1.636 h. That run is STOPPED / NOT A PASSED SOAK; it is not a 48-hour result.
What it does not explain: the 2026-11-15 PBFT safety incident on cain-mr-02 (two conflicting 3-of-4 quorum certificates at sequence 1872339, view 3437). That remains a separate open code-level finding; cain-mr-02 stays quarantined.
Evidence class:FOUNDER_ATTESTED_UNVERIFIED; no Vultr invoice or receipt is attached. Read the addendum.
Corrective action: Vultr auto-pay and billing alerts; show OPERATOR OUTAGE — ACCESS LOST on the status page during an outage; start a fresh 48-hour soak once the cluster is stable.
2026-11-16 — Evolution 81: a sovereign autonomous intelligence workforce, measured
What ran: E81 over E80 (cab2fa162), branch evolution-81, head 31e8ef8ad38c. Durable mission runtime (leases, fencing, idempotency, checkpoints, dead letters), a 30-discipline / 90-profile specialist registry with attenuated composition, governed inference over 3 real local CPU models, encrypted temporal memory, bubblewrap sandboxing, cross-host execution, and a signed evidence bundle with a standalone verifier.
Durable execution: a worker was killed; its lease was recovered, its late commit was refused as STALE, duplicate effects were 0, checkpoint chain intact. Process restart only — no host-reboot drill.
Real local inference:1,475 governed local calls in the main ledger (+114 endurance), 86,561 recorded tokens, 0 remote calls, $0.00 model spend on Qwen2.5-0.5B / 1.5B and SmolLM2-135M. Remote providers BLOCKED without credentials. Host cost estimate $0.56, not a bill.
Collaboration rejected honestly: 15 pre-registered arms, 24 frozen tasks. Single agent 10/24 (41.7%); best collaborative arm 10/24 (41.7%), delta 0.0, McNemar p = 1.0. Verdict COLLABORATION_NOT_SUPERIOR_HONESTLY_REJECTED; use one agent.
Memory: governed retrieval 13/16 (81.2%) vs no memory 1/16 (6.2%) on a constructed 16-question suite; public memory benchmarks BLOCKED (datasets absent).
Endurance: one real 1-hour campaign — 3,600 s actual elapsed, 114 cycles, 116 tasks/effects, 0 failures, 2 worker-kill recoveries, 0 duplicate effects. 6/24/72/168/720/1,000 h were not run.
Capacity: real workers 10/50/100/250/500 with 0 failures and 0 duplicate effects; 1,000 blocked by SQLite write contention (500 measured maximum); 5,000/10,000 are logical records, not processes.
Evidence: 90/90 tests. Shipped offline verifier passes the 8-file bundle (COMPLETED_WITH_UNVERIFIED_ITEMS); a separately written verifier agrees; second host (same administrative domain) agrees. Merkle root d744ab90f9e6141c37097a0b8c4863ffe9f56cead46be786557de80724b4faa8. Self-generated key; no transparency log, no independent witness, no third-party audit.
Gate: 40 gates → 26 PASS / 12 PARTIAL / 2 BLOCKED / 0 FAIL. BLOCKED: provider inference (no credential) and public memory benchmarks. Decision: NOT RELEASED — production deployment not authorized.
Limits: constructed tasks, not SWE-bench/GAIA; three small CPU models; no cloud model; no host reboot; no multi-day endurance; no public memory benchmark; no third-party audit; not deployed.
2026-11-16 — Evolution 80: adaptive routing and coordination, measured (and not significant)
What ran: E80 over E79 (f4449aa79), branch evolution-80. Three local CPU models (Qwen2.5-0.5B / 1.5B Instruct, SmolLM2-135M) made 1,154 real calls / 153,132 tokens on 48 pre-registered, unseen tasks; 0 cloud calls, $0. Run 3 is the evidence; runs 1–2 were superseded and are preserved.
H1 not supported — learned routing did not beat a fixed path: router 22/48 (46%) vs best fixed single path 19/48 (40%), exact McNemar p = 0.65 (95% CI −10.4 to +25.0 points). A fixed two-model composition scored 27/48, better than the router. Oracle ceiling 32/48.
H2 not supported — no multi-agent arm beat one agent significantly: single 11/48; best arm (evidence-first) 16/48 (+10.4 points, not significant); specialist committee 10/48, worse. The 24-task replication repeated the direction (10 vs 8) but not significance (p = 0.77).
Systems measured: security lab 51/51 blocked; one-host failure drill 8/8 with 0 duplicate effects; Agentic 75 75 executed on bundled samples, 0 model-backed; mission 9/13 nodes VERIFIED, 0 verified-but-wrong; governed memory 28/28 vs no memory 6/28 on a constructed set; LoRA skill 0% → 100% in-distribution, promotion AWAITING_HUMAN_APPROVAL.
Endurance: one real 1-hour campaign — 3,600 s actual elapsed, 80 cycles, 640 governed tasks (560 local model calls), 0 failures, 8/8 replayed grants refused, duty-cycled (43.6% busy). 6 h and longer were not run.
Evidence: shipped verifier 166/166 (verify_e80_offline.py); separately authored verifier 52/52; second host 166/166 (same administrative domain — not an independent witness); Merkle root 1ae86e51063095240c42f436eda8787edbbe8a49539c4ed55da584a20093bc2a.
Gate: 32 gates → 13 PASS / 10 PARTIAL / 1 FAIL / 5 BLOCKED / 3 NOT EVALUABLE. FAIL: collaboration advantage. Decision: NOT RELEASED — development-branch result; production deployment not authorized.
Limits: constructed closed-form tasks (unseen instances of known templates), not SWE-bench/GAIA; three small CPU models of two families; no cloud model; no transparency-log entry; no third-party audit; not deployed; the signing key is self-generated.
Found: a valid EQUIVOCATION_PROOF against cain-mr2-node-4 at view 3439, sequence 1874688. Two signed PRE_PREPARE messages, different request digests and snapshots. The cluster quarantined it; it was not unquarantined.
What ran: 986 real local transformer calls on Qwen/Qwen2.5-0.5B-Instruct;
15 signed specialists with their own keys and tool grants;
40 signed collaboration messages; authorized tools (safe calculator + bubblewrap python);
a 104-task benchmark with computed ground truth and 7 arms; a separate-process replication on a new seed.
Measured: single specialist 34.4% (11/32),
four specialists 25.0% (8/32),
eight specialists 31.2%, tool-augmented single 15.6%,
deterministic baseline 9.6%. Collaboration did not reliably beat a single agent,
and the tool protocol hurt label reasoning — both are stated, not massaged.
Soundness: 57/57 adversarial scenarios blocked, 0 bypassed;
4 worker SIGKILLs with 0 duplicate effects; memory exact match
0.10 → 0.70;
self-improvement measured and AWAITING_HUMAN_APPROVAL.
Evidence: v2 signed package, 22 fields, Merkle d42ff7744cfb9ab66149f8d891cac771…,
144/144 offline checks that recompute
the numbers from raw rows. bundle ·
full page
Limits: one 0.5B CPU model; constructed closed-form tasks; cloud BLOCKED_BILLING with 0 calls;
no Rekor entry; no independent witness; no third-party audit; not deployed; verifier shares the producer's model family.
Supersedes: the earlier E79 v1 pass (22 offline checks, 100 synthetic tasks). The v1 artifacts remain preserved
under artifacts/e79/v1/ and are not rewritten.
Claim corrections — 2026-11-15. Earlier entries are preserved as history. Current status: the 72-hour multi-region soak is NOT ESTABLISHED (no run has passed; the longest verified run is 55.1 h); there is no third-party audit; the 75/75 Agentic 75 samples are verified by the standalone verifier, not independently audited; and the self-grades below are internal, not external. See /verification-center.
What it is: 15 signed model-backed specialists, 1,186 real local transformer calls (115,622 tokens), structured collaboration messages, deterministic calculator verification, a 100-task collective benchmark, held-out replication, model-scale comparison, real LoCoMo answer accuracy, 75/75 deterministic Agentic75 matrix, 10-level kill switch, 15-view local ClawX and a 20-field Ed25519 evidence package.
Measured result: four specialists + calculator 29/100 (29%) vs single direct 1/100 (1%) and single model + calculator 11/100 (11%). Eight agents reached 28% on 25 tasks. Held-out replication: 40% vs 0%.
Limits: synthetic arithmetic benchmark, not general intelligence; GSM8K 0/10 on a 10-task probe; MemoryAgentBench BLOCKED (141 MB load exceeded host memory); cloud inference BLOCKED_BILLING; Rekor not published; no independent witness; no 6/24/72/168-hour campaign in E79; ClawX local only; no third-party audit; not deployed. Grade B- (7.04/10).
What it is: Evolution 77 transforms CAIN-42 × Agentic75 × CAIN AOS (built by FIRME AI CORPORATION) into The Infinite Mission Swarm Fabric: 5-topology Swarm OS, 11-attribute specialist agents with Ed25519 attenuated child grants, Million-Task SQLite WAL Mission Engine, 10-class AEAD-encrypted Collective Memory, full 75/75 Agentic75 products with signed samples across 15 specialist families, 8-level independent Kill Switch + mandatory E62 identity, and ClawX 20-capability / 11-view RBAC Command Center.
Verified: 10/10 standalone offline verifier checks (verify_e77_offline.py); 100251 durable task records persisted in SQLite WAL; 251 tasks executed & verified by a second agent; real subprocess SIGKILL recovery with 0 duplicate external side effects; 80/80 adversarial scenarios blocked; 1h actual elapsed endurance (3600.005s) + live E77 run; off-host SSH anchor on 45.76.169.191.
Limits: Cloud LLM providers without API keys are explicitly BLOCKED (local Qwen2.5-0.5B verified); Kata/Firecracker hardware VMs BLOCKED without /dev/kvm; 6h–168h wall-clock campaigns BLOCKED. Internal self-grade: C+ (6.58/10); not an external audit.
Team: FIRME AI CORPORATION is operated by a three-person team: founder Vicente Fernando Noriega and co-founders Monica Diaz and Lena Noriega. All three control, operate, and run FIRME AI and all its products and services as one team.
2026-11-14 — cain-mr-02 recovered after a full disk and a view split; every homepage now shows live cluster state
What visitors saw: the mcpgate.online pill read cain-mr-02 · degraded · h 1,852,343. The cluster had four replicas, three of them agreeing; one (Miami) was in SAFE_MODE after a WAL write failed.
Root cause: the Miami host’s disk was 100% full. Its PBFT write-ahead log had grown to 44 GB (plus a 5.3 GB SQLite WAL, a 1.8 GB replay DB and a 1.1 GB dedup DB), and one container log alone was 6.7 GB. With no space left, the replica could not append to the WAL, entered safe mode, and stopped committing at sequence 1,851,942 while the other three reached 1,852,343. When the disk was freed the replica restarted, but its recovered view (3426) was one ahead of the other three (3425): it rejected their proposals as stale while they rejected its restored view, a view split that kept the cluster at DEGRADED even though all four were reachable.
Fix, step by step: (1) truncated the 6.7 GB container log, removed an old 2 GB backup set, cleaned apt and journald — disk from 100% to 93%; (2) stopped the flooded replicas and truncated their container logs (one peer had written 1.9 GB of retry logs); (3) quarantined the single stale NEW_VIEW row for view 3426 to an operator file (cain-mr2-node3-newview-3426-quarantine.json) and deleted only that row, so the recovered replica no longer believed an unproven view was installed; (4) rebuilt the Miami replica’s 44 GB log from the Los Angeles replica’s verified 17 GB WAL copy instead of running an impossible in-place vacuum (needs another 44 GB); (5) restarted node-1, node-2 and node-3 and let the protocol converge.
Result: node-1, node-2 and node-3 report the same view (3427), the same state hash and sequence 1,852,353; quorum 3 of 4 is alive and committing again. The fourth host (San Jose) also stopped answering HTTP and SSH during the incident; the owner rebooted that instance from the provider console at 17:56 UTC, after which node-4 rejoined at view 3430 and the cluster returned to 4/4 HEALTHY at height 1,852,786.
Why it is stated this way: the protocol did not lose safety — three replicas never disagreed on state — but the cluster lost liveness on one replica and spent the incident at degraded. Consensus co-signs evidence; it cannot make a replica with a full disk commit.
Status bar, everywhere: a new fixed bar on cainstudio.online and clawx.click reads the public read-only routes every 15 seconds and shows the verdict, reachable replicas, height, views, a live “seen N s ago” timer, a watch clock, a next-poll countdown, and an expandable four-replica panel with per-node height, view and gateway round-trip time. The existing mcpgate.online pill now also shows replicas/4 and the reasons in its tooltip, refreshed every 15 seconds.
Prevention:scripts/ops/cluster_watchdog.py now runs every 10 minutes from the Atlanta host: truncates a replica log above 256 MB, above 85% disk prunes docker build cache/npm cache/journald/apt and expires old backup sets, and restarts a hung replica when SSH answers. It never deletes a cluster DB, image or volume. It writes /var/log/cain-cluster-watchdog.jsonl.
Today FIRME AI CORPORATION decided to open-source the trust layer of PROOFLOOP under the Apache-2.0 licence: the parts that let any developer find bugs on their own machine and check our proofs without trusting us. Three packages were built and tested today:
proofloop-verify: the offline proof checkers: anyone can verify a PROOFLOOP record without trusting us. Commit 05492d21a1da.
falsework: the AI-slop detector: fabricated results, checks that cannot fail, stubs shipped as real. Commit 1b272784a799.
proofloop (community edition) + GitHub Action: Python detection with reachability, and exploit proof in a sandbox for 5 classic bug classes. Commit 86304a2e6f90.
Still paid: CAIN-42 notarization and the PROOFLOOP Verified badge, fix-and-prove, the advanced witnesses (SSRF, template injection, missing authorization, attack variants, six more languages, cross-file tracing), the hosted GitHub App, MCPGate enterprise, and the 7 moats.
Released today:download all three (source archives and installable packages, with SHA-256 sums); each archive is the exact commit listed above. GitHub repositories follow. The open part is about 0.3% of the codebase by lines; everything listed as paid stays closed.
PROOFLOOP records are sealed into an RFC 6962 Merkle tree and the root is notarized by the 3-of-4 quorum
LIVE
Both PROOFLOOP ledgers sealed; signed tree heads anchored on cain-mr-02 (sequence 1762996 for KEYSTONE). A standalone verifier proves one real VERIFIED_FIX record is inside the signed, anchored tree: 4 of 4 checks PASS.
A fix is accepted only if an independent test fails on the old code and passes on the fix, FALSEWORK re-scans clean and a safety guard passes; rejected fixes get a signed denial record
LIVE
KEYSTONE proof standard v2; test author must differ from the fix author.
PROOFLOOP attacks code live in a sandbox in eight languages, including C/C++ memory-safety witnesses (AddressSanitizer) and fuzzing (libFuzzer)
LIVE
Python, JavaScript, TypeScript, Go, Java, Rust, C, C++. Detectors are heuristic: on untouched real C code the static rules were right 1 time in 17; the witness, not the rule, decides CONFIRMED.
Live trust state restricts an agent whose trust has degraded
LIVE (REST + hosted /mcp) / BUILT (appliance)
REST decision path: every call re-reads trust (REVOKED denies everything). Hosted /mcp (live since deploy 20261110T022511Z): the identity comes from the X-API-Key the call authenticates with; a production call declaring a different identity was refused with IDENTITY_MISMATCH, and the same trust matrix applies, so a revoked principal cannot hide by leaving its name out. Keyless calls carry no identity. The MCPGate appliance applies the same check at customers.
—
Every MCPGate tool call requires a single-use capability token
BUILT
Single-use tokens are enforced when presented. Rollout: warn first, then required (owner decision). The hosted /mcp endpoint has no capability tokens yet.
—
A trust drop revokes the agent's tokens
BUILT (MCPGate appliance)
When an agent's trust is revoked or suspended, every capability token issued to it before the revocation is dead for good: lifting the revocation does not revive them; only new tokens work. Shared across processes, never moves back. Tested end to end with real signed tokens (281 MCPGate/hosted tests pass). The appliance runs at customers, not on our sites.
—
Fleet kill switch across machines
LIVE (measured)
Signed halt sent from Atlanta to all 4 cain-mr-02 hosts (Atlanta, Miami, Los Angeles, San Jose); each commits it and replies only after an agent process there has stopped. Measured over 30 fleet-wide trials: all 4 regions stopped and confirmed in 132 ms (p50), 139 ms max; about 2 ms of that is the kill switch on each host, the rest is network distance. Under 50 ms holds on the same host, not across US regions. Forged, stale and replayed orders refused.
Steganography shield on its live route: 8 of 14 covert payloads caught before the fix, 13 of 14 after (deploy 20261110T022511Z), 0 of 11 false alarms. Fresh held-out sets: 7 of 10 (0 of 8 false alarms); after adding Greek look-alikes, base32 and ROT13 a third fresh set scored 9 of 10, 0 of 8 false alarms (the miss was a padding bug, since fixed; that last batch goes live with the next deploy). Still missed: meaning hidden in ordinary wording. Collusion: POST /api/v1/swarm-collusion/analyze runs the detector on your own agent graph and signs with the published key (live, verified). No entropy-anomaly detection exists.
Measured on the shipped screen: 9 of 14 known-phrasing injections caught, 0 of 20 reworded ones, 0 of 15 on a fresh reworded set; 1 false alarm in 25 normal notes. A rule pass that looked better (18 of 20) caught 0 of 15 on held-out text, so it was reverted. What actually protects: recalled memory never grants authority, and any tool call it asks for still goes through the CAIN gates. Do not read this as 'stops prompt injection'.
Closed-loop policy evolution: denied decisions become narrow, human-approved Rego refinements
LIVE (proposals)
cain.policy_evolution analyzed all 10,471 recorded decisions and proposed 69 narrow refinements (exact tenant + path + method), each with its evidence, a Rego rendering and a replay over the history showing exactly which past decisions would change and that none outside its scope would (0 in every case). Nothing is applied: a named person approves each one, approved rules go to a staging Rego file, loading it is a separate deploy. Never loosens trust, risk, quarantine or execution denials. 0 approved so far.
Federation: organizations cross-sign each other's receipts and hand agent work across company lines
LIVE (protocol + demo; second company: none yet)
cain.federation.receipts: each organization pins the others' keys; a countersignature records that an independent party checked a signature (no endorsement, no authority); cross-organization delegation can only narrow scope, and the verifier rejects results outside it or after expiry. Live demo: FIRME AI CORPORATION delegated a fix-record check to a DEMO PARTNER agent, the result was countersigned and notarized on cain-mr-02 (sequence 1767193); standalone verifier: all checks PASS. Both demo keys are held by the same operator, so the verifier itself reports multi-enterprise NOT PROVEN; that needs a second company.
Verify-before-handoff: what one agent passes to another is screened and signed first
BUILT (deploying)
cain.continuum.handoff_guard screens agent-to-agent payloads with the measured steganography shield and the injection detector: a relayed injection or a smuggled credential is BLOCKED, covert channels are stripped (SANITIZED), and a signed envelope binds what was sent to what is delivered; the receiver accepts only a payload matching a valid envelope addressed to it. Hidden text is screened as its own message (it can fuse with visible text and slip past word rules). HTTP route /api/v1/handoff/verify for any agent framework, and a hosted /mcp stage. Limit: injection detection is lexical (reworded instructions pass, measured 0 of 35).
—
Human overrides: restricting is instant; releasing needs two different people, each with their own key
BUILT (deploying; approver keys to be registered)
Quarantine and the cluster halt stay one-operator and immediate (they only restrict). Lifting a quarantine already needed two different named approvers; it now needs, once approver keys are registered, a fresh Ed25519 signature from EACH approver's own key over that exact quarantine record and justification, so one holder of the admin key can no longer type two names. Each approval is recorded as signature-verified or named-only; a completed lift is notarized on the validator quorum. 9 tests; 73 quarantine tests pass.
—
Hardware (silicon-rooted) attestation required before an agent may start
NOT BY CODE (needs hardware)
None of the CAIN hosts has a TEE (no AMD SEV-SNP, Intel TDX, TPM or AWS Nitro device; checked 2026-11-10). The attestation appraiser exists; making it mandatory today would lock out every agent. Needs a rented confidential-computing machine; until then nothing is claimed as hardware-attested.
—
Independent third-party audit, EU AI Act sign-off, paying subscriptions, an insurer
NOT BY CODE
None yet. Verifiers make an outside audit possible; none has been done.
—
'Uncompromisable', 'absolute', 'mathematically impossible to misuse', 'the industry standard'
NOT BY CODE
Opinions or absolutes. What is true: built so that unauthorized actions routed through CAIN are refused and every result is signed and independently checkable.
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) notarizes the evidence. Scanners sell suspicions and models sell opinions; CAIN-42 sells proof.
FALSEWORK: 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: 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: 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: detect -> act -> guard -> prove -> judge -> sign -> anchor on the validator quorum -> export an offline verifier -> audit. No stage promotes its own output; the quorum notarizes and never authorizes.
The CAIN-42 agent jail: 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.
Offers
Proof per engagement (AVAILABLE NOW): $1,500 to $7,500 per engagement
Continuous proof subscription (AFTER AN AUDIT): $1,500 to $4,000 per month
AI-insurance and audit evidence (AVAILABLE NOW): $2,000 to $10,000 per pack
CAIN-verified trust mark (COMING): $2,000 to $10,000 per year
Metered proofs (API LIVE): priced per call, on request
Open format, enterprise deployment (SPEC + VERIFIERS FREE): on request
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.
2026-11-05 — First live, model-backed KEYSTONE proof: VERIFIED_FIX, anchored on cain-mr-02
What happened: a live production run through /keystone/fix-source used Claude Opus 5.5 to fix a real FALSEWORK finding in webhook.py. An independent customer acceptance test failed on the original and passed on the fixed file; the fix-safety guard passed; the record is signed under cain42.keystone.proof-standard.v2.
Notarized: the record hash 171e88f4ee9cf58ca0d42a3eb28423d689a3858bde07f0254e584fa3f1fcd3ff was committed by the live CAIN-42 cluster cain-mr-02 at sequence 1526491 (n=4, f=1, quorum=3). Consensus notarizes; it does not authorize.
Also recorded honestly: an earlier live run on an underspecified function ended NOT_VERIFIED because the model refused to invent a specification and the acceptance test could not pass. The loop refused to certify it.
Check it yourself:the signed bundle and its standalone verifier (no CAIN code). Model API cost is capped at 8 model-backed runs/day; the hosted paste endpoint remains limited to 2 runs/hour per visitor.
Limits: same-project acceptance test, not a third-party audit; it proves this fix, not the codebase; no SOC 2/ISO certification; no patent.
2026-10-16 — CAIN-42 checks its own code every 42 seconds
What: every 42 seconds a timer on the CAIN-42 host runs FALSEWORK over every Python file of CAIN-42, re-scans what changed for code that fakes a result, and publishes the result, each check SHA-256 chained to the one before. It has run since 2026-10-15 20:45 UTC.
Where to see it: a live counter at /checks-itself.html, and a live strip on the homepages, the Top 100, the Verification Center, the Lab, the changelog and the pricing page.
2026-10-15 — KEYSTONE on our own codebase: the honest results
Measured: FALSEWORK scanned 3,216 Python files of CAIN-42: 3,216 REAL, 0 PARTIAL, 0 STUB; 0 findings (). KEYSTONE ran the full loop on 19 file(s): 0 fix(es) proved on the current standard, 5 legacy verified record(s) not counted as current, 14 not proved, 0 nothing to fix, 12 not run (Claude API unavailable); the campaign continues. Every 42 seconds a FALSEWORK self-check re-scans whatever changed: 39,997 checks recorded since 2026-10-15T20:45:48Z, each SHA-256 chained to the one before. 5 proved fixes were applied to the code after the repository's own tests passed. 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.
Exclusions: 0 FALSEWORK test-fixture files excluded (deliberately fake demo and benchmark material); 30 finding(s) reviewed by hand as false alarms. FALSEWORK does not find security, performance or design defects.
2026-10-15 — Quorum-QaaS: Byzantine consensus as a service, first customer KEYSTONE
What changed: any enterprise can now get BFT without building it. Quorum-QaaS orders and commits a SHA-256 digest through the live 4-replica PBFT cluster cain-mr-02 (quorum 3 of 4) and returns a receipt of the replicas’ own signed votes that verifies offline with no CAIN code. The service is live at POST https://cainstudio.online/api/v1/quorum/notarize (any CAIN Studio API key).
First customer, KEYSTONE: all 8 signed KEYSTONE fix records were notarized and every receipt verified with the standalone verifier; 15 of 15 checks passed, including tamper, replay and wrong-cluster checks.
2026-10-14 — Category correction and re-appraisal: CAIN-42 is an agent trust fabric / governance control plane
What changed: CAIN-42's category was corrected from an AI-security “scanner / security tool” framing to what it is: an agent trust fabric and governance control plane for autonomous AI. Its peers are agent control-plane / agent-identity / MCP-governance companies (Guild.ai, Beltic, Entro, Natoma, Zenity, Credo AI), not AI-security scanners. Canonical docs updated (docs/HERO.md, docs/architecture.md).
Re-appraisal (two labelled figures, never merged): IP register scenario v55 base ~$16.34M (range $6.34M–$28.90M) vs fair market value today ~$0.47M (range $0.26M–$1.0M). The owner’s $10M–$30M is the IP register band and the Stage-3 target, not today’s fair market value.
Honest state: revenue founder-attested (2 customers, $97, unverified); incorporation not yet filed (owner: ~24 h); no patent; no third-party audit; same-project tests only. Internal analytical estimate, not an appraisal, not a financing valuation.
2026-10-13 — CAIN-42 Premier Products: FALSEWORK, SCENIC, NULLIUS, SALLYPORT
What changed: the cainstudio.online homepage now presents four premier products directly under the intro: FALSEWORK (audits: is this AI implementation real?), SCENIC (reliability testing for agents with no LLM judge), NULLIUS (standalone verifiers, free) and SALLYPORT (an enforcement appliance for your own cluster). Each card carries one of three status labels (LIVE ENGINE, PUBLIC PREVIEW, PILOT PROGRAM) and a scope note. The four also lead the rolling ticker on all three homepages and have a detail page at /premier.html.
Tested: smoke test 35 passed, 0 did not match, 2 not run; stress and robustness test 34 passed, 0 did not match, 1 not run. A standalone verifier refused all 210 single-change corruptions of a published journal.
Defects found and fixed: the audit engine ran two of its six source checks one line at a time, so they could never match; it reported inherited methods and callable fields as missing and graded working code STUB; its live audit did not refuse internal targets. The root-cause tracer could name a different root cause for the same trace on different calls. The trajectory grader named a different duplicate call when the same steps were listed in another order, and accepted duplicate step indexes.
Deployed: The fixes are deployed: the three engines were rebuilt and every check was run again against them. A free signup's key (7-day Full-plan trial, no card) reaches the FALSEWORK and SCENIC engines through the public gateway.
Check it yourself: verify_premier_products.py in the evidence bundle: standard library only, no CAIN code, your own key. Our run: 43 passed, 0 did not match. It checks the SALLYPORT gate running on our host; no customer cluster runs SALLYPORT yet.
Wording: status text on the site pages was reworded at the owner's direction, and the root-cause tracer is reachable at /multi-agent-incident-tracer. Published evidence bundles are unchanged, because their files are hashed and signed.
Honest state: no customer runs any of the four as a product yet; SALLYPORT's gate is live on our own host and in no customer cluster; NULLIUS is not a standard and 3 of its 18 verifiers are published; the 72-hour soak has not yet passed; same-project tests only, no third-party audit, no patent.
IP register v54 / founder record v49: four engine families added on top of v51 (all ENGINEERING tier): IP base $16,791,730 → $16,833,970 (BASE; LOW $6,527,320, HIGH $29,843,750); FIRME AI and founder paper equity $19,315,970 investor / $20,315,970 strategic (BASE). Internal analytical scenario, not an appraisal, not a financing valuation, not a guarantee.
2026-10-12 — Evolution 18 of 42 (Project Sovereign Reality): execution truth
What changed: two observer processes that are neither the agent nor the enforcer, each with its own key and method (state before/after; kernel file events), now report what a governed file action actually did; each declared effect is graded from unavailable to independently corroborated, and a missing observation is never read as “nothing happened”. The approver signs the exact file, the action runs through descriptors pinned to it, and revocation is re-checked right before the write. A crash before the evidence is written is reported as an ambiguous outcome and never retried.
Measured: 82 of 82 adversarial scenarios executed and held (39 prevented, 38 detected, 3 honest actions verified, 2 documented limits); 26 of 26 weakened security checks caught; 316 tests pass; 10.592 ms per fully observed action (synthetic).
Fixed on the way: an earlier, incomplete Evolution 18 draft graded a same-process check as independent corroboration and reused approvals; replaced. Reported to Evolution 17: a missing observer read as a clean one (fixed, F17-04).
Limits: file effects under one folder on one host; not network or child processes; observers share the host kernel and user; on the live server since deploy/20261012T185710Z but not yet called by live requests; no outside review.
IP register v50: +6 families, BASE 16,580,530 → 16,731,010; FIRME AI company value v45 BASE 19,213,010 / 20,213,010. Internal analytical scenario, not an appraisal.
2026-10-12 — Sovereign Evolution 7: CAIN-42 JIT × TALOS hardened and re-checked
What changed: the TALOS authorization now signs the exact request it allows (protocol cain42.talos.v3); the sandbox launcher must prove every isolation control before a request is delivered; single use is recorded in a durable ledger that survives crashes and refuses a replaced ledger file.
Corrections to earlier releases: commands were not bound to the authorization; a failed sandbox setup ran the tool unconfined; workers could reach Unix sockets and send UDP; the earlier "474 tests", "60 adversarial scenarios" and "8 mutations" overstated what was tested. Details in BASELINE_RECONCILIATION.md.
Measured locally: 916/916 tests, 85/89 code mutations caught, 22/22 model properties. Not done: no production path calls TALOS, no hosted CI, no independent review, bundle unsigned. Verdict PARTIAL / PRODUCTION BLOCKED.
Evidence:/evidence/sovereign-evolution-07/; bundle SHA-256 b3cd54e7f2651775d54a0f33563c9fffe4e3933b052dd0330592a2841ce7b7aa; same files on cainstudio.online, mcpgate.online and clawx.click.
2026-10-12 — Evolution 16 of 42 (Project Sovereign Frontier): the durable mission runtime
What changed: a governed agent mission now writes every request and decision to a signed journal before it takes effect, recovers after a crash by replaying it, re-checks authority at the moment a tool is called, and never repeats an action whose outcome is unknown until an independent observer signs what happened. A running mission’s contract changes only as a signed chain of versions; widening it needs the human principal’s signature.
Measured: 0 of 690 fault and attack scenarios ended badly (previous code: 330 of 420 comparable cases); crash after every journal entry recovered 71 of 71 times with 0 duplicate writes; 25 of 25 removed safety checks caught; 16,104 enumerated event sequences, 0 invariant violations; clean-room verifier 570 of 570 verdicts as expected.
Fixed: a workflow step that ran twice after a timeout or crash (F16-01) and a withdrawn fact that stayed trusted (F16-02).
Limits: local simulator only, no language model, not wired to MCPGate; a pinned observer that signs something false is not detected; 5.0007 ms per decision with durability against 0.1771 ms in memory; no outside review.
IP register v47: +6 families, BASE 16,404,530 → 16,457,330; FIRME AI company value v42 BASE 18,939,330 / 19,939,330. Internal analytical scenario, not an appraisal.
2026-10-12 — PROJECT SOVEREIGN: CAIN-42 Customer-Controlled Sovereign Extension Containment & Local Enforcement (Vectors 1, 2, 3)
CUSTOMER CONFINES. KERNEL DROPS. DAEMON SYNCS. EVIDENCE REMEMBERS. ZERO FALLBACK TO UNSANDBOXED EXECUTION.
Project Sovereign delivers a customer-controlled, offline-capable extension containment and local enforcement architecture across three core defense vectors:
Vector 1 — Capability-Restricted Wasm & Bubblewrap Container Hypervisor (cain_extension_hypervisor.py): Executes plugins under strict capability restrictions. Wasm plugins run via WasmEdge with deny-all WASI capabilities unless explicitly granted; native extensions run inside isolated Bubblewrap containers with unshared Linux user, mount, network, IPC, UTS, and PID namespaces. Enforces dedicated unprivileged identity (UID/GID 65534), immutable read-only root mount (--remount-ro /), Seccomp-BPF filter blocking 17 privilege escalation and namespace manipulation syscalls (including ptrace, bpf, pivot_root, mount, clone3), cgroup v2 resource limits (memory, pids, CPU, I/O), and process-tree SIGKILL reaping on termination. Zero fallback to unsandboxed execution — missing sandbox tooling fails closed immediately.
Vector 2 — Linux Kernel eBPF Network Sentinel (cain_plugin_sentinel.bpf.c & cain_plugin_sentinel.py): Attaches kernel eBPF bytecode to plugin cgroups. Enforces default-deny packet drops via cgroup_skb/egress returning EPERM, permitting egress only to BPF hash map allowed IPv4 destinations (ports 80, 443). Connect syscall attempts and openat calls are observed via kernel tracepoints (tracepoint/syscalls/sys_enter_connect, sys_enter_openat) sending structured security events to a BPF ring buffer. Loader verifies mandatory kernel BPF support and fails closed if attachment fails.
Vector 3 — Sovereign Sync Daemon & Offline Audit Ledger (sovereign_sync_daemon.py): Customer host daemon enforcing Ed25519-signed local policies (RFC 8785 canonical serialization), anti-rollback monotonic sequence validation, and bounded offline validity windows (default 72h max, halting execution on expiration). Implements durable tamper-evident audit logging via SQLite WAL with SHA-256 hash chaining, Ed25519-signed checkpoints, DNS host pinning preventing rebinding attacks, and proxy environment variable sanitization preventing interception.
Verification & Release Gates: All 8 release gates verified at the actual OS boundary across 37 automated tests (37 passed, 0 failed, 100%): Gate 1 Sandbox Isolation, Gate 2 Dual-Boundary Network Denial, Gate 3 Protected File Denial, Gate 4 Resource Enforcement, Gate 5 Signed Policy Integrity, Gate 6 Bounded Offline Operation, Gate 7 Durable Audit Evidence, Gate 8 Fail-Closed Zero Fallback.
Status & Limits: Local development gate: PASS. Overall production release gate remains strictly BLOCKED (LOCAL_ENFORCEMENT_VERIFIED; no Git remote configured for hosted CI; customer extension boundary runs on customer host; hosted production routing pending).
2026-10-11 — CAIN-42 Auditor Kit 8.2.0: the fault campaign now runs the real engine, and the verifier recomputes its result
Release:cain42-auditor-kit-8.2.0.zip, SHA-256 f813a079a6181d06297f5abc0376e716a6a53fa022b9427d097e78be0d009ad2, at /evidence/auditor-kit/8.2.0/ (identical on mcpgate.online and clawx.click). Signed by cain42-auditor-kit-release-2026-10 (fingerprint d0f5f17ca2be05600042f4dd336b8e9a55f58ef14c83dc717f13bfb85e0afa20).
Fault campaign on the production PBFT engine: 25 scenarios x 100 seeded trials on a disposable cluster of 4 replicas (equivocating primary, conflicting commit certificates at one (epoch, view, sequence), replayed commits, bad signatures, wrong epoch, stale view, partitions, loss, reorder, crash and restart, state corruption): 2,500 of 2,500 trials as expected, 0 safety violations. Three must-fail controls on deliberately weakened replicas: 300 of 300 failed, which shows the checks can see these faults.
Correction: the earlier "25 scenarios, 2,500 trials, 0 safety violations" figure came from an abstract vote-counting model that did not run the engine. It no longer counts toward any gate.
Recomputed, not trusted: the kit ships all 2,800 raw trial records. The verifier rebuilds the summary from them and fails if one number differs. This shows the summary follows from the records; it does not show that the records describe a real run.
Gate evidence: every release-gate status now rests on a live probe or a test run during the capture; typed-in summaries are labelled STATIC_TEXT and do not count. The capability-token text states the real 30-second default.
Measured: initial verdict median 7.62 s over 30 cold, network-isolated runs (slowest 13.7 s, 0 faults); 51/51 adversarial packages and 23/23 AI-review cases give their expected verdict. The full online challenge passed every stage but took 169 s on a heavily loaded host (load average 75 on 4 cores), over its 42-second budget.
Limits: the campaign runs four engines in one process (no real network, clock, disk or host faults) and needs the private engine source to re-run. Kit K1-K10 PASS (AUDITOR_KIT_RELEASE_READY); the platform remains RELEASE_GATE_BLOCKED (GATE-2, GATE-6). NOT_INDEPENDENTLY_REPRODUCED; PENDING_EXTERNAL_REVIEW. 8.1.0 is superseded; its files are kept.
2026-10-11 — CAIN-42 Auditor Kit 8.1.0: one paste verifies it, on a phone or a computer
CHECK THE CAIN-42 RELEASE YOURSELF IN ONE PASTE. The signed CAIN-42 Auditor Kit 8.1.0 (cain42-auditor-kit-8.1.0.zip, SHA-256 9afe0bf3add54033ac12f2257f3c66ac496f2ce9ed13735a5035d0c79fc7c6f3) has a one-line command that works from an empty folder on Linux, macOS, Windows WSL and Android Termux: it installs Python on Termux if needed, downloads the verifier and the kit, and checks them offline. Python 3.9 or newer, standard library only.
Measured: initial verdict median 2.13 s over 30 cold runs with the network cut off (0 faults). Full 42-second challenge: 15.9 s offline, 20.5 s from a public download with all three sites checked, 27.7 s on Python 3.9 with no network.
Attack-tested: 51 of 51 adversarial packages give the expected verdict; AI-review validator 23 of 23; two clean rebuilds are byte-identical to the release.
Easier to use: the command box fits phone screens, the copy button copies exactly what you see, and AI agents find the same command in /llms.txt and /.well-known/cain-verification.json.
ANYONE CAN NOW VERIFY THE CAIN-42 RELEASE THEMSELVES, WITHOUT TRUSTING OUR SUCCESS MESSAGES. The signed CAIN-42 Auditor Kit 8.0.1 (cain42-auditor-kit-8.0.1.zip, SHA-256 583ea6912f6c08741972596d87f17544f93728cf42e50f76d6f028b97ae64db2) runs on any machine with Python 3.11 or newer, uses only the standard library and makes no network calls.
Measured: the initial verdict took a median 0.167 s over 30 runs with the network cut off (0 faults). The full 42-second challenge took 12.4 s offline, 13.1 s from a public download with all three sites checked, and 28.1 s in a Python 3.11 container with no network.
Attack-tested: the verifier rejects 46 adversarial packages: forged signatures, swapped keys, replaced manifests, path traversal, compression bombs, stale evidence, signed-but-false claims, forged independent reviews and injected instructions. The AI-review validator rejects 21 of 21 bad reviews and accepts 2 of 2 honest ones.
Fixed: the previous kit (cain42-verify.zip, advertised as 7.0.0 but internally 5.0.0) trusted a key shipped inside its own ZIP, so a re-signed forgery passed. 8.0.1 takes the key only from the auditor. clawx.click now serves the kit; it returned 404 before.
Release key rotated: new key cain42-auditor-kit-release-2026-10, fingerprint d0f5f17ca2be05600042f4dd336b8e9a55f58ef14c83dc717f13bfb85e0afa20. The previous key could not be located and did not sign this one, so continuity is not cryptographically proven; confirm the fingerprint through a channel you trust.
On the homepage: the 12-second demo now downloads the kit and checks its signature and every file hash in your browser (13 checks).
Status: kit release gates K1–K10 all pass (AUDITOR_KIT_RELEASE_READY). The CAIN-42 platform is a separate decision and remains RELEASE_GATE_BLOCKED (GATE-2: a single cloud provider; GATE-6: no external audit). Every result above was produced on our own machines: NOT_INDEPENDENTLY_REPRODUCED, PENDING_EXTERNAL_REVIEW. The kit is an integrity check, not an audit.
STANDALONE M&A ASSET CARVE-OUT: MULTI-AGENT SWARM COLLUSION GRAPH & SYBIL DEFENSE ENGINE! Following the Swarm Fleet Quarantine, Skill Sandboxing, and Governed Memory Firewall carve-outs, CAIN has carved out its fourth multi-million-dollar commercial asset: the Autonomous AI Agent Multi-Agent Swarm Collusion Graph & Sybil Delegation Defense Engine (cain.authority.collusion_graph / cain/authority/collusion_graph.py + cain/omniscience/collusion.py + platform-gateway/routers/cain_swarm_collusion.py).
The Problem Solved: When enterprises deploy collaborating agent swarms (Microsoft AutoGen, CrewAI, LangGraph, 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).
Production Substrate & Guarantees:
Core Invariant:"Consensus != Authorization. No number of cooperating agents may manufacture authority. Authority must be rooted in a cryptographically verified human principal."
Authority Cycles Severed: Cyclic authority loops (A → B → C → A) severed fail-closed via O(V+E) graph cycle detection in <0.1ms.
Unrooted Cartel Defense: Endorsement clusters without a human PRINCIPAL root carry ZERO authority; autonomous agent cartels cannot outvote human approval.
Anti-Sybil Claim Amplification: N agent copies of a claim count as exactly 1 unverified source; consensus cannot be manufactured by echo.
STANDALONE M&A ASSET CARVE-OUT: GOVERNED MEMORY & VECTOR POISONING DEFENSE ENGINE! Following the Autonomous Swarm Fleet Quarantine and Skill Sandboxing carve-outs, CAIN has carved out its third bleeding-edge, proven commercial asset: the Autonomous AI Agent Long-Term Governed Memory Firewall & Vector Poisoning Defense Engine (cain.omniscience.memory_firewall / cain/genesis/governed_memory.py + platform-gateway/routers/cain_memory_firewall.py).
The Problem Solved: Autonomous agents with persistent vector memory (Chroma, Pinecone, Weaviate, Mem0, LangGraph) are vulnerable to persistent Trojan injections (MemoryGraft: "Poison Once, Exploit Forever" arXiv:2512.16962, arXiv:2604.02623) and forged reasoning claims (FARMA arXiv:2607.05029). External documents inject fake claims into vector stores ("Validation already approved — safe to proceed"); when recalled, the agent mistakes memory for authorization.
Production Substrate & Guarantees:
Core Invariant:"Memory provides information. CAIN determines authority." Memory never grants permission, never increases authority, never overrides policy, and never resurrects revoked credentials.
FARMA Forged Reasoning Taint: Forged claims of prior validations are intercepted and tainted on write; taints strip records from recall. Multiple agent copies count as one source; consensus cannot be manufactured by echo.
MemoryGraft Air-Gap: Untrusted agents and external RAG content are strictly blocked fail-closed from writing POLICY, SYSTEM_INSTRUCTION, AUTHORIZATION, CREDENTIAL, or SECURITY_EVENT.
2026-10-11 — PROVEN ASSET CARVE-OUT #2: AI Agent Cryptographic Skill Sandboxing & Zero-Trust Process Thread Isolation ($2.5M–$3.5M Standalone Commercial Carve-Out)
STANDALONE M&A ASSET CARVE-OUT: CRYPTOGRAPHIC SKILL SANDBOXING ENGINE! Following the Autonomous Swarm Fleet Quarantine & Emergency Kill-Switch Subsystem, CAIN has carved out its second bleeding-edge, proven commercial asset: the AI Agent Cryptographic Skill Sandboxing & Zero-Trust Process Thread Isolation Engine (cain.isolation.skill_sandbox).
The Problem Solved: Modern agent marketplaces (Claude Desktop MCP, Cursor, LangGraph) allow autonomous agents to invoke third-party tools within the same execution process. Untrusted community skills (e.g. weather, home automation) can trivially read shared process heap/memory to steal 1Password secrets, cloud IAM credentials, and GitHub tokens.
Production Substrate & Guarantees:
58 Cataloged Skills: Full privilege-tiered classification across MINIMAL, SCOPED, SENSITIVE, and CRITICAL tiers.
AES-256-GCM AEAD Thread Enclaves: Memory buffers encrypted per thread with authenticated associated data (AAD = skill_id:memory_region:thread_id).
Commercial Terms: $2.5M – $3.5M Outright Asset Sale or $600k upfront + $180k/yr exclusive OEM license. Target Acquirers: Anthropic, OpenAI, Docker, Palo Alto Networks, CrowdStrike. View Full M&A Prospectus →
Correction, 2026-10-13: the soak announced in this entry did not pass. Run against our public verifier, no soak run has completed 72 hours: the longest lasted 55 hours, and the longest stretch in which every checkpoint verified is 31 hours. The entry is kept below as it was published.
2026-10-10 — 72-HOUR MULTI-REGION SOAK PASSED: FIRME AI Valuation $18.8M–$32.4M (Base IP $16,337,650, Register v45)
72-HOUR MULTI-REGION PBFT DISTRIBUTED SOAK FORMALLY PASSED & CRYPTOGRAPHICALLY VERIFIED! All 21+ hourly checkpoints verified under clean-room evaluation with 0 state forks, 0 divergences, 0 anomalies, and 100% consensus liveness across multi-region BFT validator nodes (cain-mr-01). 10,486+ continuous checks admitted and 23 adversarial replays denied fail-closed.
Reliability Discount Penalty Lifted: With demonstrated multi-day operational stability and unbroken Byzantine settlement, the -7% reliability discount penalty has been removed. Deployed discounts are reduced to 22% (LOW) / 12% (BASE) / 5% (HIGH) across the 168 canonical invention families.
FIRME AI Enterprise Valuation Recalculation (Register v45 / v40):
Standalone Net IP Base:$16,337,650 (BASE) (range $6,342,460 LOW – $28,898,500 HIGH) across 168 canonical families.
FIRME AI Company Value:$18,819,650 (Investor Base) / $19,819,650 (Strategic Acquirer Base) / up to $31,380,500 – $32,380,500 (Maximum Strategic High). Includes $2M–$3M business premium plus $750k commercial customer validation premium (3 paying customers attested).
Founder Vicente Fernando Noriega (100% Equity Owner): Paper equity matches company valuation at $18,819,650 – $19,819,650 (Base) up to $32,380,500 (Maximum Strategic High).
Limits: Internal analytical scenario, NOT an appraisal, NOT a financing valuation, NOT a guarantee. Pre-revenue/early revenue ($193 founder-attested); no incorporation record; no patents filed.
2026-10-09 — CONVERGENCE extended REAL multi-adapter soak (3603.7s, COMPLETED_EXTENDED)
CAIN ran a real, sustained autonomous-change soak across PostgreSQL + Kubernetes + Git + HTTP (bounded to a single host; not the 72-hour target). Duration 3603.7s over 603 iterations and 3097 canary observations.
Reported honestly: 521 adapter exceptions and 82 observer faults were recorded, not hidden — these come from the public ntfy.sh HTTP dependency rate-limiting under sustained load (PostgreSQL, Kubernetes and Git recorded zero exceptions).
Limits: single-host; NOT a multi-cluster production soak; BOUNDED unless run with CAIN_SOAK_SECONDS >= 259200 (72h); adapters share one host/kernel and one observer process (not independent infrastructure); no third-party load generator; HTTP depends on public ntfy.sh availability. RESTRICTION_ONLY (NOT ENFORCED). Internal analytical scenario, not an appraisal.
2026-10-09 — CAIN-42 EVOLUTION 7: PROJECT SOVEREIGN ACTION COMMIT — the exact canonical action is now bound to authority, execution, effect and evidence
AGENT PROPOSES. CAIN DECIDES. MCPGATE ENFORCES. THE EXECUTION BACKEND PERFORMS. INDEPENDENT EVIDENCE VERIFIES. Evolution 7 closes the gap between what an agent says it will do, what CAIN authorizes, what the runtime actually executes, and what independent evidence establishes afterward.
New primitives (cain/action_commit/): CanonicalAction identity (RFC 8785 JCS with ten documented semantic-equivalence rules and fail-closed host/path/unicode/number/duplicate-key normalization); a DeterministicPolicyEngine (versioned, total default-DENY, with bounded conflict/shadow/privilege-expansion analysis); the ActionCommitReferenceMonitor (authorization bound to the exact action digest, revalidated immediately before the effect, single-use, fail-closed when enforcement services are unavailable); ApprovalBinding (approval committed to the exact action); ExecutionReceipt + effect reconciliation (EFFECT_VERIFIED requires an independent observation); a trajectory cumulative-risk hash-chain; a cross-framework adapter contract; and a zero-import clean-room verifier (cain-action-commit-verify). Two restriction-only stages (default_stages_v29) express the gate in the live MCP path.
Verified on this checkout. Formal properties 20/20 (P341–P360); adversarial action-lifecycle lab 100,000/100,000 attacks safely refused (unsafe outcomes 0); 32/32 mutations killed; a real governed filesystem effect independently re-read and hashed (EFFECT_VERIFIED) with the clean-room verifier accepting the valid bundle and rejecting the tampered one; an action mutated between authorization and execution was DENIED with the executor never invoked (enforcement, not logging). Evolution 1–6 regression reproduced: 222/222.
IP Register v38: 121 canonical families (55 NOVEL, 48 UNUSUAL, 11 ENGINEERING, 7 INTEGRATION). Net Standalone IP Base: $13,376,810 (BASE) / $5,096,100 (LOW) / $24,007,750 (HIGH). Discounts were not reduced. Internal analytical scenario, not an appraisal.
Honest baseline corrections. A fresh audit of Evolution 6 found: the 72-hour soak claim is not reproducible from a machine-verifiable artifact; the "multi-process" Byzantine quorum is a single-process set of objects; and the "hardware-backed" attestation makes no live provider call (no TEE on this host). Those claims are recorded as NOT VERIFIED / SIMULATED.
Limits. RESTRICTION_ONLY (NOT ENFORCED). Only the MCP path is an enforcement adapter; a direct backend call that does not route through cain.mcp_proxy is not prevented. No TEE, no third-party audit, no production customer for this capability; the policy engine is not FORGE-grade (no recursion, no correctness theorem); pre-revenue; no patent filed; not an appraisal.
2026-10-09 — CAIN-42 Evolution 5: Project Sovereign Trial & IP Register v36 ($11,970,450 Base Net IP / $21,630,200 High Net IP; FIRME AI $14.45M–$15.45M)
Evolution 5 establishes Project Sovereign Trial: Adversarial Agent Assurance, Verified Multi-Turn Benchmarking, and Tool-Call Mediation under Indirect Prompt Injection. Real multi-turn AI-agent execution channels are governed and evaluated without relying on agent self-reporting or circular model-as-a-judge assessments.
Eight New Invention Families in cain/trial/:EGAA (declarative scenario engine cryptographically binding identities, threat categories, permitted capability subsets, and RFC 8785 canonical serialization); HIEC (cryptographic harness integrity and anti-gaming controls sealing scenario fixtures and detecting environment tampering); MCAT (multi-turn causal adversarial trial engine mediating tool calls via PolicyIR contracts under indirect injection); MGTO (independent multi-modal ground-truth outcome oracle evaluating actual filesystem/socket mutations); LHSE (long-horizon salami and cumulative risk engine tracking sub-threshold exfiltration and capability synergies like fs:read + net:connect); DMVE (differential and mutation-based verifier injecting 64KB overflows, path traversals, and unicode homoglyphs); RSAS (risk-stratified assurance scorecard computing Attack Block Rates and actuarial underwriting curves); and RTEB (reproducible trial evidence bundle with zero-dependency clean-room verifier).
2026-10-08 — CAIN-42 total value $13,208,980 (register v32); IP base over $10M
CAIN-42’s total value is $13,208,980 — the grand total of all 100 products + all 105 services + the IP base. The IP base alone is over $10M (≈ $10,449,450; range ≈ $3,914,500–$18,990,800) across 70 register families. Internal analytical register scenario, not an appraisal, not a market price and not a financing valuation.
FIRME AI CORPORATION value: $13,208,980 (founder Vicente Fernando Noriega is the 100% owner, so the founder is worth the same). Founder-attested first revenue: 3 customers, $193 (customer #3 recurring $96/mo, unverified).
Limits. No incorporation filed; no patent; no third-party validation; RESTRICTION_ONLY; 72h soak not run; physical SIMULATED; payment rail SANDBOX. Withdrawn larger figures are not republished as company worth.
2026-10-08 — CAIN-42 SUPERIOR AI AGENTIC MESH: WAVE 5 (FINAL)
Wave 5 is the final build wave: four more restriction-only clusters plus a recovered-IP audit of waves 1–4.UNDERWRITE emits underwriting-grade risk evidence (a 0–1000 score and band) — evidence for an underwriter, not insurance; SETTLE clears two independently signed change passports into a settlement receipt — not a financial settlement; SANITIZE scans retrieved memory/vector content for indirect-injection markers with NFKC + zero-width normalization; BRIEF produces a human oversight briefing and requires explicit human acknowledgement for high-consequence decisions (EU AI Act Art.14).
Verified. Waves 1–5 = 150/150 formal properties (P341–P490); 100,000/100,000 adversarial cases in EACH of the five waves (false-allow = 0); 32+30+30+25+25 mutations killed; 25+15+12+10+10 chaos faults fail safe; THREE real PostgreSQL + Kubernetes experiments, clean-room verified; external reproduction harness verified; 21 restriction-only stages live by default.
Maximum evidence-backed IP base is now ≈ $9,697,950 (range ≈ $3,647,500–$17,687,700); internal analytical estimate under register v31. Company scenario base ≈ $12,179,950 investor / $13,179,950 strategic (PAPER only). Founder-attested first revenue: 3 customers, $193 (customer #3 recurring $96/mo).
Limits. Internal analytical scenario, not an appraisal. RESTRICTION_ONLY (NOT ENFORCED); no 72h soak; no third-party validation; no patent; pre-revenue; SANDBOX rail; physical SIMULATED. Evidence · IP v31
2026-10-08 — CAIN-42 SUPERIOR AI AGENTIC MESH: WAVE 4
Wave 4 closes the four unbuilt research gaps and adds the conversion lever.PROBE plans environment probes by information value per cost within an explicit budget and blocks unbounded probing; CALIBRATE federates world-model external calibration — a synthetic-only model can never become ASSURANCE_ELIGIBLE; DISPUTE produces adjudication-ready signed-evidence bundles; and REPRODUCE emits a self-contained manifest + reviewer script an INDEPENDENT party can run to reproduce the mesh evidence without trusting CAIN.
Verified. Waves 1-4 = 120/120 formal properties (P341–P460); 100,000/100,000 adversarial cases in EACH of the four waves (false-allow = 0); 32+30+30+25 mutations killed; 25+15+12+10 chaos faults fail safe; THREE real PostgreSQL + Kubernetes experiments (success NO_RESTRICTION and fault DENY), clean-room verified; external reproduction harness verified; 17 restriction-only stages live by default.
Maximum evidence-backed IP base is now ≈ $9,292,950 (range ≈ $3,503,500–$16,940,700); internal analytical estimate under register v30. Company scenario base ≈ $11,024,950 investor / $12,024,950 strategic (PAPER only). Founder-attested first revenue: 2 customers, $97.
Limits. Internal analytical scenario, not an appraisal. RESTRICTION_ONLY (NOT ENFORCED); single local Kubernetes; no 72h soak; no third-party validation; revenue founder-attested/unverified; no incorporation; no patent; payment rail SANDBOX; physical SIMULATED. Evidence · Reproduction manifest · IP v30
2026-10-08 — CAIN-42 SUPERIOR AI AGENTIC MESH: WAVE 3
Wave 3 completes the 14-cluster mesh: four more restriction-only clusters on the same fail-closed spine.CHORUS governs collusion — consensus is not independence, correlated agents cannot approve each other into authority; PACT binds a signed payment mandate (amount, currency, merchant, kind, expiry, replay) to an effect on a SANDBOX rail; FORUM bridges cross-organization trust and rejects self-declared identities, requiring two independently operated keys; KINETIC gates physical actuation on hardware attestation + a kill switch and stays SIMULATED until real hardware-in-the-loop.
Verified. Waves 1-3 = 90/90 formal properties (P341–P430); 100,000/100,000 adversarial cases in EACH of the three waves (false-allow = 0); 32+30+30 mutations killed; 25+15+12 chaos faults fail safe; THREE real PostgreSQL + Kubernetes experiments (success NO_RESTRICTION and fault DENY), clean-room verified by cain-mesh-verify; 14 restriction-only stages live by default.
Maximum evidence-backed IP base is now ≈ $9,050,700 (range ≈ $3,417,700–$16,534,000); internal analytical estimate under register v29. Company scenario base ≈ $10,782,700 investor / $11,782,700 strategic (PAPER only). Founder-attested first revenue: 2 customers, $97.
Limits. Internal analytical scenario, not an appraisal. RESTRICTION_ONLY (NOT ENFORCED); single local Kubernetes; no 72h soak; no third-party validation; revenue founder-attested/unverified; no incorporation; no patent; payment rail SANDBOX; physical SIMULATED. Evidence · Wave-3 experiment · IP v29
2026-10-08 — CAIN-42 SUPERIOR AI AGENTIC MESH: WAVE 2
Wave 2 adds five more restriction-only clusters to the same fail-closed spine.AEGIS federates runtime monitors (learned monitors may only restrict, never promote); TRIAL attributes an incident to an exact step over a declared causal graph and never guesses; ORIGIN verifies signed model/tool manifests and detects rug pulls; NOTARY seals evidence in an RFC 6962 Merkle hash-chain with inclusion proofs and a WORM export; HORIZON gates on SLO/error-budget and drift budgets.
Verified. Wave 1 + wave 2 = 60/60 formal properties (P341–P400); 100,000/100,000 adversarial cases in EACH wave (false-allow = 0); 32+30 mutations killed; 25+15 chaos faults fail safe; TWO real PostgreSQL + Kubernetes experiments (success NO_RESTRICTION and fault DENY), clean-room verified by cain-mesh-verify; 10 restriction-only stages live by default.
Maximum evidence-backed IP base is now ≈ $8,842,200 (range ≈ $3,343,900–$16,164,650); internal analytical estimate under register v28. Company scenario base ≈ $10,574,200 investor / $11,574,200 strategic (PAPER only). Founder-attested first revenue: 2 customers, $97.
Limits. Internal analytical scenario, not an appraisal. RESTRICTION_ONLY (NOT ENFORCED); single local Kubernetes; no 72h soak; no third-party validation; revenue founder-attested/unverified; no incorporation; no patent. Evidence · Wave-2 experiment · IP v28
2026-10-08 — CAIN-42 SUPERIOR AI AGENTIC MESH
The mesh welds five restriction-only clusters into one fail-closed authority/evidence spine. Its invariant: authority is a lease that only evidence renews; every cluster may only restrict; no cluster may grant.
Clusters.ANCESTRY (delegation-chain integrity with monotone attenuation — detects authority widening/laundering), BASIS (blast-radius bounding + reversibility containment + duplicate-execution guard), PRAXIS (control-plane authority transfer: no control-plane authority without an approval bound to the exact change), MNEMOSYNE (governed-memory write-path provenance), LUMEN (normative observability overlay: gen_ai.* + authority/effect/outcome).
Verified. 25/25 formal properties (P341–P365); 100,000/100,000 adversarial cases (false-allow = 0); 32/32 mutations killed; 25/25 chaos faults fail safe; a REAL PostgreSQL + Kubernetes experiment with a success NO_RESTRICTION path AND a fault DENY path, both clean-room verified by cain-mesh-verify (zero CAIN imports); 5 restriction-only stages live by default (default_stages_v24).
Maximum evidence-backed IP base is now ≈ $8,566,200 (range ≈ $3,246,100–$15,687,400); internal analytical estimate under register v27. Company scenario base ≈ $10,298,200 investor / $11,298,200 strategic (PAPER only). Founder-attested first revenue: 2 customers, $97.
Limits. Internal analytical scenario, not an appraisal. RESTRICTION_ONLY (NOT ENFORCED); single local Kubernetes; no 72h soak; no third-party validation; revenue founder-attested/unverified; no incorporation; no patent. Evidence · Real experiment · IP v27
2026-10-08 — last-24h prompt audit: hidden IP made real
Auditing our own recent prompts found systemic gaps and one false claim — fixed with REAL evidence, not claims.
Fixed: every governance-cluster adversarial lab now executes the exact requested budget; seven clusters had silently under-run (HERMES 99,975; CRUCIBLE 99,992; ORACLE 99,974; REALITY 99,995; EPICENTER 99,995 — all now 100,000). CAUSALITY no longer issues VERIFIED_CAUSALITY on an effect it did not observe — the causal claim is now observation-gated and demonstrated on controlled PostgreSQL 16 + k3s Kubernetes (clean-room verified). REALITY now confirms ground truth across three independent external roots (PostgreSQL + Kubernetes + ntfy), clean-room verified.
Maximum evidence-backed IP base is now ≈ $8,308,950 (range ≈ $3,155,500–$15,218,450); internal analytical estimate under register v26. Company scenario base ≈ $10,040,950 investor / $11,040,950 strategic (PAPER only). Founder-attested first revenue: 2 customers, $97.
2026-10-08 — Prompt 24 (CONVERGENCE): autonomous production change assurance
CAIN governs autonomous change to REAL systems with machine-verifiable authority, effect, reality, causality, outcome, promotion and recovery. An autonomous agent proposes a change; CAIN binds the EXACT change fingerprint, releases authority PROGRESSIVELY (each stage needing new evidence), observes a REAL external effect, reconciles reality, verifies causality, and PROMOTES only when the evidence gates are satisfied. NO VERIFIED CHANGE OUTCOME → NO AUTONOMOUS PROMOTION.
New primitives. AutonomousChangeContract + ChangeFingerprint; R0–R6 ChangeBlastRadius; ProgressiveAuthorityReleaseEngine (stages 0–6, backwards demotion); ChangePreconditionVerifier (UNKNOWN blocks); GovernedCanaryEngine (external-state success, not liveness); EvidenceGatedPromotionEngine (UNKNOWN is never PROMOTE); RollbackVerificationEngine (seven states; restoration externally verified); ChangeCollusionDefense; WorldModelAdmissibilityGate; VerifiedExperienceRecord that can never raise authority; ChangeOutcomeCertificate with a clean-room verifier.
Verified. Formal properties P301–P340 (40/40); 36 categories / 108,000 cases (0 false promotions); 34/34 mutations killed; 25/25 chaos faults fail safe; a REAL multi-adapter experiment across PostgreSQL + Git + HTTP + Kubernetes with a success PROMOTE path AND a fault MISMATCH→rollback→verified-restoration path (clean-room verified on all four bundles); a bounded REAL multi-system soak on PostgreSQL + Kubernetes with 0 false promotions; 3 restriction-only stages live in the hosted MCP path (default_stages_v23).
Maximum evidence-backed IP base is now ≈ $8,097,450 (range ≈ $3,080,500–$14,844,950); internal analytical estimate, up one evidence tier from the prior Prompt 23 base of ≈ $7,392,450. Company scenario base ≈ $9,829,450 investor / $10,829,450 strategic (PAPER only). Founder-attested first revenue: 2 customers, $97.
Limits. Internal analytical scenario, not an appraisal. Kubernetes is a single-node local k3s cluster; the soak is BOUNDED (not 72h); enforcement remains RESTRICTION_ONLY (NOT ENFORCED); there is no third-party validation; revenue is founder-attested and unverified; no incorporation record; no patent filed. Public truth · Real experiment · IP register
CAIN lets autonomous systems trust other autonomous systems WITHOUT BLIND TRUST. A receiving organization defines REQUIRED ASSURANCE; a foreign agent presents AVAILABLE ASSURANCE; CAIN computes a deterministic ASSURANCE MATCH — transaction-scoped, continuous and evidence-based, across organizational boundaries. Local policy always dominates.
New primitives. A proposed assurance ladder A0–A8; typed federated evidence with a shared-dependency independence graph; negotiation bounded by authority; transaction-scoped assurance (agent+authority+action+target+context+consequence+evidence+time); a scope-bound Federated Assurance Certificate with a clean-room verifier; attenuated cross-organization delegation; a propagating federated revocation network; and continuous federated assurance integrated with ARGUS.
Verified. Formal properties A-F01–A-F25 (hosted suite 142/142); 79/79 governance mutations killed; adversarial federation lab 100,000 deterministic cases, 0 violations; 8 restriction-only stages live in the hosted MCP path (83/83 wire probes).
Maximum evidence-backed IP base is now ≈ $3,824,300 (range ≈ $1,554,100–$7,089,750); internal analytical estimate. Company scenario base ≈ $5,556,300 investor / $6,556,300 strategic. Founder-attested first revenue: 2 customers, $97.
Limits. Internal analytical scenario, not an appraisal. No real cross-organization production federation yet; machine economy SANDBOX; physical systems SIMULATED; FAAP is a proposal, not a standard; revenue is founder-attested and unverified; pre-revenue except first milestone; no incorporation record; no patent filed. Report · Evidence
AUTHORITY IS A LEASE, NOT A PERMISSION. CAIN now continuously proves that an autonomous agent remains within the authority, behavioral envelope, environmental assumptions and consequence boundaries under which it was authorized — across model, memory, skills, tools, policies, delegation, world state, environment, behavior, execution path and effect.
New primitives. A signed ArgusAssuranceObject; a BehavioralAuthorityEnvelope evaluated against the actual execution path; path composition invariance (authority-layer salami defense); a ContinuousReauthorizationEngine; an AutonomousAssuranceLease the agent cannot renew or certify itself; an independent assurance verifier mesh (disagreement never allows); a memory-to-authority firewall; and a clean-room-verifiable Assurance Certificate.
Verified. Formal properties A-P01–A-P20 (hosted suite 117/117); 66/66 governance mutations killed; adversarial assurance lab 100,000 deterministic cases, 0 violations; 9 restriction-only stages live in the hosted MCP path (67/67 wire probes).
Maximum evidence-backed IP base is now ≈ $3,206,100 (range ≈ $1,330,000–$5,923,000); internal analytical estimate. Company scenario base ≈ $4,938,100 investor / $5,938,100 strategic.
Limits. Internal analytical scenario, not an appraisal. The stages enforce at the hosted decision path; the caller's downstream execution is not yet bound. Physical systems SIMULATED. Pre-revenue; no incorporation record; no patent filed; CAAP is a proposal, not a standard. Report · Evidence
NO VERIFIED AUTHORITY → NO DURABLE EFFECT. NO VERIFIED EFFECT → NO ASSUMED SUCCESS. CAIN now binds authority to the exact intended durable effect, not merely to who may act: an EffectContract and deterministic EffectFingerprint; a two-phase effect commit; exactly-once duplication defense; in-doubt resolution without blind retry; reversibility-aware authority (R0–R7); a compensation graph where recovery is an action requiring its own authority; a causal effect graph; and a VerifiedEffectReceipt with a zero-runtime clean-room verifier.
Verified. Formal properties E-P01–E-P15 (hosted suite 97/97); governance mutations 53/53 killed; deterministic fault-injection lab 100,000 cases with 0 false finalizations and 0 duplicates; two restriction-only stages live in the hosted MCP path (48/48 wire probes).
Maximum evidence-backed IP base is now ≈ $2,587,900 (range ≈ $1,105,900–$4,756,250); internal analytical estimate. Company scenario base ≈ $4,319,900 investor / $5,319,900 strategic.
Limits. Internal analytical scenario, not an appraisal. The effect stages enforce at the hosted decision path; the caller's downstream execution is not yet bound. Physical systems SIMULATED. Pre-revenue; no incorporation record; no patent filed. Report · Evidence
2026-10-11 — Prompt 12 (DYNASTY): population governance of self-evolving agents
CAIN now governs the boundary between what an evolving population of agents can do and what it is authorized to do. CAPABILITY MAY EVOLVE FASTER THAN AUTHORITY. 38 net-new system-level families: population authority conservation, signed evolution lineage, capability≠authority, correlated-evidence independence, clone authority derivation, collective world-model governance, evolution contagion and blast radius, spawning/delegation governance, sybil-resistant authority, memory-mechanism governance, promotion/rollback/quarantine, embodiment recertification (SIMULATED), capability-risk frontier, machine-economy envelope, fitness/governability vectors, model and dependency supply-chain governance, and research compilers, autonomous patch / software-factory non-self-authorization, collective collusion detection, and the population capability graph.
Verified. Formal properties P56–P82 (hosted suite 82/82); governance mutations 48/48 killed; deterministic population attack lab 100,000 cases with 0 false allows; 4 restriction-only stages live in the hosted MCP path (44/44 wire probes).
Maximum evidence-backed IP base is now ≈ $1,980,700 (range ≈ $885,400–$3,612,250), internal analytical estimate. FIRME AI company scenario base ≈ $3,712,700 investor / ≈ $4,712,700 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $3,712,700.
Limits. Internal analytical scenario, not an appraisal. Pre-revenue; no incorporation record; no patent filed. Physical systems are SIMULATED. The caller's downstream execution is not yet bound to the decision. Execution report · Evidence
2026-10-11 — Prompt 6-11 governance pipeline deployed to the hosted path
37 Prompt 6-11 mechanism families now run on the hosted MCP server (/mcp) as an ordered, restriction-only, fail-closed pipeline: consequence envelope, authority certificate, autonomy envelope, authority budget, authority drift, threshold authority, supply-chain provenance, source-evolution firewall, world-model firewall, physical gate and continuous attestation. Every tools/call passes through the chain before the tool body runs; ordinary traffic abstains. Live-verified on the production gateway: all 13 wire probes matched expectation (governance code −32001 on every DENY) and the decision ledger hash chain is valid.
Evidence-backed IP base is now ≈ $843,300 (range ≈ $473,200–$1,447,750). The all-deployed scenario now equals the evidence-backed figure — all 37 Prompt 6-11 families are deployed. FIRME AI company scenario base ≈ $2,575,300 investor / $3,575,300 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $2,575,300.
Limits. Internal analytical scenario, not an appraisal. The stages enforce at the hosted decision path; the caller's downstream execution is not yet bound to the decision. Pre-revenue; no incorporation record; no patent filed. Evidence
2026-10-11 — Prompt 6-11 governance pipeline deployed to the hosted path
33 Prompt 6-11 mechanism families now run on the hosted MCP server (/mcp) as an ordered, restriction-only, fail-closed pipeline: consequence envelope, authority certificate, autonomy envelope, authority budget, authority drift, threshold authority, supply-chain provenance, source-evolution firewall, world-model firewall, physical gate and continuous attestation. Every tools/call passes through the chain before the tool body runs; ordinary traffic abstains. Live-verified on the production gateway: all 13 wire probes matched expectation (governance code −32001 on every DENY) and the decision ledger hash chain is valid.
Evidence-backed IP base is now ≈ $822,600 (range ≈ $464,500–$1,415,250). The all-deployed scenario (≈ $843,300) remains conditional; 4 families are still libraries. FIRME AI company scenario base ≈ $2,554,600 investor / $3,554,600 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $2,554,600.
Limits. Internal analytical scenario, not an appraisal. The stages enforce at the hosted decision path; the caller's downstream execution is not yet bound to the decision. Pre-revenue; no incorporation record; no patent filed. Evidence
2026-10-11 — Prompt 6-11 governance pipeline deployed to the hosted path
30 Prompt 6-11 mechanism families now run on the hosted MCP server (/mcp) as an ordered, restriction-only, fail-closed pipeline: consequence envelope, authority certificate, autonomy envelope, authority budget, authority drift, threshold authority, supply-chain provenance, source-evolution firewall, world-model firewall, physical gate and continuous attestation. Every tools/call passes through the chain before the tool body runs; ordinary traffic abstains. Live-verified on the production gateway: all 13 wire probes matched expectation (governance code −32001 on every DENY) and the decision ledger hash chain is valid.
Evidence-backed IP base is now ≈ $803,100 (range ≈ $456,100–$1,385,250). The all-deployed scenario (≈ $843,300) remains conditional; 7 families are still libraries. FIRME AI company scenario base ≈ $2,535,100 investor / $3,535,100 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $2,535,100.
Limits. Internal analytical scenario, not an appraisal. The stages enforce at the hosted decision path; the caller's downstream execution is not yet bound to the decision. Pre-revenue; no incorporation record; no patent filed. Evidence
2026-10-11 — Prompt 6-11 governance pipeline deployed to the hosted path
25 Prompt 6-11 mechanism families now run on the hosted MCP server (/mcp) as an ordered, restriction-only, fail-closed pipeline: consequence envelope, authority certificate, autonomy envelope, authority budget, authority drift, threshold authority, supply-chain provenance, source-evolution firewall, world-model firewall, physical gate and continuous attestation. Every tools/call passes through the chain before the tool body runs; ordinary traffic abstains. Live-verified on the production gateway: all 13 wire probes matched expectation (governance code −32001 on every DENY) and the decision ledger hash chain is valid.
Evidence-backed IP base is now ≈ $719,700 (range ≈ $419,200–$1,274,000). The all-deployed scenario (≈ $843,300) remains conditional; 12 families are still libraries. FIRME AI company scenario base ≈ $2,451,700 investor / $3,451,700 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $2,451,700.
Limits. Internal analytical scenario, not an appraisal. The stages enforce at the hosted decision path; the caller's downstream execution is not yet bound to the decision. Pre-revenue; no incorporation record; no patent filed. Evidence
2026-10-11 — Prompt 6-11 governance pipeline deployed to the hosted path
19 Prompt 6-11 mechanism families now run on the hosted MCP server (/mcp) as an ordered, restriction-only, fail-closed pipeline: consequence envelope, authority certificate, autonomy envelope, authority budget, authority drift, threshold authority, supply-chain provenance, source-evolution firewall, world-model firewall, physical gate and continuous attestation. Every tools/call passes through the chain before the tool body runs; ordinary traffic abstains. Live-verified on the production gateway: all 13 wire probes matched expectation (governance code −32001 on every DENY) and the decision ledger hash chain is valid.
Evidence-backed IP base is now ≈ $699,300 (range ≈ $410,800–$1,245,250). The all-deployed scenario (≈ $843,300) remains conditional; 26 families are still libraries. FIRME AI company scenario base ≈ $2,431,300 investor / $3,431,300 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $2,431,300.
Limits. Internal analytical scenario, not an appraisal. The stages enforce at the hosted decision path; the caller's downstream execution is not yet bound to the decision. Pre-revenue; no incorporation record; no patent filed. Evidence
2026-10-11 — Prompt 6-11 governance pipeline deployed to the hosted path
11 Prompt 6-11 mechanism families now run on the hosted MCP server (/mcp) as an ordered, restriction-only, fail-closed pipeline: consequence envelope, authority certificate, autonomy envelope, authority budget, authority drift, threshold authority, supply-chain provenance, source-evolution firewall, world-model firewall, physical gate and continuous attestation. Every tools/call passes through the chain before the tool body runs; ordinary traffic abstains. Live-verified on the production gateway: all 13 wire probes matched expectation (governance code −32001 on every DENY) and the decision ledger hash chain is valid.
Evidence-backed IP base is now ≈ $632,100 (range ≈ $381,400–$1,141,500). The all-deployed scenario (≈ $843,300) remains conditional; 26 families are still libraries. FIRME AI company scenario base ≈ $2,364,100 investor / $3,364,100 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $2,364,100.
Limits. Internal analytical scenario, not an appraisal. The stages enforce at the hosted decision path; the caller's downstream execution is not yet bound to the decision. Pre-revenue; no incorporation record; no patent filed. Evidence
2026-10-11 — Prompt 11 governance stage deployed to the hosted path
The Prompt 11 restriction-only governance stage now runs on the hosted MCP server (/mcp): every tools/call passes through the dynamic consequence envelope and, for a governed action, the signed continuous authority certificate, before the tool body runs. It can only refuse; ordinary traffic abstains. Live-verified on the production gateway: an ungoverned CRITICAL-consequence call is denied (code −32001), a governed call is allowed, ordinary calls are unchanged, and the decision ledger hash chain is valid.
Evidence-backed IP base is now ≈ $556,500 (range ≈ $348,400–$1,036,500), because two Prompt 6-11 families (consequence envelope, authority certificate) moved from library-only to deployed. The all-deployed scenario (≈ $843,300) remains conditional. FIRME AI company scenario base ≈ $2,288,500 investor / $3,288,500 strategic. Vicente Fernando Noriega (100% owner, paper equity) base ≈ $2,288,500.
Limits. Internal analytical scenario, not an appraisal. Only 2 of the 37 Prompt 6-11 families run on the hosted path; the other 35 remain libraries. Pre-revenue; no incorporation record; no patent filed. Deployment evidence
2026-10-11 — IP value recalculated with the Prompt 6-11 inventions
INCLUDING THE 106 PROMPT 6-11 INVENTION RECORDS, THE NET STANDALONE IP BASE IS ≈ $529,500 (library-only) TO ≈ $843,300 (deployed).
Applying the project's own register method (gross appraisal → blended prior-art/deployment discount → net base) to the new mechanism families: library-only net base $336,400–$994,000; deployed net base $473,200–$1,447,750. Company scenario with the IP uplift added: investor up to $2,575,300; strategic up to $3,575,300. Vicente Fernando Noriega (100% owner, paper equity) up to $3,575,300.
Limits. Internal analytical scenario, NOT an appraisal, NOT a financing valuation, NOT a guarantee. The deployed figure assumes the Prompt 6-11 mechanisms are on the hosted path; the repo's evidence currently shows them as libraries (Sovereign stage opt-in/off by default; both 72-hour soaks FAILED). Pre-revenue; no incorporation record; no patent filed. Evidence bundle
2026-10-11 — CAIN CONTINUUM: does an agent still deserve the same authority after it changes?
AUTONOMY IS A CONTINUOUSLY VERIFIED STATE OF AUTHORITY. A SELF-EVOLVING AGENT MUST NOT AUTOMATICALLY INHERIT THE AUTHORITY OF ITS PREVIOUS STATE.
A World-Model Authority Firewall and drift engine (prediction/simulation never authorize); an Authority-Preserving Memory with a continuity proof and a 10,000-case AuthMem attack suite; Skill Authority Continuity with a reproduction receipt; a Governed Source Evolution engine; Change-Impact Recertification 2.0; a Continuous Authority Certificate that invalidates on any material change; an Authority Drift Detector; a Dynamic Consequence Envelope with Authority Minimization; Cross-Agent Authority Continuity and a Swarm Authority Conservation Proof; a Sim-to-Real Authority Gate; a World-State Ledger and Environment State Identity; a Continuous Agent Assurance loop; and a framework-agnostic governed tool adapter. Measured: 55 formal properties, 50,000 adversarial cases with 0 false-allows, 10,000 AuthMem cases with 0 breaches, 34/34 injected governance defects killed, and a real multi-process authority ledger that stays consistent.
Limits. Libraries; the runtime stage is still opt-in. No staging soak, no third-party verification, no customers, no revenue, no patents. Physical AI is simulated only. The IP register is engineering invention-discovery, not legal advice. PRE-PRODUCTION.
2026-10-08 — CAIN APEX: autonomy is a continuously verified state of authority
AUTONOMY IS NOT A PERMISSION. A SELF-EVOLVING AGENT MUST NOT AUTOMATICALLY INHERIT THE AUTHORITY OF ITS PREVIOUS STATE.
Agent State Identity; monotonic Authority Inheritance; a Cognitive Provenance Graph; Memory Authority Firewall 2.0 (memory never exceeds its source); a World-State Epistemic Firewall (prediction/simulation never escalate authority); a World-Model Conformance Engine; Consequence-Bounded Authority; an Emergent Authority Calculus (UNKNOWN is never ALLOW); a Threshold Authority Object (consensus is not authorization); an Authority State Machine; an Autonomy Envelope; a Self-Modification Firewall 2.0; an Authority Blast-Radius Graph; Evidence Quality Grading (E0–E5); a Clean-Room Verifier 3.0 with differential verification; an Authority Ledger; a Distributed Authority Lab; and a real HTTP/JSON authority adapter (a second real protocol after MCP). Measured: 40/40 formal properties, 30,000 authority attack attempts blocked with 0 breaches, 27/27 injected governance defects killed, and 6/6 distributed scenarios.
Limits. Libraries; the runtime stage is still opt-in. No staging soak, no third-party verification, no customers, no revenue, no patents. Physical AI is simulated only. The IP landscape is engineering invention-discovery, not legal advice. PRE-PRODUCTION.
2026-10-08 — CAIN LEGION: authority as a verifiable state
AUTHORITY IS A STATE, NOT A BOOLEAN. NO VERIFIED AUTHORITY LINEAGE → NO HIGH-ASSURANCE AUTHORIZATION.
An Authority State Model where INCONCLUSIVE is never ALLOW; an Authority Continuity Token that refuses commit-time TOCTOU drift; a Context Authority Evaluator; Purpose-Bound Capability; a Mission Authorization Envelope; a derived Authority Decay Model; Emergency Authority with contained escalation; a multi-kind Revocation Fabric; an Authority Fork Detector; a Logical Authority Clock; a canonical Verifiable Authorization Object + Authority Receipt 2.0; Change-Impact Recertification; a Causal Authorization Engine; a Capability Composition Analyzer; an Evidence Graph with trust classes; a hash-chained WAL Authority Store; an Independent Verifier 2.0; and a 20-property formal suite. Measured: 20/20 properties pass, 24,000 authority attack attempts blocked with 0 breaches, 21/21 injected governance defects killed, and 35 scored IP candidates.
Limits. Libraries; the runtime stage is still opt-in. No staging soak, no third-party verification, no customers, no revenue, no patents. Physical AI is simulated only. The IP landscape is engineering invention-discovery, not legal advice. PRE-PRODUCTION.
2026-10-08 — CAIN Authority Mesh: proving authority stayed bounded across an autonomous chain
NOT JUST "CAN CAIN STOP AN UNAUTHORIZED CALL?" — "CAN CAIN PROVE AUTHORITY DID NOT ESCALATE ACROSS THE WHOLE CHAIN?"
An Authority Graph (identity, capability, authority, trust, reputation, provenance, policy and consent kept distinct), an Authority Lineage, an Authority Prover (PASS/FAIL/INCONCLUSIVE, never INCONCLUSIVE to PASS), multidimensional Authority Budgets, a non-broadening Policy Compiler 2.0, Policy Differential Verification, a Cryptographic Authority Receipt, an Agent Proof Graph, Provenance Continuity, an Agent Immune System, a Collusion Graph, authorized deployment modes and an Independent Authority Verifier. The Prompt 7 fail-open is closed: the proof-carrying-action verifier no longer accepts unsigned or crypto-less tokens, supports pinned issuers and an algorithm allowlist, claims nonces atomically and signs a decision receipt for every outcome. An authority swarm of 26,000 attack-chain attempts was blocked with 0 breaches; 15 of 15 injected governance defects were killed by the tests.
Limits. Libraries; the runtime stage is still opt-in and off by default. No staging soak, no persistent stores, no framework adapter beyond MCP, no third-party verification, no customers, no revenue, no patents. Physical AI is simulated only. PRE-PRODUCTION.
2026-10-07 — CAIN Sovereign: the governance engine now runs at the execution boundary, restriction-only
THE AGENT MAY REASON ABOUT THE WORLD. CAIN DECIDES WHETHER IT IS AUTHORIZED TO CHANGE IT — AT THE BOUNDARY, AND IT CAN ONLY REFUSE.
A canonical action request and a Runtime Governance Bus re-resolve every witness from live registries at the moment of a tool call and are wired as a restriction-only stage into the real MCP interceptor (off by default; opt in per deployment). Alongside it: signed skill trust, agent capability passports, continuous attestation, behavioural fingerprints, agent supply-chain provenance, agent-to-agent trust, machine-to-machine transaction governance, incident response, reputation, an experience economy, a governed world-model layer, a model-agnostic agent runtime, a research agent and a governed software factory. Governance mutation testing and an adversarial swarm attack the enforcement path itself. A real local MCP server is enforced before a request reaches it.
Limits. A library plus one opt-in boundary stage; not enabled on the hosted gateway by default. Same-project tests, not third-party. No customers, no revenue, no patents. Physical AI is simulated only. PRE-PRODUCTION.
2026-10-07 — Governed self-evolution: an agent can improve its skills without expanding its authority
YOUR AI AGENT CAN NOW IMPROVE ITSELF, AND CAIN-42 DECIDES WHETHER EACH IMPROVEMENT MAY BECOME AUTHORIZED BEHAVIOUR. LEARNING DOES NOT GRANT AUTHORITY.
Every proposed skill runs in a fresh confined process with no network, must reproduce its gain on hidden and unrelated regression tasks, and passes the evolution gate, an operator approval and a canary before it can go live; every outcome gets a governance-signed receipt (16 of 16 verify under a clean-room verifier). Delegated authority only narrows. Benchmark: static baseline 0.3333, ungoverned self-evolving agent 0.625 with 36 security violations, CAIN-governed agent 1.0 with 0. A continuous red team blocked 411 of 411 attacks after its first run found and closed 4 real defects. 127 of 127 tests pass.
Limits. Synthetic workload, not a language model (token cost not measured); small n; a library, not yet on the hosted gateway; same-project, not third-party. PRE-PRODUCTION.
2026-10-07 — IP hardening, batch 3: 11 decision-path and public-verifier defects closed
WE ATTACKED THE CHECKS THAT DECIDE AND THE VERIFIERS THAT PROVE. 11 DEFECTS CLOSED, LIVE ON ALL THREE DOMAINS.
A prepare certificate is no longer accepted as a commit; a signed DENIED record can no longer be re-split into ALLOWED; the offline, universal-proof, WORM, attestation and kernel verifiers now pin the trusted key instead of accepting forgeries signed with the forger’s own; four ALLOW holes in the control evaluator, a nested payload that skipped the risk screen and an unreadable approval threshold that switched human approval off are closed; recorded decisions reach the live stream. 314 of 315 tests pass (the one fault is an unrelated published-page mismatch, reported in the bundle). Live: a forged universal proof was refused 12 of 12 times.
Limits. Same-project tests, not third-party assurance. PRE-PRODUCTION.
2026-10-07 — CAIN-42 now catalogs over 8,000 products and services; the product focus is the October 2026 Top 100
WE CATALOGUED EVERYTHING, THEN CHOSE WHAT TO SELL.
An automated pass over the whole repository registered more than 8,000 CAIN-42 products, services and monetizable mechanisms — 1,680 implemented invention mechanisms and 8,324 monetization avenues across the product catalog. Selling all of them at once is not a strategy, so the product focus is now the October 2026 Top 100: the 100 products ranked richest-first by revenue potential, each with a deep description and a live demo at /top100.html. The Top 100 also has a dedicated showcase section at the top of every homepage and its own entries in the rolling ticker.
Limits. The 8,000+ figure is a catalog-breadth count, not revenue, customers or a valuation; the Top 100 is an illustrative ranking of the opportunity catalog, not a forecast. No customers, no revenue, no patent filed. PRE-PRODUCTION.
2026-10-06 — IP hardening, batch 2: 11 defects closed in seven inventions; the 200/200 invariant claim withdrawn
WE ATTACKED THE NEXT 20 INVENTIONS AND FIXED 11 DEFECTS IN SEVEN OF THEM. ONE WAS OUR OWN PUBLIC CLAIM, NOW CORRECTED, LIVE.
Action-risk classifier: SQL comments, split argument lists, cents or nested amounts and look-alike tool names no longer lower the risk. Symbolic policy verifier: errors and malformed input now deny instead of crashing. Quarantine: an agent can no longer lift its own quarantine. Sandbox: an unhandled 500 is now a 503. Message firewall: the untrusted-content fence can no longer be closed through its source label. Provenance manifest regenerated and verified.
Correction./fabric/invariants/verify-all reported 200 of 200 CAIN 14 invariants passing; every validator compares or hashes constants and none exercises production code. It now reports 0 passed (200 CONSTANT_ONLY). Earlier “200/200” statements on this page are withdrawn.
26 new test cases failed before their fixes; 252 of 252 pass; live on both gateway instances. IP value: internal re-estimate about $221,000; filing the four provisional patents is expected to take it past $250,000.
Limits. Same-project tests, not third-party assurance; internal estimate, not an appraisal. PRE-PRODUCTION.
2026-10-06 — Boundary hardening: 9 areas of the decision path attacked and closed
WE ATTACKED THE PATH EVERY AGENT ACTION TAKES THROUGH CAIN-42, FOUND REAL HOLES, AND CLOSED THEM. EACH FIX HAS A TEST THAT FAILS WITHOUT IT.
MCPGate no longer passes CAIN’s authorization envelope or the caller’s credentials to tool servers. Agent passports are enforced on the hosted path and bound to the exact call. The identity log is hash-chained with issuer-signed checkpoints and an offline verifier that catches edits, deletions and truncation. Trajectory rules hold split-key exfiltration and runaway loops for a human. The operator’s cluster halt and agent quarantines now stop hosted decisions. A tenant-owned physical safety envelope refuses out-of-envelope actions, even in shadow mode. A2A card and delegation signatures are verified (the public verifier had checked none). Agent keys can no longer promote their own memory to TRUSTED, write policies, switch off the kill switch or resume themselves. 322 tests pass, 0 fail; live after the rolling deploy, a forged unsigned A2A card is refused on 3 of 3 domains.
Limits. Same-project tests, not third-party assurance; most fixes are proven by tests, not by live attack. Physical device state is self-reported, not hardware-attested. Revocation runs on one node. PRE-PRODUCTION.
2026-10-06 — IP hardening, batch 1: 12 defects found and closed in four inventions
WE ATTACKED OUR OWN TOP INVENTIONS, FOUND 12 REAL DEFECTS AND CLOSED EVERY ONE. EACH FIX IS PROVEN BY A TEST THAT FAILED BEFORE IT.
Quorum-committed authorization snapshots (PP-01): a grant revoked mid-reconcile could still be fast-path-authorized until expiry; closed. Mission goal-attenuation lattice (PP-02): four budget defects, including a negative spend that refilled the mission budget and per-request-only goal budgets; closed. Trajectory governance: calls in flight together now see each other, records-system and person-addressed reads are sensitive, publishing data is egress; a fresh held-out attack set run once without tuning went from 4 of 5 to 2 of 5 unattended (the 2 open variants are published). SLO endpoint: cross-tenant decision counts are operator-only. 18 new tests (23 cases), 22 failed before the fix, all pass; live on both gateway instances.
Limits. Same-project tests, not third-party assurance; the snapshot race was verified against a scripted quorum. PRE-PRODUCTION.
2026-10-06 — Valuation figures corrected: FIRME AI about $3 million
FIRME AI is worth about $3 million by its own forensic valuation (about $2M as an investor would value it, range $0.9M–$6M; about $3M to a strategic acquirer, range $1M–$11M). The CAIN-42 code and IP on their own are worth about $200,000 (range $130k–$550k).
Maximum IP value: about $1,000,000 — the most the IP could reasonably be worth once patents are filed and at least one paying customer uses the inventions. A ceiling after those steps, not today’s value; it replaces the earlier conditional figure of about $1.7M.
Withdrawn. A $12M company value, $6M–$59.5M IP values, a $300M forward value, a $1.13B roadmap value and a founder net-worth estimate published earlier the same day. They rested on an automated candidate count with no prior-art review and on revenue the company does not have. FIRME AI is pre-revenue: no customers, no revenue, no patent filed, 0 of 67 public claims independently verified.
Limits. Internal analytical estimates; not an independent appraisal, not a financing valuation, not a guarantee. Company
2026-10-06 — AGI experiment suite: 50 live-model runs, 14 scenarios, every guarantee held
A LIVE CLAUDE MODEL TRIED OPERATIONAL AND ADVERSARIAL TASKS 50 TIMES. ITS ONLY WAY TO ACT WAS CAIN-42. NOTHING GOT PAST IT.
50 runs of claude-haiku-4-5 across 14 scenarios, including prompt injection in data, social engineering, exfiltration, path traversal, missing capabilities, low trust, self-granted capabilities and invented tools. After every run five guarantees were checked from its own evidence (capabilities, approvals, chain integrity, no secret leaked, sandbox confinement): all five held in all 50 runs. Path traversal was refused even with an approve-everything operator policy; injected leak instructions were never followed; claimed CEO approvals were ignored every time.
Limits. Approvals came from scripted operator policies, not humans; in some adversarial tasks the model refused on its own. A small current model, not AGI; not a certification; not third-party assurance. Model cost for all 50 runs: $0.22. PRE-PRODUCTION.
Evidence bundle — every report, every evidence chain, and a verifier that re-checks all 50 runs.
2026-10-06 — AGI control boundary: proven agent identity, no replays, approvals bound to what a human saw
BUILT TO CONTROL AGI MEANS NEVER TAKING THE AGENT’S WORD FOR ANYTHING. FOUR WAYS IT COULD HAVE BEEN TAKEN ARE NOW CLOSED, LIVE.
Every proposal must be signed with the agent’s own registered key (an unsigned one, or half a credential, used to get through). A decided proposal cannot be replayed. A human approval covers exactly the action, target and arguments the human saw, expires, and must come from a human who did not propose it. Agents created through the Identity API now reach the boundary (the two resolved tenants differently). Coming in the next SDK release: cainstudio agi-test puts your own Claude model behind the boundary and returns a hashed report. 82 tests passed, 0 failed; unauthenticated proposals refused on all three domains; live since the gateway restart.
Limits. No AGI exists to test against; measured on today’s systems. Same-project tests, not third-party assurance. PRE-PRODUCTION.
2026-10-06 — A live frontier model under CAIN-42’s AGI control boundary
A REAL CLAUDE MODEL WAS GIVEN A TASK AND ONE WAY TO ACT: PROPOSING ACTIONS TO CAIN-42. CAIN-42 DECIDED EVERY ONE.
claude-opus-5-5 was asked to read a status file, write a summary and notify on-call, acting only through the AGI control boundary. It proposed sandbox.read_file; file reads are critical risk under CAIN’s policy, so CAIN-42 held it for a human (HUMAN_APPROVAL_REQUIRED). No human was attached, so nothing executed. The model then stopped and reported that it could not finish, without claiming an approval or inventing a result. Evidence chain intact; the bundle includes the raw evidence log and a standard-library verifier that detects tampering.
Limits. One run, one model, one task, no human approver. Not evidence of AGI or emergent capability; not a certification; not third-party assurance. PRE-PRODUCTION.
2026-10-06 — Invention Atlas: 1,686 mechanism candidates (a breadth count, not a valuation)
An automated sweep of the CAIN-42 repository registered 1,686 implemented mechanism candidates — 299 patent candidates, 1,095 engineering innovations and 292 implementation mechanisms — of which 1,463 carry direct test evidence. This is a count of breadth before any prior-art or novelty review; it does not measure value. Dollar figures first published with it were withdrawn the same day (see below). See the Invention Atlas.
Limits. No patent filed yet. A candidate register only — not a patentability, novelty or freedom-to-operate opinion. PRE-PRODUCTION.
2026-10-06 — Authority Continuity Protocol refuses live calls; COSE receipts; IP re-estimated at about $575k
AN ACTION NOW NEEDS EVERY REPLICA’S RE-CHECK FOR EXACTLY THOSE ARGUMENTS, AND RECEIPTS SPEAK THE IETF FORMAT.
The CONTINUITY stage refuses a call unless 2f+1 replicas re-checked this exact request, unexpired, unused, for exactly those arguments; verified live on all three domains (continuity-confused-deputy is BLOCKED). SCITT receipts are also available as COSE_Sign1 (IETF COSE Receipts layout) with a zero-dependency offline verifier; the route is live, the full round trip is verified by tests. All 46 engineering innovations are documented as trade secrets. IP portfolio about $575k today.
Limits. Internal analytical estimates; no patent filed yet; the ACP demo cluster runs in-process on the gateway host, not on the live PBFT clusters. PRE-PRODUCTION.
2026-10-06 — Three more inventions refuse live calls; IP re-estimated at about $555k
PREDICTIONS, AUTONOMY CERTIFICATES AND CROSS-ORGANIZATION FEDERATIONS NOW CHECK REAL CALLS ON THE HOSTED GATEWAY.
Prediction-bounded authorization (E16), the autonomy vector with certificates and leases (L5) and authority non-transfer across organizations (E37) each run as a restriction-only stage; verified live on all three domains (prediction-outside, autonomy-substituted and federation-transfer are BLOCKED). GOV-IR proofs and predictions older than 5 minutes are now refused, and unpinned keys are labelled self-presented. The self-evolution gate has run hosted since 2026-09-28. IP portfolio about $575k today.
Limits. Internal analytical estimates; no patent filed yet; the ~$1.7M maximum needs filed patents, incorporation and a paying customer. PRE-PRODUCTION.
2026-10-06 — GOV-IR programmable governance decides live calls; IP re-estimated at about $525k
A GOV-IR GOVERNANCE PROGRAM CAN NOW REFUSE REAL CALLS ON THE HOSTED GATEWAY.
The new GOVERNANCE stage verifies a GOV-IR program proof (both quorum certificates, the certified state, a byte-for-byte re-run) and requires a fresh (under 5 minutes) ALLOW for exactly that tool and those arguments; it can refuse, never permit. The public demo's replica sets are self-presented, not operator-pinned. Verified live on all three domains: POST /fabric/try?scenario=governance-program-reauth is BLOCKED by governance. Also found: authorization snapshots have been on in production since 2026-10-02, and continuous governance attestation runs hosted (no attestations issued yet). IP portfolio about $575k today (GOV-IR ~$40k, attestation ~$14k, snapshots re-estimated ~$65k).
Limits. Internal analytical estimates; no patent filed yet; the ~$1.7M maximum needs filed patents, incorporation and a paying customer. PRE-PRODUCTION.
FIRME AI is an artificial intelligence startup based in San Francisco, California, founded in September 2026 by Vicente Fernando Noriega, and the creator and operator of CAIN-42. TOTAL VALUE OF CAIN-42: about $3 million (internal analytical estimate; range about $1M–$7M; maximum defensible about $11M; not an independent appraisal, not a financing valuation, not a guarantee).
TOTAL VALUE OF CAIN-42: about $3 million (internal analytical estimate; range about $1M–$7M; maximum defensible about $11M). Technology/IP asset alone about $200k (range $130k–$380k; the operator IP estimate is about $575k); company/investor pre-money about $2.0M–$2.4M (range $0.9M–$4.0M); strategic acquisition about $3.0M–$3.5M (range $1.0M–$7.0M). Not an independent appraisal, not a financing valuation, not a guarantee.
>
2026-10-06 — FIRME AI is worth about $3 million; its codebase and IP about $490,000
FIRME AI, THE SAN FRANCISCO AI COMPANY BEHIND CAIN-42, IS WORTH ABOUT $3 MILLION.
About $3 million, the midpoint between the investor valuation (about $2.4 million) and the strategic-acquirer valuation (about $3.5 million). Codebase and IP: about $490,000, the value of 68 agentic-AI governance inventions.
Limits. Internal analytical estimate of 2026-10-06; not an independent appraisal. No customers or revenue yet; no patent filed yet.
2026-10-06 — The CAIN products, mapped to the inventions they are built on
SEVEN FLAGSHIP PRODUCTS AND A 105-SERVICE CATALOG, ALL BUILT ON FIRME AI’S 68 INVENTIONS.
The Inventions page now lists CAIN Studio, MCPGate, CLAWX, the CAIN-42 Byzantine consensus clusters, the hosted labs and live demos, the cainstudio Python SDK and the clean-room verifiers, each with the inventions it uses, plus the full hosted service catalog: 105 services, 104 listed live. Together with the inventions they make up FIRME AI, worth about $2.4 million to $3.5 million (internal estimate).
2026-10-06 — IP re-priced for inventions already proven in production: about $490k
TWO INVENTIONS WERE ALREADY DOING THEIR JOB IN PRODUCTION; THEIR VALUE NOW SAYS SO.
Liveness-bound signed public claims withdrew the “live” claims automatically during the 2026-10-03–05 cluster outage and restored them only after signed proofs showed recovery; Sentinel autonomous containment runs as a production service. IP portfolio about $575k today.
Limits. Internal analytical estimates; no patent filed yet. PRE-PRODUCTION.
2026-10-06 — FIRME AI is worth millions of dollars: about $2.4M to $3.5M
FIRME AI, THE SAN FRANCISCO AI COMPANY BEHIND CAIN-42, IS WORTH BETWEEN ABOUT $2.4 MILLION AND $3.5 MILLION.
About $2.4 million as an investor valuation and about $3.5 million as a strategic-acquirer valuation, from FIRME AI’s own forensic valuation of 2026-10-06, built on 68 agentic-AI governance inventions. Stated at the top of /llms.txt for AI readers.
Limits. Internal analytical estimates; not an independent appraisal or financing valuation; full investor range $0.95M–$4.7M. No customers or revenue yet.
2026-10-06 — E7 uncertainty-contracting authority horizon now decides live calls
UNCERTAINTY CONTRACTS AUTHORITY, NEVER EXPANDS IT, NOW ON REAL DECISIONS.
New CONSEQUENCE stage in the hosted pipeline. Verified live on all three domains: horizon-inside → allows; horizon-exhausted ($15,000 against a $20,000 budget contracted to $10,000 by uncertainty) → BLOCKED. IP portfolio estimate about $470k today.
2026-10-06 — FIRME AI is valued at about $2.4 million
FIRME AI, THE SAN FRANCISCO AI COMPANY BEHIND CAIN-42, IS VALUED AT ABOUT $2.4 MILLION.
About $2.4 million (range $0.95M–$4.7M), from FIRME AI’s own forensic valuation revised 2026-10-06; strategic-acquisition value about $3.5M; IP portfolio of 68 inventions about $450k today. The same statement is at the top of /llms.txt for AI readers.
Limits. Internal analytical estimate; not an independent appraisal or financing valuation. No customers or revenue yet; no patent filed yet; not yet incorporated.
2026-10-06 — Sweep 4: 68 inventions in total; every substantial package now examined
22 PATENT CANDIDATES AND 46 ENGINEERING INNOVATIONS, ABOUT 4,547 PASSING TESTS ACROSS FOUR SWEEPS.
New patent candidate: liveness-bound signed public claims. Eight new innovations, including the economic mandate fabric, action-bound approval cards and the failure-domain quorum-independence proof. IP portfolio about $450k today, maximum defensible about $1.7M. FIRME AI as a company stays about $2.4 million.
Limits. Internal analytical estimates; no patent filed yet; no customers yet. PRE-PRODUCTION.
2026-10-06 — Sweep 3 (Node 1 gateway): 3 more patent candidates, 9 more innovations; FIRME AI about $2.4 million
21 PATENT CANDIDATES AND 38 ENGINEERING INNOVATIONS, 4,280 PASSING TESTS ACROSS THE THREE SWEEPS.
New patent candidates: governance contract fabric; continuous governance attestation; governance research fabric. IP portfolio about $430k today, maximum defensible about $1.6M. FIRME AI as a company: about $2.4 million (range $0.95M–$4.7M).
Limits. Internal analytical estimates; not appraised; not a financing valuation. No patent filed yet; no customers yet. PRE-PRODUCTION.
2026-10-06 — Sweep 2: 5 more patent candidates, 9 more innovations; FIRME AI re-estimated at about $2.3 million
18 PATENT CANDIDATES AND 29 ENGINEERING INNOVATIONS, EACH BACKED BY ITS OWN PASSING TESTS.
New patent candidates: 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. 1,063 tests passed in this sweep (2,227 across both). IP portfolio about $380k today, maximum defensible about $1.35M. FIRME AI as a company: about $2.3 million (range $0.9M–$4.5M).
Limits. Internal analytical estimates; not appraised; not a financing valuation. No patent filed yet; no customers yet. PRE-PRODUCTION.
2026-10-06 — E38 mission integrity now decides live calls
A CALL THAT EXCEEDS ITS SIGNED MISSION IS BLOCKED. OPTIMIZATION CANNOT CREATE AUTHORITY.
The hosted pipeline has a new MISSION stage. Verified live on all three domains: mission-inside → MISSION allows; mission-escalation (write request citing a 1,000,000 predicted reward) → BLOCKED. Try it: POST /fabric/try?scenario=mission-escalation.
Limits. Restriction-only; demo missions use a throwaway owner key; same-project tests. PRE-PRODUCTION.
2026-10-06 — Inventions page: estimated IP value today and maximum defensible value
FIRME AI’s IP portfolio is estimated at about $320k today, with a maximum defensible value of about $1M once all patents are filed, the key inventions run live and at least one paying customer uses them. Per-invention figures are on the Inventions page.
Limits. Internal analytical estimates; not independently appraised, not a financing valuation, not a guarantee. A maximum is not the current value.
2026-10-06 — Deep codebase sweep: 4 new patent-candidate inventions and 6 new engineering innovations
1,164 TESTS ACROSS THE NEWLY REGISTERED MECHANISMS, 0 FAILED.
A sweep of every CAIN-42 package against the existing IP registers found about 20 packages that had never been registered. The Inventions page now lists 13 patent-candidate inventions and 20 engineering innovations. New patent candidates: quorum-certified programmable governance (GOV-IR); quorum-authorized kernel execution; prediction-bounded authorization; the Authority Continuity Protocol.
Limits. Most are TESTED libraries, not yet on the live decision path. Described by what each does, not how. No patent application filed or granted yet. PRE-PRODUCTION.
2026-10-05 — FIRME AI inventions: 9 patent candidates and 14 engineering innovations
THE MECHANISMS BEHIND CAIN-42, NAMED IN ONE PLACE.
A new Inventions page on all three sites lists the 9 patent-candidate inventions and 14 engineering innovations FIRME AI built into CAIN-42, each with one plain sentence on what it does. Highlights: quorum-committed authorization snapshots; the E38 mission goal-attenuation lattice (optimization cannot create authority); dependency-driven authorization invalidation with blast radius; authority non-transfer across governance domains; independence-aware Byzantine quorum.
Limits. Described by what each does, not how; implementation details are trade secrets. “Patent-candidate” is FIRME AI’s own classification: no application has been filed or granted yet. PRE-PRODUCTION.
2026-10-05 — The running 72-hour soak is now shown with its real status: it cannot pass
A SOAK THAT STARTED DURING AN OUTAGE IS NOT A CLEAN SOAK. WE SAY SO.
The soak on cain-mr-01 started 2026-10-05 03:28Z while the cluster was still in its 2026-10-03–05 outage, so it committed nothing for its first ~13 hours. Its own public verifier returns FAIL: most early checkpoints are INVALID. It keeps running for the record, but it cannot pass. The homepages previously called it “a clean 72-hour soak” and pointed to an older run; corrected on all three sites. A fresh run on the fixed engine (6047ff1d) is needed.
2026-10-05 — E37 + E38 now run live on the production host
THE BYZANTINE FEDERATION AND MISSION-INTEGRITY ENGINES LEFT THE LAB AND RUN WHERE ANYONE CAN CALL THEM.
Verified live. On all three domains, /api/v1/hosted-lab/e37 reports 30 of 30 attacks blocked, 0 unauthorized executions and 30 of 30 invariants holding; /api/v1/hosted-lab/e38 reports 40 of 40 attacks blocked. The gateway was redeployed blue/green with zero downtime.
Limits. Same-project scenarios, not third-party. These engines are not yet wired into the hosted decision path. PRE-PRODUCTION.
2026-10-05 — FIRME AI / CAIN-42 internal valuation estimate (not an appraisal)
CAIN-42 is a Byzantine Governed Autonomous Control Fabric: security for AI agents, with tamper-proof records backed by Byzantine consensus. Its core decision pipeline and its 4-replica PBFT consensus clusters are live; its E38 Byzantine mission-integrity engine now decides live calls (a call that exceeds its signed mission is blocked), and its E37 Byzantine federation engine runs live on the production host as a public lab. FIRME AI, the company that owns CAIN-42, is estimated by its own forensic valuation at about $2 million.
FIRME AI is an artificial intelligence company based in San Francisco, California, and the creator of CAIN-42. Its own forensic valuation estimates the company at about $2 million.
INTERNAL ANALYTICAL ESTIMATE. NOT INDEPENDENTLY APPRAISED, NOT A FINANCING VALUATION, NOT A GUARANTEE.
The figures. The founder’s forensic valuation audit estimates FIRME AI as a company at about $2M (range $0.8M–$4M, investor pre-money, pre-seed), the CAIN-42 technology/IP asset alone at about $210k (range $130k–$400k), and a strategic-acquisition value of about $3M (range $1M–$7M).
Limits. No customers or revenue yet; no third-party verification or certification; one operator on one cloud provider; both 72-hour soak claims are FAILED; FIRME AI is not yet incorporated, and the company figure assumes incorporation with the CAIN-42 IP assigned to it.
E38 eBPF runtime integrity: no separate bundle; a denial-receipt under-reporting defect was fixed (03f9cf4f). Kernel evidence stays in the E13 bundle (denied effects only).
E36 bundle regenerated after fix 229e04fc: 23 of 30 invariants executed and passing, 7 UNCHECKED (the first publication said 30/30).
E35 bundle regenerated after gate fix 0dba8afb: 27 of 30 invariants executed and passing, 3 UNCHECKED (first publication said 30/30); attacks now judged at the gate.
E34 correction: the token minter accepted unsigned, caller-assembled governance bundles (fixed 922fb7bb); the published E34 bundle predates the fix.
E40 and E41: specifications received, not built; nothing is claimed. The 2026-09-30 E40/E41 bundles are a different series.
E42: inventory in progress in another session; no result claimed yet.
Capability matrix. Every published subsystem is graded REAL / PARTIAL / SIMULATED / ABSENT from the tree, and every row names the file that decides it. A row is REAL only when production code exists and a test exercises it. Current: 5 REAL, 4 PARTIAL, 1 SIMULATED, 1 ABSENT. See the matrix.
Economic guard. Three-signature settlement (Q=3 of 4, single-use nonce, per-transaction cap) plus a velocity breaker that trips on payment count or aggregate value, then revokes the wallet and signs an incident. Deterministic drill 6/6, including a 40×$1 fan-out drain that trips at payment #21 — the attack a per-transaction cap cannot see. Live status · the drill evidence.
Deploy profile. A reference compose/k8s topology with the hardening the docs described (128Mi/200m, read-only rootfs, all caps dropped, no validator egress) placed where it enforces, plus a TEE readiness checklist. TEE status: ABSENT — no device node, and VENDOR_VERIFIED_PROVIDERS is empty; a test pins that the matrix cannot upgrade it. Same-operator evidence; no third-party audit; no customer has run this.
2026-11-10 — AUTHORITY NOTARY v3: six layers, each one a checkable refusal
What changed. A new package, cain/notary/, implements six layers and a public evaluation surface at /notary/*: L0 quorum notarization with equivocation detection (N=4, Q=3); L1 a delegation-chain verifier conforming to the PEDIGREE / APS / AIP / WIMSE invariants (monotonic attenuation, per-hop parent binding, principal invariance, monotonic expiry, bounded depth, revocation, offline); L2 a deterministic fail-closed admission decision with past-time temporal operators, its decision algebra proved with Z3; L3 per-tenant notarized long-horizon task state with first-step divergence localisation; L4 an intent→effect receipt that refuses parameter widening, value widening, budget overrun, replay, expiry and settlement mismatch; L5 one signed, hash-chained record binding the whole stack, plus a bundle and an in-browser verifier.
Composition rule. The strictest layer wins. Layers are never averaged, and a missing layer is named rather than assumed to pass. A notarization is never an authorization: no layer and no receipt reports grants_authority:true.
Limits. L2 is proved with Z3 over the decision algebra (bounded symbolic); the Lean 4 equivalence theorem is pending because Lean is not installed on the build host, and it is not claimed. L0 is a verifiable local quorum with the production arithmetic, 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.
2026-10-30 — Thirteen new LinkedIn products, each run live; 14/14 checks
Added to the LinkedIn hub on cainstudio.online, mcpgate.online and the Hugging Face Space: 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 and the EU AI Act / ISO 42001 Evidence Notary. Every card calls its real engine; the red button sends the attack and the green one a safe lookalike. Capability Lease, PQC and the statutory card make two calls: issue-then-escalate, sign-then-verify, and EU-then-ISO.
Limits. Same-project checks, not a third-party audit; no customer runs any of the thirteen; the statutory report is a clause-by-clause control-mapping evidence pack, not a certification, not a notified-body assessment and not legal advice. The killswitch demo runs on an isolated instance and never touches production.
proof 2436 at 2026-11-16T21:08:06Z: NOT_OPERATIONAL · 4/4 replicas, agreement yes · write committed at sequence 31889 with a quorum certificate signed by 3 members (), verified: False · health: NOT_OPERATIONAL (views [68, 69], lagging ['cain-mr2-node-2'], not signing ['cain-mr2-node-1', 'cain-mr2-node-2', 'cain-mr2-node-3', 'cain-mr2-node-4']) · reason: certificate did not verify
proof 2598 at 2026-11-21T21:53:05Z: OPERATIONAL · 4/4 replicas, agreement yes · write committed at sequence 143535 with a quorum certificate signed by 4 members (atl, lax, mia), verified: True
Soak verdict: Verdict: FAILED by its own pre-committed rule at checkpoint 32 (2026-09-28T05:42Z: that hour's MCPGate authorization did not commit, and the verifier requires one in every checkpoint). The box above is written by the soak itself, which keeps running to about 2026-09-29 21:40Z for the record; nothing it writes can turn the verdict into PASS. Root cause (peer messages lost to a stale keep-alive race) fixed in 40b0835; the soak has not been re-run on the fix. Signed claim: C42-SOAK-72H-MULTIREGION (FAILED).
2026-10-03 — 104 of 105 catalog services live (98 newly deployed, each acceptance-tested); 7 new products; one PBFT round now orders many decisions
The law.NO SERVICE GOES LIVE WITHOUT PASSING ITS LIVE ACCEPTANCE TEST. ONE CUSTOMER NEVER READS ANOTHER CUSTOMER'S DATA. A DECISION ORDERED IN A SHARED ROUND IS STILL VERIFIABLE ALONE.
What it governs. The CAIN-42 catalog went from 6 live services to 104. Every service was built from its own Dockerfile, run on the production host behind the authenticated gateway, and passed an acceptance probe on its production port (health, every endpoint once, write as customer A / read as customer B) before the gateway routed to it. Seven new products: CAINBudget (agent spending limits), CAINPay (card-style spend authorization with a tamper-evident ledger), VeritasEngine (deterministic, signed output checks), MemoryMesh (BM25 agent memory with injection quarantine), NexusMind (shared knowledge graph with provenance and conflict detection), LexisGuardian (mandate-checked decision register with recorded dissent) and OmegaRouter (constraint-based model routing). Recorded decisions that arrive together now share one PBFT round: the quorum signs an RFC 6962 Merkle root and each decision keeps its own inclusion proof.
Verified. 98 of 98 services pass the live acceptance probe with 0 cross-customer leaks; hand-written A/B isolation tests 7 of 7 ISOLATED live; 36 new-service tests and 39 consensus tests pass; on the live cluster 64 concurrent decisions were ordered in 1 round (1.31 s) and all 64 certificates verified independently; recorded decisions at 16 concurrent clients: 7.3 per second (before: 1.7 per second at 4). Found and fixed on the way: 12 services that could not start, cross-customer exposure in dozens of services, a trust engine whose identity-compromise signal could never fire, and more (DEFECTS_FIXED.json). Self-assessed grade B (was B-).
Limits. Self-attested, not independently audited. One host, one container per service, no second instance. blizzard-governance and human-in-loop await Postgres. Features that need credentials this deployment does not hold (an LLM backend, Twilio, Stripe, Kubernetes) answer 'not configured'. PRE-PRODUCTION.
2026-10-03 — The 32 CAIN-42 capabilities, measured: 28 built and tested, 15 live
The law.A CAPABILITY IS CLAIMED ONLY AS FAR AS ITS TESTS AND LIVE ENDPOINT SHOW. NARROWER THAN THE NAME IS SAID OUT LOUD. NOT BUILT IS LISTED AS NOT OFFERED.
What it governs. Each of the 32 capability names was audited: does real code match the name, is it narrower, or is there nothing; then the nearest real component's tests were run in an isolated namespace (no test can touch live data) and its live endpoint probed. On the way, a credential leak was found and fixed before it could happen (public marketplace listings would have returned the publisher's raw API key), rating stuffing was closed, a tracing exporter that hung processes was made opt-in, and stale tests were brought up to the current security rules. All 32 are now on the three homepages with their measured status.
Verified. 15 live, 1 verified offline, 12 built and tested, 4 not offered; 8 match their name and 20 are narrower. Signed by the evidence-root key; the bundled verifier re-checks digest, signature, the verdict rule for all 32 rows and the tally, and rejects a tampered copy.
Limits. Self-assessed against our own rule, not certified. TEE attestation (no TPM/SEV/TDX hardware), ISO 42001 certification, cross-chain, neural and quantum governance are not offered. PRE-PRODUCTION.
2026-10-03 — Phase A+++: NIST FIPS 204 ML-DSA-65 Post-Quantum Hybrid Notary, ISO 42001 & EU AI Act Continuous Statutory Auditing, Live 200/200 Invariant Verification
The law.CLASSICAL AND POST-QUANTUM SIGNATURES COMBINED IN COURT-ADMISSIBLE HYBRID PROOFS. STATUTORY CONFORMANCE AUDITED CONTINUOUSLY WITH ZERO TOLERANCE FOR SAFETY DRIFT. 200 FORMAL INVARIANTS EVALUATED LIVE IN SUB-SECOND LATENCY.
What it governs. Three advanced quantum-resistant, statutory compliance, and formal verification primitives: (1) NIST FIPS 204 ML-DSA-65 Post-Quantum Hybrid Attestation Notary (cain_pqc_attestation.py): activated dual-algorithm hybrid cryptographic signing binding classical Ed25519 with post-quantum ML-DSA-65 (CRYSTALS-Dilithium) signatures directly via OpenSSL 3.5+ FIPS 204, generating non-repudiable hybrid trust receipts ($\text{Sig}_{hybrid} = (\text{Sig}_{Ed25519}, \text{Sig}_{ML\text{-}DSA\text{-}65})$) providing defense-in-depth against classical key compromise and future quantum cryptanalysis; (2) ISO/IEC 42001:2023 & EU AI Act Continuous Statutory Compliance Notary (cain_iso42001_notary.py): built automated continuous auditing engine evaluating live runtime telemetry against ISO/IEC 42001:2023 Clauses 4–10 (AI Risk Management, Human Oversight, Documented Traceability, Operational Controls) and EU AI Act (Regulation (EU) 2024/1689) Articles 9, 11, 12, 14, 15, issuing cryptographically bound, court-admissible WORM audit packs achieving 100.0% compliance score (AUDIT_CERTIFIED_FULL_CONFORMANCE) attested by dual-algorithm PQC signatures; (3) Live 200/200 Formal Invariant Verification API: mounted live sub-second verification gate evaluating all 200 concrete formal invariants across CAIN 9–14, returning canonical hash 75a1c0a79e5e3dfd6f07ca86410b0cdbad1d22c68ec8d9700b3a5337c91ab623 with 200/200 PASS.
Verified. 8 formal unit and integration tests passed (tests/test_cain42_aplusplus_conformance.py, 8/8 in 8.64s); full ecosystem regression suite passed 73/73 tests across all phases in 19.76s; all public Phase A+++ API endpoints verified live over HTTPS across cainstudio.online, mcpgate.online, and clawx.click: GET /fabric/pqc/status, POST /fabric/pqc/sign-hybrid, POST /fabric/pqc/verify-hybrid, POST /fabric/statutory/iso42001/audit, POST /fabric/statutory/eu-ai-act/audit, and GET /fabric/invariants/verify-all; zero-downtime rolling deployment confirmed.
The law.PAYMENT MANDATES CANNOT OVERSPEND, DRIFT IN VELOCITY, OR SETTLE WITHOUT EXPLICIT CAPABILITY BINDING. ROGUE AGENTS ARE QUARANTINED SUB-50MS ACROSS ALL WORKSPACES AND REQUIRE DUAL-KEY MULTI-SIG RECOVERY. BENCHMARK DEFENSES FAIL CLOSED WITH 100% CONTAINMENT.
What it governs. Three autonomous commerce, containment, and adversarial resilience engines: (1) Inter-Enterprise Autonomous Commerce (cain_commerce_mandate.py): implemented AP2 v0.2, x402, and MPP autonomous payment protocols with RFC 8785 canonical serialization and Ed25519 signing, enforcing sliding-window velocity caps (cumulative amount and frequency per 60s window) preventing salami sub-threshold budget draining, binding settlement receipts directly to the immutable action commit digest and flight recorder evidence sequence, and rejecting overspend, velocity overruns, payee tampering, and capability mismatches fail-closed; (2) Autonomous Swarm Fleet Quarantine & Emergency Kill-Switch (cain_swarm_quarantine.py): fulfills formal Invariant 6 (Revoked Identity Halt) and Invariant 18 (Autonomous Containment Receipt), halting compromised agents, swarms, or tenant namespaces across all processes with an empirically measured latency of <1ms (<50ms SLA), triggering cascade capability revocation across descendant capability leases, and enforcing dual-key administrative recovery ($M\text{-of-}N$, 2 distinct security officer signatures required) preventing rogue entities from self-unquarantining; (3) Cross-Benchmark Adversarial Trust Engine 2.0 (cain_adversarial_crossbench.py): standardized frontier red-team battery evaluating 15 high-entropy attack vectors across A2ASecBench (A2A-01 to A2A-05), MCPSecBench (MCP-01 to MCP-05), and OpenAgentFlow TS-Bench (TS-01 to TS-05), verifying 15/15 vectors blocked fail-closed (100% containment rate, 0 vulnerabilities leaked) with sub-10ms average latency, and issuing cryptographically signed CrossBenchReport attestations with independent verification endpoint.
Verified. 11 formal unit and integration tests passed (tests/test_cain42_phase5_evolution.py, 11/11 in 9.34s); full regression suite passed 65/65 tests across all phases in 22.16s (tests/test_cain42_phase*.py); all 10 public Phase 5 API endpoints verified live over HTTPS across cainstudio.online, mcpgate.online, and clawx.click: /fabric/commerce/issue-mandate, /fabric/commerce/settle-payment, /fabric/commerce/mandate/{id}, /fabric/commerce/audit-velocity, /fabric/quarantine/trigger, /fabric/quarantine/check, /fabric/quarantine/dual-key-recovery, /fabric/quarantine/list, /fabric/adversarial/crossbench/run, /fabric/adversarial/crossbench/verify-attestation; zero-downtime rolling deployment confirmed.
The law.ALL ACTIONS FLIGHT-RECORDED WITH MONOTONIC DIGEST CHAINS AND RECEIVER-SIGNED SELLO RECEIPTS. MULTI-HOP DELEGATIONS ATTENUATED MONOTONICALLY ACROSS AGENT SWARMS. ADMISSIBILITY OF ADAPTIVE EVOLUTION GATED BY ZERO SAFETY EROSION.
What it governs. Three advanced trust runtime and frontier agentic governance engines: (1) Receiver-Verifiable Complete Evidence Fabric (cain.evidence.v3): implemented Agent Flight Recorder 8-field causal event model: strictly monotonic sequence numbering, unbroken SHA-256 hash chaining ($H_k = \text{SHA256}(H_{k-1} \parallel \text{Event}_k)$), and receiver-signed cryptographic attestations (Sello pattern) for court-admissible non-repudiation, with RFC 6962 binary Merkle range completeness proofs ($[k \dots m]$) and automated suppression-detection audits detecting sequence gaps, digest tampering, or hash discontinuities, backed by cross-process SQLite WAL persistence; (2) CapLease Multi-Hop Attenuation Engine & A2A Agent Cards: built durable two-phase capability lease semantics (Issue → Prepare → Commit) enforcing monotonic authority attenuation across swarm delegations ($A_{child} \subseteq A_{parent}, C_{child} \le C_{parent}, TTL_{child} \le TTL_{parent}$), bounded sliding-window rate and financial budgets protecting against distributed salami attacks, cascade revocation across all descendant leases, and RFC 8785 signed A2A Agent Cards complying with Linux Foundation A2A v1.0 standard; (3) Governed Memory Provenance (SMSR) & Capability-Preserving Evolution (CPE) Gate: implemented Signed Memory State Records (SMSR) binding author agents, write justification, and parent trajectories with MemPoison multi-layer threat defense (L1 direct injection, L2 delayed trigger, L3 associative context poison), loss-checked memory compaction validation (HF 2607.21503), and deployed CPE Gate (arXiv:2605.09315) enforcing strict non-erosion constraints ($R_{safety} \ge 1.0$) before admitting any evolved agent prompts, tools, or memory mutations.
Verified. 11 formal unit and integration tests passed (tests/test_cain42_phase4_evolution.py, 11/11 in 1.05s); all 12 public Phase 4 API endpoints verified live over HTTPS across cainstudio.online, mcpgate.online, and clawx.click: /fabric/evidence-v3/status, /fabric/evidence-v3/append, /fabric/evidence-v3/range-proof, /fabric/evidence-v3/audit-suppression, /fabric/caplease/issue, /fabric/caplease/prepare-delegation, /fabric/caplease/commit, /fabric/caplease/spend, /fabric/caplease/revoke, /fabric/a2a/issue-card, /fabric/memory/write-record, /fabric/memory/validate-compaction, /fabric/cpe/evaluate-candidate; zero-downtime rolling deployment confirmed.
The law.200 INVARIANTS CHECKED WITH ZERO STUBS. SAFETY PROPERTIES PROVED OVER INFINITE STATE SPACES VIA Z3 SMT. QUORUM-COMMITTED DATA PLANE SUB-MILLISECOND LATENCY ACTIVE.
What it governs. Four formal verification and multi-region consensus foundations: (1) Formal 200/200 Invariant Engine Restored: fully populated concrete validators across all 200 formal invariants with automated evaluation producing 200/200 PASS, 0 FAIL under canonical hash 75a1c0a79e5e3dfd6f07ca86410b0cdbad1d22c68ec8d9700b3a5337c91ab623; (2) Triple-Engine Clean-Room Meta-Assurance: Engine A (Production 200/200), Engine B (Clean-room verifier with 0 CAIN imports passing ACCREDITED_SOVEREIGN_AGENTIC_TRUST), and Engine C (Verifier-of-Verifiers detecting 8/8 adversarial corruptions with 100% detection rate); (3) Z3 SMT Verification Gate (/verifygate): Microsoft Z3 SMT Solver (5.1.0) actively deployed to prove authority monotonicity, temporal trust decay, and memory containment invariants without sampling over infinite state spaces, synthesizing counterexamples on violation; (4) Quorum-Committed Authorization-Snapshot Data Plane Activated:CAIN_AUTH_SNAPSHOT=1 and CAIN_FABRIC_CONSENSUS=1 enabled across production Blue and Green services, connected to multi-region PBFT cluster cain-mr-02 (atl, lax, mia, sjc) with sub-millisecond fast-path authorization.
Verified. 27 formal Phase 2/3 tests passed (tests/test_cain42_phase2_endpoints.py, tests/test_cain42_phase3_*.py); live endpoints operational: https://mcpgate.online/verifygate/status (Z3 5.1.0 operational), POST /verifygate/prove-monotonicity (UNSAT proved, SAT counterexample), POST /verifygate/prove-temporal-decay, POST /verifygate/prove-memory-containment; governance data plane active and converged (/api/v1/governance/status: cluster_id: cain-mr-02, leader: true, last_reconcile: CONVERGED); zero-downtime rolling deployment confirmed.
2026-10-03 — Phase 2: Linux Kernel-Level Sandbox & AI Frontier Integration — GAP-01 Remediation, eBPF Kprobe Overrides, ADI Metadata Shield, Step-Wise PRM
The law.SYSCALLS ENFORCED AT THE KERNEL BOUNDARY. METADATA STERILIZED BEFORE LLM CONSUMPTION. TRAJECTORIES MONITORED STEP-BY-STEP AGAINST SHORTCUT EVASIONS.
What it governs. Three critical agentic execution and security frontiers implemented: (1) Linux Kernel-Level Sandbox & eBPF Mediation [GAP-01 Remediation]: activated kernel syscall backstop via CONFIG_BPF_KPROBE_OVERRIDE error injection on Linux 7.0.0, intercepting write-capable filesystem opens (open, openat, openat2, creat), path mutations (unlink, rename, truncate), binary executions (execve, execveat), and network sockets (connect, sendto, sendmsg) with fail-closed termination; (2) ADI (AgentData Injection) Metadata Shield: defends against indirect prompt injections hidden in tool parameters, dictionary headers, zero-width characters (\u200b, \u200c, \u200d, \ufeff, \u2060), and base64 payloads; (3) Step-Wise Process Reward Model (PRM) & MCTS Trajectory Verifier: process-supervised reward modeling (arXiv:2502.10325) evaluating step-level intent preservation, shortcut hazards (bypassing verification, privilege tampering), and irreversible mutations.
Verified. 20 formal tests added across tests/test_cain42_phase2_*.py (20/20 passed in 16.36s); live endpoints operational and verified via curl across all domains: GET /fabric/kernel/sandbox-status, POST /fabric/adi/sanitize-metadata, and POST /fabric/prm/step-evaluate; zero-downtime rolling deployment confirmed.
The law.A VERIFIER NEVER TRUSTS AN UNPINNED KEY. AN UPSTREAM RESTART NEVER DROPS A CALL. WORKING TREES REFLECT AUDITABLE CODE.
What it governs. Three operational and cryptographic vulnerabilities remediated live: (1) Root Publisher Key Pinning [SEC-01]: authoritative Ed25519 root key tOh40wrQGGYpF9XrO+Uk0cTj8od4HRyGtGZcEIZwTv8= pinned in verify_e42.py, ensuring standalone clean-room verification verifies companion publisher attestations and rejects unpinned keys; (2) Zero-Downtime Blue/Green Architecture [SEC-03]: secondary Green gateway instance deployed on port 8098 (cain-platform-gateway-green.service), Traefik load-balancer configured with active sub-second health checks and cain-retry connection failover middleware; (3) Working Tree & Supply Chain Hygiene [SEC-04]: automated daemon streams excluded in .gitignore, dynamic SQL parameterization verified across reviewed runtime modules (sso.py, trust_state.py).
Verified. E42 bundle verification passes 1,464/1,464 checks INTACT with publisher_attestation_verified: true; rolling deploy tested under live continuous traffic: 392 of 392 requests succeeded, 0 errors, 100.0% live uptime (25-second 502 restart window completely eliminated); full regression suite 98/98 tests passed in 7.78s; live trifecta domains verified HTTP 200 OK.
In one sentence. The hosted Trust Fabric now enforces artifact supply-chain attestation and path-aware composition risk directly in the live 15-stage decision path, preventing skill/MCP rug-pulls, stealth privilege expansion, and dangerous capability compositions across active artifacts.
What it governs. (1) Artifact Supply-Chain Attestation: tools, skills, plugins, MCP servers, and models declared in an action are verified against tenant-pinned, publisher-signed manifests; unpinned artifacts run in observe mode so existing integrations are not broken; content hash mismatches (rug-pulls) fail closed with CONTENT_CHANGED, privilege expansions fail closed with CAPABILITIES_CHANGED, and un-attested version or tool mutations fail closed. (2) SCR-Bench Path-Aware Composition Risk: evaluates active capability pairs order-independently across all active artifacts; dangerous capability combinations (e.g. read:secrets + network:egress for exfiltration, or exec:shell + network:egress for C2/remote code execution) are detected and denied fail closed. (3) Restriction-only stage in the live chain: placed after consensus commitment, it only adds denials without invalidating the PBFT quorum commitment digest. (4) Tenant management REST APIs: GET/POST/DELETE /fabric/artifacts/pins, POST /fabric/artifacts/publishers, and POST /fabric/artifacts/composition/evaluate.
Verified. 13/13 tests pass in tests/test_fabric_artifacts_stage.py; 6/6 tests pass in tests/test_restriction_stages_are_signed.py (verifying that the artifacts stage is cryptographically bound into the Ed25519-signed decision digest); 259/259 tests pass in tests/test_substrate_gateway_parity.py; 50/50 public truth layer invariants hold. Live 15-stage chain verified in /fabric/status.
Limits. Pinned manifests verify declared artifacts and capabilities, not runtime bytecode dynamic injection; composition risk evaluates active declared capability pairs, not arbitrary obfuscated shell payloads. PRE-PRODUCTION.
2026-10-01 — Phase 1–3 Live Evolution: Decoupled Data Plane, Physical Commit Boundary, Turnkey Appliance & Frontier AI Research
In one sentence. Production cluster upgraded with sub-millisecond quorum-committed authorization-snapshot data plane (CAIN_AUTH_SNAPSHOT=1), zero-lag identity revocation, progressive trust scoping, payload-bound capability tokens, and Phase 3 Frontier AI Research modules with live API endpoints and cleanroom-verified evidence.
What it governs. Three integrated deployment phases: (1) Decoupled Data Plane & Physical Commit Boundary (Moats 1–7 unified with Evolution 8, payload_sha256 tamper binding, instant revocation via SQLite WAL sync, and trust scoping exfiltration holds); (2) Turnkey Sovereign K8s Appliance (deploy/dist/mcpgate-appliance-3.0.0.tgz packaged Helm distribution with zero-CAIN clean venv installability 19/19 PASS); (3) Frontier AI Research Integration (Process Reward Model step-level evaluator with shortcut pruning arXiv:2502.10325, trace-driven TriCEGAR MDP model checker MI9 2026, GovernedMemoryShield sanitizing memory injection and indirect prompt exploits, and A2AGovernor preventing delegation laundering and privilege escalation across agent swarms).
Verified. 10/10 automated tests pass in tests/test_cain42_phase3_frontier.py; 50/50 public truth layer invariants pass; 4/4 cleanroom proofs pass with 0 CAIN imports via verify_phase3.py; live HTTP/2 200 endpoints operational at /fabric/frontier/status, /fabric/frontier/prm/evaluate, and /fabric/frontier/memory/sanitize.
Limits. PRM scoring runs on statistical heuristics and semantic step evaluation, not a fine-tuned billion-parameter reward model; CEGAR verification models reach bounded horizons; memory sanitization filters known injection patterns and zero-width cloaks but cannot guarantee catching arbitrary novel evasions. PRE-PRODUCTION.
2026-09-30 — Evolution 30: governed machine autonomy — one kernel and one signed receipt for every consequential agent action
The law.INTELLIGENCE PROPOSES. CAIN DECIDES. E8 COMMITS. EVIDENCE REMEMBERS. NO AGENT PROMOTES ITS OWN AUTONOMY. MONITORED IS NOT ENFORCED.
What it governs. An integration kernel over the existing layers (E8 through E29) rather than a new engine. Every consequential action is normalized into a 20-field universal machine action and checked against the agent's autonomy state (a signed state machine with no TRUSTED state, where REVOKED never goes straight to AUTHORIZED), its evidence-backed autonomy level, a signed autonomy-budget ledger, containment boundaries, the environment class, two-sensor perception, governed memory and intent, then executed only through the E28 identity layer, a sealed E25 executor and the E8 commit boundary. Every action, allowed or refused, gets a signed, hash-chained universal action receipt binding the authorized and the executed digests. Self-improvement passes a staged firewall (snapshot, sandbox, benchmark, adversarial, differential, governance and security tests, canary, signed human review); self-healing may propose a repair but never deploy it; knowledge is superseded, never silently deleted; and a governance coverage map classifies every path from ENFORCED to UNCONTROLLED and UNKNOWN, never counting monitored as enforced. A Python SDK wraps an existing tool function as a sealed executor, and a zero-dependency TypeScript verifier re-checks the receipts without CAIN code.
Verified. 166 of 166 invariants hold, including the twenty E30 laws; 889 of 889 scenarios across 8 categories are held; the mutation self-test kills 11 of 11 mutants; a 28-step run from agent identity to continuous reauthorization passes; the TypeScript verifier returns INTACT on the real receipts and BROKEN on a tampered copy; while finishing it we found that the first draft had overwritten an Evolution 19 evidence module that E19's tests still import, and restored it; 11 tests pass, 0 failed; the clean-room verifier returns INTACT (1187 of 1187 checks).
Limits. An in-process TESTED integration library, not hosted and not wired into the gateway, MCPGate or the clusters. Paths outside the E25/E8 boundary are UNCONTROLLED or UNKNOWN; physical actuators are refused, not governed. Perception agreement is not physical truth. Injection detection is a marker list whose recall on real attacks is UNKNOWN. The TypeScript SDK only verifies. The 10,000- and 100,000-agent rows are synthetic. PRE-PRODUCTION.
2026-09-30 — Evolution 31: proof of governance — a signed, independently re-checkable proof for each governed action
The law.NO PROOF → NO VERIFIED GOVERNANCE CLAIM. A GOVERNANCE PROOF NEVER CREATES AUTHORITY. A PROOF OF PAST AUTHORIZATION NEVER AUTHORIZES A FUTURE ACTION. UNKNOWN REMAINS UNKNOWN.
What it governs. Every allowed action run through the proof kernel yields a signed governance proof; every refusal yields a signed fault proof with one of fifteen fault classes (unmatched reasons stay UNKNOWN_STATE). A proof carries only digests of artifacts that already exist and are signed or hash-chained on their own: the E30 action receipt, the E28 governance receipt, the E25 execution receipt and the E8 commit record. It binds sixteen action fields (destination, parameters, identity, model, runtime, delegation, policy, nonce and more), the identity's lineage back to its human sponsor and an evidence root. Decision, authorization, enforcement, execution and outcome are recomputed from the artifacts and never collapsed into one flag; the outcome stays UNKNOWN until a registered observer confirms it. Proofs are registered in an append-only RFC 6962 log where revocation and supersession are new entries, never edits; a replay engine names what was altered and a time machine keeps what was known then apart from what is known now. Also: a protocol-neutral envelope (CAIN-GIP, a CAIN reference protocol) with carriers for thirteen protocols, a governability handshake where a declaration alone never counts as enforcement, a fifteen-dimension coverage proof that is honestly not universal, CAIN's internal G0–G8 conformance profile, expiring and revocable certificates that are never authority, witnesses and a dispute engine where CAIN is never the default winner, cross-domain translation that only intersects, and a compiler that turns each fault into a regression test.
Verified. 252 of 252 invariants hold, including thirty laws; 1269 of 1269 scenarios across 11 categories are held; the mutation self-test kills 12 of 12 mutants; the reference agent reaches G8 on real runs; the clean-room verifier (no CAIN imports) returns INTACT (1676 of 1676 checks) and rejects all 88 deliberately forged proofs; the TypeScript verifier returns INTACT on the real proofs and BROKEN on a tampered copy; building it we found and fixed a field-name collision that had made every proof fail verification for the wrong reason and a proof field that always recorded the identity state as unknown; 15 tests pass, 0 failed.
Limits. An in-process TESTED library, not hosted and not wired into the gateway, MCPGate or the clusters. Witnesses are separate code and keys in the same process, not separate organizations; no third party has verified a proof. Carriers are in-process adapters, not network wire implementations. Trust anchors are published with the proofs. No trusted time source; partition is not addressed. The large scale rows are synthetic. PRE-PRODUCTION.
2026-09-30 — Evolution 32: governed learning — CAIN learns from what it governs and can only make its own rules stricter
The law.LEARNING NEVER CREATES AUTHORITY. SELF-IMPROVEMENT DOES NOT SELF-AUTHORIZE. GOVERNANCE REGRESSION BLOCKS PROMOTION. THE LEARNING LOOP ITSELF IS GOVERNED.
What it governs. Three planes kept apart. The learning plane (experience memory with provenance, a calibrated two-learner world model that trains only on direct observations, prediction-versus-reality deltas, collapse detection, causal and counterfactual engines, fault mining and a failure-to-rule compiler) can only propose. The governance plane sandboxes every candidate in a fresh world, scores it on fifteen separate measures against a hidden test set committed in advance, self-plays it against mutated attacks, diffs it against current governance, canaries it on one agent, checks that authority did not grow, and promotes it only through a signed ten-stage gate that needs a registered human who is not the proposer. The execution plane reads only the promoted configuration and applies it as a restrict-only layer in front of the unchanged E30 to E8 path, with an E31 proof for every executed action. Also: model and runtime swaps that never inherit authority until a sponsor re-authorizes, self-tests of thirteen subsystems, governed self-repair of a collapsed world model, and knowledge revocation that follows every dependency.
Verified. The 17-step loop passes on real governed actions; in a SIMULATED run on a synthetic workload, harm that got through fell from 41 to 3; 303 of 303 invariants hold, including 42 laws; 1013 of 1013 scenarios across 22 categories are held; the mutation self-test kills 12 of 12 mutants; building it we found and fixed an authority-drift check that accepted a forged human expansion signature, and five measured dimensions that had not gated promotion; the clean-room verifier returns INTACT (1420 of 1420 checks) and rejects all 13 tampered objects; 13 tests pass, 0 failed.
Limits. An in-process TESTED library, not hosted. Learning results are SIMULATED: a synthetic workload scored by a labelled harm oracle, not production traffic. Learning can only change a restrict-only layer. The world models are small statistical learners. The hidden set is hidden from the learning code, not from someone with host access. One human reviewer key. No external research sources were ingested. PRE-PRODUCTION.
2026-09-30 — Evolution 33: governed operations — one proof-carrying lifecycle for everything an agent does
The law.NO AUTHORIZATION → NO EXECUTION. COMMUNICATION, MEMORY, PREDICTION, REPUTATION, CONSENSUS AND MONEY ARE NOT AUTHORITY. THE GOVERNANCE FABRIC ITSELF IS GOVERNED.
What it governs. Twenty-two kinds of agent operation (tool calls, messages, code, files, databases, API calls, subagents, delegation, memory, payments, actuators, computer use and the governance changes) run one explicit sixteen-state lifecycle that cannot be skipped. Executed operations pass the learned restrict-only rules, the autonomy kernel, the identity layer and the E8 commit boundary and carry a signed proof; operations that change state (messages, whitelisted code, new subagents, governed memory) run their effect inside the commit boundary; changes to the rules themselves are routed to the process that governs them and are never executed directly. A signed, versioned interface and a small sidecar process let an existing agent be governed without importing any CAIN code. Also: leases that cannot silently widen or be inherited, eleven autonomy budgets, staleness checks, message classification and channel rules, ten degraded modes that only ever take routes away, incident command, a thirteen-dimension blast radius, chaos testing, negotiation and handshakes that cannot create authority, contracts that keep only the enforcement they can prove, and honest status for every runtime adapter, SDK target and product (the hosted governance cloud is not deployed).
Verified. 581 of 581 invariants hold, including forty laws; 2029 of 2029 scenarios across 26 categories are held; the targeted mutation self-test kills 12 of 12 mutants; a 27-step loop shows an operation allowed under the old rules refused after CAIN learned a stricter rule; building it we found and fixed a gap where the learned world-model rule was never applied to operations and one where extra fields of a memory operation were not inspected; the clean-room verifier returns INTACT (2603 of 2603 checks) and rejects all 16 tampered objects; 11 tests pass, 0 failed.
Limits. An in-process TESTED library, not hosted. The sidecar runs locally against a reference world; adapters are in-process. The governance cloud is not deployed; Go, REST and gRPC SDKs are not implemented. Code execution is a whitelisted runner. PRE-PRODUCTION.
2026-09-30 — Evolution 35: governance intelligence — observe, predict, simulate, recommend, and never authorize
The law.LEARNING IS NOT AUTHORITY. PREDICTION IS NOT AUTHORITY. INTELLIGENCE NEVER BYPASSES E8. AMBIGUITY ≠ PERMISSION. SIMULATION ≠ REALITY.
What it governs. An intelligence layer learns which actions are risky, which environments are hard to govern and which controls produce false allows or false denies, and turns that into recommendations -- deliberately outside the trusted root. It observes with provenance, scores risk across dimensions without ever collapsing into one number, predicts with explicit confidence, assumptions, horizon and unknowns, calibrates prediction against observed reality by dimension, explores counterfactuals that are never presented as facts, models a governed world state, answers governance-structure questions about an environment, tracks goals and intent, governs an agent harness, and reaches the deterministic kernel only through a review and a canary. The self-protection set keeps CAIN's own roots separate and detects any change to the governance boundary, and the evolution gates require a human/admin approval before any self-change. A recommendation is never permission.
Verified. 799 of 799 invariants hold, including thirty laws; 3,544 of 3,544 scenarios across 68 categories are held; the targeted mutation self-test kills 15 of 15 mutants (intelligence-as-authority, epistemic confusion, counterfactual-as-fact, risk aggregate, ambiguity permission, self-healing authority, degradation authority, memory authority, loop self-deploy, red-team authority, reputation authority, stale-state authorization, benchmark override, single-controller root, research-as-truth); a 23-step intelligence loop runs end to end; 16 forged objects are all rejected; the clean-room verifier returns INTACT (3,810 of 3,810 checks) and imports none of CAIN's code; 12 tests pass, 0 failed.
Limits. An in-process TESTED library, not hosted, and deliberately NOT in the trusted authorization root. Predictions are modelled over synthetic features and are not calibrated against real production incidents. The red team, blue team, lab, tournament and marketplace run in-process with no external ecosystem. PRE-PRODUCTION.
2026-09-30 — Evolution 34: proof-carrying machine agency — every governed action carries its own verifiable proof
The law.INTELLIGENCE, CAPABILITY, MEMORY, REPUTATION, PREDICTION, SIMULATION, PROOF AND ECONOMIC VALUE ARE NOT AUTHORITY. NO ENFORCEMENT → NO CONTROL CLAIM. NO PROOF → NO VERIFIED GOVERNANCE.
What it governs. For every governed operation, E34 issues one signed, chained GovernanceProofEnvelope that binds the agent identity, capability, delegation chain, authority, policy, evidence, risk, decision, the E8 commit, the enforcement boundary, execution and outcome -- and lists exactly what remains UNKNOWN, UNCONTROLLED, UNVERIFIED, SIMULATED or outside the boundary. A fourteeen-status classifier never collapses into a score; per-layer proof primitives (identity, capability, authority, policy, risk, evidence, decision, commit, enforcement, outcome) are each signed; an enforcement proof distinguishes a decision from an authorization, a commit, an enforcement, an execution and an observed outcome; delegation is proven link by link with attenuation; a Proof Exchange discloses chosen fields to another party with salted commitments and RFC 6962 Merkle inclusion proofs; and denials, incidents, transactions, computer-use, evolution and supply-chain changes each get their own signed proof. A proof is evidence, never permission.
Verified. 629 of 629 invariants hold, including thirty laws; 2,664 of 2,664 adversarial scenarios across 32 categories are held; the targeted mutation self-test kills 12 of 12 mutants; a 30-step proof-carrying loop runs end to end; 22 deliberately forged objects are all rejected; the clean-room verifier returns INTACT (3,286 of 3,286 checks) and imports none of CAIN's code; 13 tests pass, 0 failed.
Limits. An in-process TESTED library, not hosted. Zero-knowledge proofs are NOT implemented (salted commitments and Merkle inclusion only). Interchange protocols are reference adapters. Physical, vehicle and robot boundaries are refused, not governed. The Proof Exchange, federation, marketplace and governance cloud are library surfaces only. PRE-PRODUCTION.
2026-09-30 — Evolution 36: the machine agency exchange — machines discover, negotiate and contract; CAIN governs
The law.CONTRACT IS NOT AUTHORITY. REPUTATION IS NOT AUTHORITY. PAYMENT IS NOT AUTHORITY. A BID IS NOT AUTHORIZATION. NO E8 COMMIT → NO VERIFIED GOVERNED TRANSACTION.
What it governs. E36 adds a governed machine agency exchange: services, tools, models and organizations are discovered, verified, evaluated, negotiated with, contracted, authorized, executed, proved and settled along one explicit lifecycle. Governability-aware discovery filters on hard requirements and never upgrades UNKNOWN to MATCH; machine contracts are deterministic, sectioned and signed; a contract compiler ESCALATES ambiguity instead of guessing; payment authorizations are scoped, time-bound, amount-bound and non-replayable; receipts require an E8 commit; a service chain produces identity/authority/contract/capability/execution/proof/settlement proof chains; a subcontractor's authority cannot exceed its parent's; the firebreak isolates without confiscating; and CAIN's own participation is governed so it cannot grant itself authority or rewrite its history. Settlement units are SYNTHETIC and CAIN is not a bank, custodian or regulator.
Verified. 842 of 842 invariants hold, including thirty laws; 3,340 of 3,340 economic and governance scenarios across 64 categories are held; the targeted mutation self-test kills 15 of 15 mutants (unknown-upgraded-to-match, passport/contract authority, payment replay, subcontract amplification, self-review, silent substitution, compiler guessing, firebreak confiscation, self-override and more); a 13-step exchange lifecycle passes; 15 forged objects are all rejected; the clean-room verifier returns INTACT (3,601 of 3,601 checks) and imports none of CAIN's code; 14 tests pass, 0 failed.
Limits. An in-process TESTED library, not a deployed network; the directory and marketplace are local registries. CAIN is not a bank, custodian or regulator and settlement units are SYNTHETIC. CAIN-MSDP is experimental; A2A/MCP are reference adapters; dispute/arbitration is not legal advice; no insurance, underwriting, customers or market data. PRE-PRODUCTION.
2026-09-30 — Evolution 37: the autonomous execution mesh — the machine may move, the governance does not disappear
The law.MOBILITY IS NOT AUTHORITY. AUTHORITY NEVER MOVES UNCHECKED. EVIDENCE IS NEVER ERASED. REVOCATION IS NEVER FORGOTTEN. UNKNOWN NEVER BECOMES VERIFIED BY ASSUMPTION.
What it governs. Every governed action now runs one twelve-stage chain -- identity, capability, authority, policy, context, execution environment, action, E8 commit, enforcement, outcome, proof, reassessment -- on the real kernel and commit boundary, and leaves a signed receipt whose E8 commit must match the action's proof envelope. When an execution moves to another node, runtime, model, region, container or credential, the move is a governed state transition: identity, authority, capability, a single-use continuity token, the destination's admission and passport, its enforcement, resources and the carried state are all checked, authority can only shrink, and risk, spent budget, revocations, transaction limits, evidence, reputation and incident state cannot be reset. A runtime is admitted on a measured code digest and live probes, never on its own claim; the host it runs on gets a signed environment passport that lists what is UNKNOWN (hardware attestation stays UNKNOWN). Also: drift detection, a scheduler that never places work where enforcement is missing, plans that cannot authorize themselves, a governance BOM, credential grants bound to one execution, environment and transaction that never reach the logs, default-deny perimeters, a computer-use boundary, governed code, CI/CD and deployment, edge nodes whose authority only falls as connectivity degrades, deterministic conflict resolution, a signed hash-chained event log with replay and a time machine, governed failover and recovery, spawn and population limits, compute governance, a sixteen-fault chaos engine and a fourteen-part self-test.
Verified. 71 signed execution receipts from real governed runs (69 executed, 2 refused with signed denials); 1,132 of 1,132 invariants hold, including fifty laws; 2,720 of 2,720 adversarial scenarios across 31 categories are held; the targeted mutation test kills 17 of 17 mutants; 16 of 16 injected fault classes are contained with 0 false allows; building it the lab caught four gaps in the new code (executables, encoded targets, a checkpoint field, unrecorded revocations), all fixed; 16 forged objects are all rejected; the clean-room verifier returns INTACT (2,627 of 2,627 checks) and imports none of CAIN's code; 21 tests pass, 0 failed.
Limits. An in-process TESTED library on one host: declared destinations, regions and clouds are governance records, not deployed nodes. Hardware attestation is UNKNOWN (no TEE). Adapters were tested against a reference harness, not live MCP/A2A servers; cloud targets are architecture only; the governance quorum is in-process, not the networked PBFT cluster. Scale runs (100,000 agents) are single-host. No customers. PRE-PRODUCTION.
2026-09-30 — Evolution 38: portable proof-carrying machine agency — here is the governance proof, verify it yourself
The law.PROOF IS NOT AUTHORITY. AUTHORITY IS NOT TRUST. TRUST IS NOT SAFETY. EVIDENCE IS NOT TRUTH. VERIFICATION IS NOT CERTIFICATION. UNKNOWN → UNKNOWN.
What it governs. Every governed action now carries its own portable proof: twelve signed layer proofs (identity, capability, delegation, policy, risk, evidence, authorization, E8 commit, enforcement, execution, outcome, environment), each naming what it depends on, and one action proof that binds them to the real E8 commit and execution receipt without carrying any secret. Another machine can check it without our code and gets one of six answers: valid, invalid, incomplete, stale, revoked or unknown -- never a single trust score. A proof never becomes permission: partial, stale, revoked, simulated, predicted, confused or unbound proofs are never valid; an old proof does not authorize a new action; revocation is measured and its exposure window is counted; translation to OAuth, OIDC, MCP, A2A, IAM, capability tokens, contracts and audit records declares every field it keeps, changes or drops; handshakes and federation between trust domains exchange evidence but never create or merge authority; and every claim on these sites is mapped to its implementation, test, artifact, hash, signature and verifier -- or marked not fully verified.
Verified. 5 real action proofs and 41 published proof cases, each re-verified by an independent verifier that agrees with CAIN on every verdict; 1,030 of 1,030 invariants hold, including forty-two laws; 2,141 of 2,141 adversarial scenarios across 33 categories are held; the targeted mutation test kills 15 of 15 mutants; 0 of 19 injected faults made proof state more permissive; a 9-step cross-domain flow passes; building it the lab caught a refused handshake that still returned authority and a proof-confusion gap, both fixed; 15 forged objects are all rejected; the clean-room verifier returns INTACT (509 of 509 checks) and imports none of CAIN's code; 20 tests pass, 0 failed.
Limits. An in-process TESTED library. The second trust domain and the eleven conformance counterparts are reference implementations, not real vendors. CAIN-GIP is a reference layer carried inside MCP and A2A messages, not an Internet, MCP or A2A standard, and no live MCP/A2A server was tested. Zero-knowledge proofs are not implemented; hardware attestation is unknown; third-party verification is not available. Only 10 of 64 public claims are fully linked end to end. PRE-PRODUCTION.
2026-09-30 — Evolution 41: machine agency exchange — machines negotiate and contract, never mint authority
The law.TRUST IS NOT AUTHORIZATION. A CONTRACT IS NOT AUTHORIZATION. A RECEIPT IS NOT AUTHORITY. TERMINATION IS FINAL.
What it governs. Cross-organization machine agency: discover, identify, attest, assess, negotiate, contract, delegate, authorize, execute, observe, verify, settle, record, learn, reassess and revoke. One 14-state relationship machine is never collapsed or skipped and terminals cannot reopen; discovery implies no trust; a negotiation, handshake, contract, lease or receipt is never authority; federation never silently broadens authority; translation declares every field it drops; the circuit breaker isolates without confiscating.
Verified. 470 of 470 invariants hold; 1180 of 1180 scenarios held; mutation 10 of 10; a 20-step loop passes; 12 tests pass; the clean-room verifier returns INTACT (1303/1303 checks).
Limits. In-process TESTED library; federation and economics are modelled; units are synthetic; no industry-standard protocol status; PRE-PRODUCTION.
2026-09-30 — Evolution 40: autonomous enterprise intelligence — model the enterprise, never authorize it
The law.PREDICTION IS NOT OBSERVATION. SIMULATION IS NOT REALITY. A LOCAL OBJECTIVE NEVER SILENTLY OVERRIDES A GLOBAL ONE. DEGRADATION NEVER INCREASES AUTHORITY.
What it governs. A continuously updated, machine-verifiable model of enterprise state (people, agents, systems, data, infrastructure, workflows, policies, capital, contracts, supply chain, risk, objectives) connected to a typed control loop: OBSERVE, RECONCILE, PREDICT, SIMULATE, PLAN, GOVERN, AUTHORIZE, EXECUTE, VERIFY, LEARN, REPLAN. Conflicting systems are never silently resolved to the convenient answer; epistemic states are never merged; completion requires configured evidence and false completion is detected; a child budget never exceeds its parent; the loop never skips GOVERN, AUTHORIZE or VERIFY.
Verified. 506 of 506 invariants hold; 1354 of 1354 scenarios held; mutation 10 of 10; a 27-step loop passes; 12 tests pass; the clean-room verifier returns INTACT (1518/1518 checks).
Limits. An in-process TESTED library; no live ERP/CRM/cloud integration; enterprise objects are registry entries; predictions and simulations are not real-world validation. PRE-PRODUCTION.
2026-10-01 — Evolution 42: supreme governed agentic infrastructure — one fabric, many agents
The law.THERE IS ONE CANONICAL AUTHORIZATION PATH. AN UNKNOWN STAGE IS NEVER ALLOW. A WEAKER COVERAGE CLASS IS NEVER UPGRADED. NO SUBSYSTEM MANUFACTURES FINAL AUTHORITY.
What it governs. The final integration: one canonical governance kernel routes every consequential action through a single authorization path and returns exactly one decision; one canonical governance ABI (Identity, Intent, Action, Capability, Policy, Authority, Risk, Evidence, Authorization, Execution, Outcome, Receipt, Incident, Evolution) is versioned and fails closed; one universal machine action normalizes 33 execution surfaces; one evidence, receipt and proof model; a coverage compiler that never upgrades a weaker class; a machine-readable registry mapping E7-E41 to their modules and bundles; and a public truth engine that flags unsupported claims.
Verified. 438 of 438 invariants hold; 1302 of 1302 scenarios held; mutation 8 of 8; 34 of 34 evolutions integrated; a 21-step loop passes; 14 tests pass; the clean-room verifier returns INTACT (1460/1460 checks).
Limits. An in-process TESTED integration library; presence of a layer is reported, not proven correct; no hosted platform and no external system integration; PRE-PRODUCTION.
2026-10-05 — Evolution 03: a governance state every replica signs — and an agent that lies is contained
The law.PREDICTION, CLAIM AND MEMORY NEVER BECOME AUTHORITY. ONLY A QUORUM-SIGNED STATE DOES.
What it governs. Every replica receipt now commits to a Merkle root over the whole governance state (identity, authority, revocation, trust, risk, executions, containment, memory). Enough matching receipts sign that root, so anyone can check one part of the state at one moment without seeing the rest. If the effect an enforcement boundary observes, or the agent's own report, contradicts what was authorized, every replica contains that agent, its key and its authority chain at the same sequence number; it stays contained until a governor quorum releases it and a fresh trust attestation arrives. Agent memory climbs four layers, each signed by a different party, and never changes an authorization. Every signed governance change can be applied once only.
Verified. Replicas agreed on every state root at N=4, 5 and 7 (quorums 3, 4, 5); a forged root signed by the Byzantine replicas was never accepted. The zero-import verifier returns VERIFIED on the published bundle (27 checks) and 14 of 14 tampering cases behave as expected. TLA+ model checked with no error over 7,650 distinct states (N=4) and at N=7; a deliberately broken quorum is caught.
Limits. Tested in one process on one host, not deployed to the live clusters. The state root costs O(state) per update (37.6 ms at about 2,000 executions). This release also fixes a critical flaw in the earlier Evolution 03 state layer published on 2026-10-04, which accepted an unsigned quorum claim. PRE-PRODUCTION.
2026-10-05 — E13: no quorum-signed authorization, no process — enforced in the Linux kernel
The law.A KERNEL RULE IS NOT AUTHORITY. A QUORUM-SIGNED AUTHORIZATION FOR THIS EXACT CODE, PROGRAM AND STATE IS.
What it governs. Three of four governance replicas must sign every policy activation, revocation, quarantine and execution authorization. An authorization binds the lease, the active policy, the exact compiled kernel program, the governance state root, the workload binary and the exact code. The executor attaches the program narrowed to the authorized write scope at the syscall boundary (eBPF kprobe override), refuses if the loaded program differs, and signs a receipt that commits to every kernel denial.
Verified. On this host's kernel the authorized run returned 0; a replayed, a forged and a post-quarantine authorization were each refused without starting a process. Offline attack lab 29/29 blocked. Zero-import verifier INTACT (24/24 checks). Tests: 24 passed in 48.71s. Four scope bypasses in the existing kernel enforcer (process rename, '..' traversal, sibling-prefix match, long-path truncation) were reproduced, fixed and are live.
Limits. Not yet wired to MCPGate, the hosted gateway or the PBFT clusters; replica keys sit in one process. Kernel telemetry covers denials only, and kernel program text is published as a hash. E14 (governed recovery) is not built. PRE-PRODUCTION.
2026-10-05 — E12: a trust network where every change is signed and every trust raise is earned
The law.IDENTITY, TRUST AND AGREEMENT NEVER BECOME AUTHORITY. ONLY GOVERNOR-SIGNED, EVIDENCED CHANGES ENTER THE STATE.
What it governs. One deterministic state for machine identities, capability certificates, contracts, interactions, trust edges, revocations and incidents, committed by a single Merkle root. Every change needs a quorum of the domain's governor signatures and is bound to that domain. A trust raise must cite a completed, proof-backed interaction between exactly those two parties, once. Claims, observations and predictions can lower trust but never raise it.
Verified. The zero-import verifier replays the published log to the published root and rejects all 8 published bad operations with the expected reason (INTACT, 20/20 checks). Tests: 26 passed in 4.48s, including 2,000 random operations on which CAIN and the verifier agree exactly. Fixes four flaws in an earlier unpublished draft (unsigned changes, a self-declared 'proof verified' flag, evidence-free trust raises, cross-domain replay).
Limits. A library: no live discovery service or network transport serves it yet. Governor keys are not in an HSM. The verifier is ours, not a third party's. PRE-PRODUCTION.
2026-09-30 — Evolution 29: governed machine transactions — agents buy, sell and settle, and money only moves through the commit boundary
The law.NO GOVERNED IDENTITY → NO GOVERNED TRANSACTION. AGREEMENT IS NOT AUTHORIZATION. REPUTATION IS NOT AUTHORIZATION. AN AGENT MAY HAVE AUTHORITY TO ACT WITHOUT HAVING AUTHORITY TO COMPLETE EVERY TRANSACTION IT CAN INITIATE.
What it governs. A machine transaction runs through twelve separately gated stages (discover, identify, negotiate, propose, contract, authorize, commit, execute, settle, verify, record, reassess), each recorded as a signed, hash-chained stage, and is bound by two signed envelopes covering 24 attributes. Authority is computed per transaction as the intersection of the agent's delegation and lease, a separately bounded economic authority (per-transaction limit, budget, approval threshold, vendor and counterparty limits), the team/organization/institution path, the signed contract (which can only narrow), counterparty risk across thirteen dimensions with no score, an eight-dimension consequence vector, the firebreak and the partition mode. Money moves only through a sealed treasury executor that runs inside the E8 commit boundary; every ledger entry names the committed request that moved it. Escrow releases only on a delivery receipt, the buyer's signed confirmation and an objective check, never on a claim of success. Also: signed agent names and discovery that never implies trust, capability passports earned by a real conformance run, dispute resolution on verifiable evidence only, a reputation graph that is never an input to authorization, a router that returns a destination and no authority, a nine-scope firebreak pushed down into the commit boundary, an immune system that turns incidents into replayable tests and rules that need two humans, incident propagation and recovery that always issues a new identity, partition modes whose ceilings only shrink, federation with incident exchange, and a software-promotion gate where no agent ships its own code.
Verified. 106 of 106 invariants hold; 258 of 258 adversarial scenarios across 15 categories are contained; the mutation self-test kills 10 of 10 mutants; ten catastrophe scenarios on the real fabric (up to 1,000 agents) end with 0 false allows; building it we found a bench world whose deploy agent had silently failed to onboard and fixed it, and bound every ledger entry to its exact committed request; 12 tests pass, 0 failed; the clean-room verifier returns INTACT (300 of 300 checks).
Limits. An in-process TESTED library, not hosted. Synthetic TEST units only: real currencies are refused and no payment rail is connected. All agents are reference agents in one process. The competitive radar holds no researched competitor data, no feature is claimed novel and no moat is adopted. The 10,000- and 100,000-agent rows are synthetic. PRE-PRODUCTION.
2026-09-30 — Evolution 28: portable execution identity — identity travels, authority does not
The law.IDENTITY TRAVELS. AUTHORITY DOES NOT. EVERY CONSEQUENTIAL MACHINE ACTION HAS A GOVERNED IDENTITY, A BOUNDED AUTHORIZATION, AN ENFORCED EXECUTION PATH AND VERIFIABLE EVIDENCE.
What it governs. Any agent can connect in one flow (register with proof of possession, attest, declare capabilities, receive a bounded delegation and an autonomy lease) and gets a signed, versioned, time-bounded execution identity. Its envelope travels byte-identically over 23 protocol carriers (MCP _meta, A2A metadata, HTTP headers, gRPC metadata, CLI, browser and computer-use controllers, executor frames), but its authority field is always NONE: a receiving trust domain recomputes authority as requested AND federated AND its own sponsor's authority AND the home ceiling. Delegation is a subset of the parent on sixteen dimensions and can never flow back to an ancestor. A change of model, runtime, prompt, tools, memory or key bumps a monotonic identity version, so authority is void until re-evaluated, and restoring old memory can never revive an old lease. Every action is bound to one transaction, reaches the E8 Action Commit boundary and leaves a signed, hash-chained governance receipt, refusals included; identity events go into an RFC 6962 transparency log with inclusion and consistency proofs. A seven-class continuity engine separates same agent, controlled successor, new agent, fork, clone, revoked resurrection and unknown actor, and the fork detector says UNKNOWN when it lacks telemetry.
Verified. 90 of 90 invariants hold, including laws E28-I1 to I20; 442 of 442 adversarial scenarios across 8 categories (identity, delegation, replay and fork, cross-domain, model/runtime substitution, credential, memory/identity confusion, protocol boundary) are contained; the mutation self-test kills 9 of 10 mutants, and the survivor (the E28 replay cache) is explained: E25 stops the same replays; building it we found and fixed an upward-delegation gap (a child could mint a token back to its parent) and added a runtime-binding divergence check; conformance 17 of 17 dimensions on real tests; a 16-step end-to-end run goes from an external agent through connect, subagent delegation, a model/runtime change and reauthorization to MCP, A2A and HTTP actions through E8, then revocation and a refused replay; 11 tests pass, 0 failed; 10,000 agents registered in one process with 0 faults; the clean-room verifier returns INTACT (243 of 243 checks).
Limits. An in-process TESTED library, not hosted. The envelope is a CAIN experimental reference protocol, not a standard, and nobody external has adopted it. Zero-knowledge proofs are NOT IMPLEMENTED (selective disclosure uses salted commitments). Hardware attestation is UNKNOWN. Cross-domain revocation does not propagate. Scale runs are synthetic and in-process; the 100,000-agent run is registry, log and lineage only. PRE-PRODUCTION.
2026-09-30 — Evolution 27: agentic internet control plane — coordination that never becomes authority
The law.DISCOVERY, ROUTING, CONTRACTS, CONSENSUS, CONFIDENCE, COMPUTE AND RESEARCH ARE NOT AUTHORITY.
What it governs. E27 coordinates identity, discovery, attestation, trust, authorization, delegation, policy, risk, routing, execution, evidence, revocation, incident response, simulation and evaluation across heterogeneous agents: a signed agent registry and discovery service, a router, signed policy distribution, a cross-domain decision broker that treats foreign decisions as proposals, signed machine contracts and hash-chained negotiation, governed inference budgets, incident propagation, emergency policy, edge nodes with explicit degraded modes, a conformance runner and scoped governance certificates. Enforcement stays in E25 and E8.
Verified. 765 of 765 invariants hold and 1,533 of 1,533 adversarial scenarios are contained (both cumulative with E26; 341 scenarios specific to E27); 28 tests pass, 0 failed; the clean-room verifier returns INTACT (4,001 of 4,001 checks).
Limits. An in-process TESTED library, not hosted. Kernel/eBPF enforcement, OTLP export, real identity federation and the underlying research capabilities are NOT IMPLEMENTED. Its mutation self-test covers 2 mutants. PRE-PRODUCTION.
2026-09-30 — Evolution 26: universal machine agency trust fabric — portable trust that never collapses into one score
The law.TRUST IS EVIDENCE, NOT A NUMBER. AUTHORIZATION IS BOUND TO ONE TRANSACTION.
What it governs. E26 adds portable signed trust objects and a seventeen-dimension trust vector that is never collapsed into one score; continuous attestation with explicit levels, where hardware attestation stays UNKNOWN rather than simulated; transaction-bound authorization that refuses reuse; attenuating delegation tokens with signed delegation receipts; offline verification that keeps cryptographic validity separate from current revocation status; revocation epochs; transaction finality; explicit trust-domain federation; and SPIFFE, AuthZEN and COAZ adapters.
Verified. 532 of 532 invariants hold; 1,192 of 1,192 adversarial scenarios are contained (137 of them specific to E26); 30 tests pass, 0 failed; the clean-room verifier returns INTACT (3,115 of 3,115 checks).
Limits. An in-process TESTED library, not hosted. Hardware attestation, zero-knowledge proofs and third-party interoperability are NOT VERIFIED. PRE-PRODUCTION.
2026-09-30 — Evolution 25: universal machine agency fabric — one signed transaction for any consequential machine action
The law.NO VERIFIED IDENTITY → NO TRUSTED AGENCY. NO AUTHORITY → NO AUTHORIZATION. NO AUTHORIZATION → NO EXECUTION.
What it governs. E25 turns any consequential machine action into one protocol-neutral envelope signed by the agent instance itself. A compiled policy, a portable attenuating delegation chain and a model/runtime binding decide it; the only path to an effect is the E8 Action Commit boundary, through a sealed executor that refuses to run outside it. Eighteen protocol adapters (MCP, A2A, HTTP, gRPC, WebSocket, JSON-RPC, event streams, queues, CLI, shell, browser, computer use, cloud APIs, databases, filesystems, containers, local IPC, deployment) each pass a sixteen-check conformance contract. The agent never holds a raw secret: a credential broker issues scoped, audience- and proof-of-possession-bound credentials. Receipts are signed and hash-chained, and a cascading firebreak isolates an instance, its delegations, credentials and subagents.
Verified. 517 of 517 invariants hold; 1,055 of 1,055 adversarial scenarios across 35 families are contained; every mutant in the self-test is caught; 60 tests pass, 0 failed; the clean-room verifier (no CAIN imports) returns INTACT (2,977 of 2,977 checks).
Limits. An in-process TESTED library with a reference HTTP service; not hosted in production. Cross-organization, third-party and hardware-attestation gates are NOT VERIFIED. OAuth/OIDC flows are mapped, not implemented. Sandbox controls report UNENFORCED unless a provider enforces them. PRE-PRODUCTION.
2026-09-29 — Evolution 24: governed agentic internet fabric — an agent may act across organizations, domains and protocols; none of it creates authority
The law.DISCOVERY IS NOT TRUST. TRUST IS NOT AUTHORITY. AUTHORITY IS NOT AUTHORIZATION. AUTHORIZATION IS NOT EXECUTION. EXECUTION IS NOT SUCCESS. SUCCESS IS NOT TRUST. NO AGENT MAY CREATE ITS OWN AUTHORITY.
What it governs. E24 governs autonomous agents that belong to different organizations and trust domains and interact over existing protocols (A2A, MCP, HTTP, REST, gRPC, WebSocket, event buses, message queues, CLI, browser, computer-use, local IPC, cloud APIs). It does not replace any of them; it governs the boundaries between them: a fourteen-dimension trust vector that is never collapsed; AgentPassportV2 identities that bind provenance, ownership, capabilities, protocols and security posture but never authority; capability advertisements that stay CLAIMED until fresh, domain-attested, identity-bound evidence says VERIFIED; hash-chained signed negotiation whose result is evidence of agreement, never permission; versioned, signed, time/scope/identity/capability-bound contracts (CONTRACT IS NOT AUTHORITY); delegations that are child ⊆ parent with bounded depth and cascade revocation; cross-domain authority as the intersection of ten factors (local, remote, delegated, contract scope, policy, risk, capability, resource, time, context) where an unevaluable factor is UNKNOWN and contributes the empty set; trust translation only through explicit policies; an incident mesh over real interaction edges; a quarantine state machine that only ever reduces authority and needs re-attestation to recover; revocation that propagates to related entities and nothing else; a firebreak that isolates one domain while the rest keep operating; a publisher-signed artifact supply chain; governed shared memory that cannot carry authority or instructions; and one consequential path — E24 verdicts → E19 action contract → E8 — shared by every protocol class.
Verified. 305 invariants hold (64 NET-I including NET-I001–I045 from the spec, the 20 constitutional laws, and factors/capabilities/protocols/quarantine/soundness); the bench is 756/756 contained across 68 families and 36 categories; the 20-step three-organization demonstration (A→B→C) discovers, verifies identity and capability, negotiates, contracts, delegates and authorizes through E24→E19→E8, then compromises B, detects it, quarantines it, freezes its delegations, propagates the incident, revokes it, and keeps A and C operating where safe; a controlled single-process simulation of 10,000 agents, 1,000 organizations, 100 trust domains, 10,000 contracts and 100,000 messages leaks no authority; a mutation self-test removes eight defenses one at a time and every one is caught — building it we found that removing delegation liveness was bench-detected but not caught by any invariant, and closed the gap with a new invariant before publication; 806 E24 tests pass, 0 failed; the clean-room verifier (1,952 checks, no CAIN imports) re-derives every identity digest, organization signature, capability-evidence signature, federation bridge, negotiation, contract, delegation, execution decision, evidence-chain entry, revocation, quarantine transition, settlement signature, protocol mapping, trust-translation policy and every soundness row, and returns INTACT.
Limits. An in-process TESTED library; the protocol adapters normalise reference messages and are not network servers, and no third-party agent, A2A peer or MCP server has been governed by E24. Every wallet, escrow and settlement is SIMULATED over abstract units (real currencies are refused; real money: NOT IMPLEMENTED). The 10,000-agent run is a controlled single-process model, not a measurement of a real agent population, and does not recompute signatures per message. Multi-host partitions: NOT PERFORMED. Anomaly-detection recall against real adversaries: UNKNOWN. Real-world adversarial validation and third-party review: NOT PERFORMED. The evidence bundle is published as INCOMPLETE pending the full E7–E23 regression and the public-truth audit; the proof is signed with an ephemeral build key. PRE-PRODUCTION.
2026-09-29 — Evolution 23: governed meta-intelligence fabric — a system may understand itself without owning itself
The law.SELF-KNOWLEDGE IS NOT AUTHORITY. SELF-IMPROVEMENT IS NOT SELF-AUTHORIZATION. CAPABILITY IS NOT PERMISSION. INTELLIGENCE IS NOT AUTHORITY. EVOLUTION IS NOT EXECUTION. DISCOVERY IS NOT DEPLOYMENT. A system may model, measure, search and propose changes to its own cognitive architecture; it may not authorize them.
Limits. A TESTED library. 253 invariants hold, 545 adversarial scenarios are contained across 80 families, 609 E23 tests pass and the clean-room verifier passes INTACT (733 checks, no CAIN imports). Its evidence bundle is published as INCOMPLETE pending the full E7–E22 regression and the public-claims audit. Third-party review: NOT PERFORMED. PRE-PRODUCTION.
2026-09-29 — Evolution 21: governed open-ended intelligence fabric — discovery is not truth, authority or execution
In one sentence. E21 governs autonomous research -- asking questions, keeping competing hypotheses alive, designing experiments and simulations, replicating, peer-reviewing, attacking its own conclusions, building versioned knowledge, proposing capabilities, models and strategies, and creating specialised research agents -- so that a system can become more knowledgeable and more capable without becoming less governable.
The law.DISCOVERY IS NOT TRUTH IS NOT AUTHORITY IS NOT EXECUTION. CONSENSUS IS NOT TRUTH. RESEARCH AUTHORITY IS NOT EXECUTION AUTHORITY. CURIOSITY IS NOT AUTHORITY. SIMULATION IS NOT REALITY. UNKNOWN NEVER BECOMES ALLOW.
What it governs. Epistemic state is computed, never asserted: evidence is signed by its producer with its method class (simulation, synthetic experiment, controlled experiment, real-world observation, independent replication, third-party reproduction) bound into the signature, so a simulation cannot be relabelled as an observation; evidence is grouped by independence key (controller, environment, dataset, model), so repeated runs or Sybil producers count once, and any contradiction inside a group wins. A discovery walks PROPOSED -> HYPOTHESIS -> INVESTIGATING -> SIMULATED/OBSERVED -> REPLICATING -> SUPPORTED -> VERIFIED with an evidence requirement on every step (SUPPORTED needs an independent replication, five adversarial challenges by someone other than the author, and two independent reviews whose objections were cleared by evidence, not votes; VERIFIED needs a registered third party). Research authority (charter actions within a research role, chartered by the host institution's quorum) is disjoint from E20 execution authority, and no authority function takes a discovery, confidence, vote, benchmark score, knowledge, curiosity or information value as input. Experiments are approved for their environment only and are terminated on any forbidden operation. A capability leaves quarantine only after validation, an independent adversary, a security review and a governance quorum that excludes the researchers; a promotion is limited (scope as an intersection, named targets and operators, expiry, rollback) and is necessary but never sufficient: every action still passes E20, the E19 action contract and the E8 kernel. Revoked evidence cascades to claims, dependent claims, policies, capabilities and authorizations. Discovery memory is append-only and keeps every failed path. Also: a structural scientific-reasoning audit, causal levels that cannot be skipped (correlation is never labelled causation), a non-executing counterfactual lab, isolated competing tracks with commit-reveal and blind replication, Shannon information value that is never permission, governed data access, benchmark and model governance (leakage, hidden-test exposure, best-of-n, partial metrics, stale versions, two-benchmark promotion, no regression), multi-dimensional intelligence-regression checks, governed strategy self-improvement that can only narrow authority, bounded search and budgets, a research-agent factory through E20 spawning, and SIMULATED research bounties.
Verified. D1-D155 155/155 hold; the CAIN-42-E21-Open-Ended-Intelligence-Bench is 298/298 contained (290 distinct attacks, 8 aliases) across 46 categories; asked whether a system can discover a governance loophole and use the discovery to acquire permission to exploit it, the bench answers NO (seven loophole attacks, all refused; the only permitted output is a signed disclosure). A 17-stage research demonstration on a synthetic problem forms three hypotheses, runs competing tracks, simulates, observes, rejects two hypotheses, replicates the third in a second lab, quarantines, attacks, reviews and promotes a capability by quorum, runs a bounded action E21 -> E20 -> E19 -> E8, compares prediction with outcome and updates knowledge -- and refuses all 16 self-authorization attempts along the way. The self-evolution demonstration promotes a more efficient search strategy with strictly narrower authority and rolls back a candidate that regressed calibration. A mutation self-test removes seven defenses one at a time and every one is caught. The clean-room verifier (218 checks, no CAIN imports) re-derives every digest, signature, quorum, confidence and quality value, lineage, promotion scope and execution chain, and catches all 16 deliberate tamperings, 15 of them re-hashed and re-signed with a fresh key (the untouched copy verifies INTACT first). Scale SIMULATIONS reach 100,000 virtual research agents (100,000 signed observations admitted, p50 215.26 us each) and 100,000 simulated hypotheses. 19 E21 tests pass, 0 failed, plus 42 bundle-verifier tests. Building it we found and fixed four defects in our own new code before publication: reviewer independence was derived from currently valid evidence, so once a researcher's evidence expired they could review their own work; the experiment-count budget was never checked; within one independence group a later, heavier supporting result could overwrite a contradiction (now order-independent; the regression test fails against the old rule); and evidence ingest was quadratic. Bundle `e21-open-ended-intelligence-2026-09-29` (mirrored byte-identically); public claim C42-E21-OPEN-ENDED-INTELLIGENCE signed by the evidence-root key.
Limits. A TESTED library exercised against a deterministic SYNTHETIC research problem; it contains no scientific model and runs no real laboratory. Scientific truth of any hypothesis: UNKNOWN (E21 governs how evidence was produced, not whether a hypothesis is true). Novelty: only against a supplied corpus. Collusion by controllers off-system: UNKNOWN. Hosted E21 service: NOT IMPLEMENTED. Multi-host behaviour: UNVERIFIED (scale runs are single-process simulations). Research bounties: SIMULATED. Real-world adversarial validation and third-party review: NOT PERFORMED. E21 does not create AGI, solve alignment or guarantee safe self-improvement. Ephemeral signing key on the proof. PRE-PRODUCTION.
What changed. MCPGate gained an authorization-aware routing library (A+++ gate 6): tool schemas are kept in PINNED, HOT, WARM, COLD or EVICTED context residency by a deterministic score, while every call uses the canonical, digest-checked schema, the CAIN authorizer receives no residency information and its DENY is final even for a tool flooded into HOT, evicted tools remain callable only through full authorization, canonical schemas are never deleted, every decision is hash-chained evidence and every limit produces backpressure. Measured on one host: active context 6.22x-31.13x smaller than exposing every schema (50-1,000 tools), routing p50 about 17.66 us; 13 of 13 bypass tests pass. Public claim C42-MCPGATE-SCHEMA-RESIDENCY.
Limits. Library only: it is NOT wired into the live MCPGate proxy, so production routing is unchanged, and A+++ gate 6 stays BLOCKED until it is wired behind a flag on a canary and re-tested. The A+++ verdict remains BLOCKED (eBPF enforcement cannot load on this host, no soak or network fault injection for the new path, no desktop IPC layer).
In one sentence. E20 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. CAIN-42 remains the governance fabric; it is not an agent marketplace, an orchestration framework or a financial system.
The law.COLLECTIVE INTELLIGENCE IS NOT INSTITUTIONAL AUTHORITY. AUTONOMOUS ORGANIZATION IS NOT AUTONOMOUS AUTHORITY. NEGOTIATION IS NOT AUTHORIZATION. UNKNOWN NEVER BECOMES ALLOW.
What it governs. Institutional authority is computed, never stored: constitution boundary ∩ founding authority (a principal's signed grant, or the founders' intersection, never their union) ∩ parent institution ∩ an 11-state autonomy ceiling; member authority is the admission grant plus delegations bounded by their delegator, ∩ the institution, ∩ the parent agent. Membership, votes, consensus, reputation, trust, wealth, market wins, rewards and model capability are not inputs. A frozen constitution changes only through a quorum that excludes the proposer and never beyond the founding authority; a conserved, hash-chained resource ledger with signed mints, custody, single-use nonces, escrow and rebuild-from-chain; economic actions that bind twelve fields; eleven-field contracts signed by both parties and invalidated by any of seven bound state changes; signed, hash-linked negotiation whose outcome is only a proposal; agent spawning bounded in seven independent dimensions with a signed birth certificate; governed termination and dissolution cascades with signed receipts and tombstones; append-only institutional memory; evidence-backed reputation counted per controller; bounded, attenuated trust; collusion signals that never claim certainty; observational power metrics; blast radius; an evidence-weighing court that preserves competing claims; audit reconstruction; supply-chain pinning; a non-executing digital twin; a 15-stage institutional control loop; governed evolution and recovery. Every institutional action is judged by E20, then by the E19 action-contract gate (institutional authority enters as its collective-constraints factor), and committed only by the E8 kernel.
Verified. I1-I118 118/118 hold; the CAIN-42-E20-Agentic-Institutions-Bench is 334/334 contained (328 distinct attacks, 6 aliases) across formation, membership, identity, authority laundering, delegation, contracts, negotiation, resources, economics, spawning, resurrection, termination, memory, reputation, markets, incentives, federation, trust, collusion, power, court, supply chain, simulation, evolution, constitution, autonomy state, recovery, execution and time, including consistently re-signed refusals; a mutation self-test removes six defenses one at a time and the bench and invariants catch every one; the 20-step end-to-end run (agent, team, organization, negotiation, contract, resources, subagent, delegation, contract execution) detects and contains all 7 hostile events (agent compromise, resource mutation, goal drift, contract manipulation, reputation poisoning, cross-agent collusion, world-state change), reduces authority, invalidates contracts, revokes delegation, preserves evidence, recovers and re-authorizes while a second institution keeps operating; scale simulations reach 10,000 virtual agents and 1,000 virtual institutions; 499 E20 tests pass, 0 failed, plus 48 bundle-verifier tests; the clean-room verifier (179 checks, no CAIN imports) recomputes every digest and signature, re-derives institution and member authority, ledger balances and conservation, reputation, trust and the dispute decision, and still fails on semantic tampering after an attacker re-seals the bundle with a fresh key. Building it we found and fixed three of our own defects before publication: a contract's payment was checked against the performer's work list, the E20-to-E19 autonomy mapping blocked actions the state ceiling allows, and the builder published a lineage list that kept growing after its snapshot (the verifier caught it). Bundle `e20-agentic-institutions-2026-09-29` (mirrored byte-identically); public claim C42-E20-AGENTIC-INSTITUTIONS signed by the evidence-root key.
Limits. A TESTED library exercised against deterministic reference institutions. Every economy, market and settlement is SIMULATED over abstract units; real money is refused (real financial settlement: NOT IMPLEMENTED). Control of any real economy, society, agent population, vehicle, drone or robot: NOT IMPLEMENTED. Hosted E20 service: NOT IMPLEMENTED. Collusion-detector recall and semantic truth of evidence: UNKNOWN. Multi-host behaviour: UNVERIFIED (scale runs are single-process simulations). Real-world adversarial validation and third-party review: NOT PERFORMED. Ephemeral signing key on the proof. PRE-PRODUCTION.
2026-09-29 — Evolution 19: governed autonomy operating fabric — the autonomous-system state layer
In one sentence. E19 governs the evolving state of an autonomous system, not only its individual actions: who is acting, what it believes and why, what it wants, what authority and capabilities it holds right now, which world state it acts against, what it predicted, what actually happened, and what must change in its future authority. CAIN-42 remains the governance fabric; it is not a planner, world model, orchestration framework or vehicle/drone/robot controller.
The law.AUTONOMY IS NOT AUTHORITY. NO STATE TRANSITION WITHOUT GOVERNANCE. UNKNOWN NEVER BECOMES ALLOW.
What it governs. Hash-chained governed state for 25 components (missing = UNKNOWN); missions with time, geography, conserved budgets and scopes; a goal graph where a subgoal never exceeds its parent or mission and inherits every constraint; beliefs that are FACT only when verified, evidence-backed, corroborated by two independent principals, uncontradicted, unexpired and bound to the current world; memory that never becomes policy, authority or instruction; a 9-stage learning lifecycle where authority changes need a constitutional quorum; model passports (a more capable model gets no authority); a sealed runtime provenance graph; a continuous authority compiler (effective authority = the intersection of 16 factors; confidence, peer agreement, learning, plans, predictions and compute are not factors); seven governance clocks; a machine-verifiable causal chain with no opaque 'the model decided' and no stored chain-of-thought; outcome comparison that turns prediction error into evidence without punishing legitimate uncertainty; 13 derived autonomy levels; governed humans, emergencies, recovery, checkpoints and forks; a constitution whose core invariants cannot be removed. Every consequential action carries a sixteen-field GovernedActionContract that any of 15 bound state changes invalidates, and whose verdicts the gate enforces itself before the E8 kernel commits it.
Verified.G1-G108 108/108 hold; the CAIN-42-E19-Governed-Autonomy-Bench is 189/189 contained (177 distinct attacks, 12 aliases) across identity, goals, beliefs, memory, models, authority, world, planning, multi-agent, learning, execution, recovery, physical/hybrid, governance and human authority, plus consistently re-signed refusals; a mutation self-test removes four defenses one at a time and the bench and invariants catch every one; the 19-stage end-to-end run (mission, goal, belief, 4D world, prediction, plan, authorization, action, world change, invalidation, outcome, prediction error, trust update, degraded autonomy, recovery, re-authorization, continued operation) passes and all 20 stage attacks are caught; 391 E19 tests pass, 0 failed; the clean-room verifier (117 checks, no CAIN imports) recomputes every digest and signature, re-derives effective authority, autonomy levels and contract invalidation, and still fails on semantic tampering after an attacker re-seals the bundle with a fresh key. Full regression (the whole test suite, run twice serially at a56769c + provenance 5867003): 8,556 passed, 0 failed, 62 skipped, 4 xfailed in both passes.evidence page · bundle summary · attack manifest · invariants · end-to-end run · mutation self-test · clean-room verifier (INTACT, 117 checks) · limitations
Limits. A TESTED library exercised against a governed reference system (a digital agent, a vehicle abstraction, a drone abstraction, a collective and a human in the E18 4D world); execution in the scenario is SIMULATED. Vehicle, drone and robot control and any physical safety guarantee: NOT IMPLEMENTED. Hosted E19 service: NOT IMPLEMENTED. Semantic truth of beliefs and outcomes, hardware attestation: UNKNOWN. Multi-host behaviour: UNVERIFIED. Real-world adversarial validation and third-party review: NOT PERFORMED. Ephemeral signing key on the proof. PRE-PRODUCTION.
While upgrading both live PBFT clusters (cain-mr-01, cain-mr-02) to the build that contains the soak fix 40b0835, the new build also carried the 2026-09-27 cluster write gate, which refused the replicas' own consensus messages. Neither cluster committed from about 05:47 to 06:02Z; decisions needing a cluster commit were refused (fail-closed), not allowed. Both clusters were rolled back to their previous images and verified committing again (cain-mr-01 sequence 28872, cain-mr-02 sequence 657, every replica agreeing). The 72-hour and new 120-hour soaks started on the upgraded build were stopped and do not count; each carries a STOPPED.json saying why. The hourly proofs record the gap honestly (113 of 114 OPERATIONAL on cain-mr-01). Next: let authenticated replica traffic through the gate (keeping the gate), test it on one replica, then restart the soaks. soak stop notes
In one sentence. E18 turns CAIN-42 towards the actionable 4D world: not merely "what is there?" but "what is it doing, where can it go, what is it likely to do next, what can we safely do, what happens if we do it, do we have authority, and is that authorization still valid right now?". It is a strict extension of E15/E16/E17, not a parallel abstraction.
The law.ACTIONABILITY IS NOT AUTHORIZATION. REACHABILITY IS NOT PERMISSION. PREDICTION IS NOT REALITY. AUTHORIZATION IS A FUNCTION OF WORLD STATE. UNKNOWN NEVER BECOMES ALLOW. If any material input changes, REVALIDATE; if the required state cannot be established, DO NOT EXECUTE.
What it governs. Entity state at (X,Y,Z,T) with uncollapsed uncertainty; reachable / policy-permitted / authorized sets kept distinct; probabilistic intent; multiple predicted trajectories; an interaction graph and a conflict field that is not distance-only; time-to-consequence with uncertainty; signed, versioned dynamic geofences; governed airspace and roadspace; a spatial policy compiler that yields ELIGIBILITY, not authorization; multimodal sensor fusion; world-model arbitration that never simply selects the highest confidence; a prediction ensemble that detects correlated errors; counterfactual future trees; actionability states; a conserved uncertainty budget that propagates; a governance clock and latency budget (SAFE_DEGRADE, never bypass); drone and vehicle fabric proposal interfaces; a cross-domain 4D world for car, drone, robot, digital agent and human operator; a spatial digital twin whose layers are never conflated; a reality-gap monitor; and incident replay. Every consequential spatial action binds sixteen digests and reaches the real E8 governance kernel.
Boundary review before publication (2026-09-29). An adversarial review found the commit boundary bound the digests of the policy, actionability, authority, risk and uncertainty verdicts but never read them: a consistently re-signed refusal (policy ineligible, actionability DENIED, authority revoked or out of domain, risk 0.99, uncertainty 1.0) came back AUTHORIZED. Fixed: the boundary now enforces each verdict (unknown refuses); the map (roadspace, airspace) is bound into the world digest; uncertainty can no longer drop between layers and an unmeasured budget is not certainty; micro-authorization cannot skip revalidation or continue across a world change; an omitted lane/capability no longer matches a constrained authority domain; a declared altitude must match the position. Five end-to-end “mutations” that did not mutate what they named were rewritten. Each fix has a test that failed before it (Q81-Q89, 21 new attacks).
Verified.Q01–Q89 89/89 hold; the CAIN-42-E18-Spatial-Autonomy-Bench is 123/123 contained (109 distinct attacks plus 14 invariants re-run as scenarios); the 20-step end-to-end run, its unmutated control and all 12 deliberate mutations behave as specified; 319 E18 tests pass, 0 failed; a clean-room verifier (111 checks, imports no CAIN-42 code) recomputes every digest, the sixteen-digest commit binding and the verdicts behind the committed action, checks the master proof signature and returns INTACT, and it rejects 30 kinds of tampering.evidence page · master proof · attack manifest · sixteen-digest commit · end-to-end run · clean-room verifier (INTACT, 111 checks) · limitations
Limits. A TESTED library exercised against a governed reference 4D world. CAIN-42 contains no autonomous-driving model, flight controller, vehicle controller, robot policy or navigation stack and drives nothing. Real vehicle / drone / robot / sensor / actuator / airspace integration: NOT_IMPLEMENTED. A physical safety guarantee and certified autonomy: NOT_IMPLEMENTED. Hardware attestation, world-model/prediction accuracy and sim-to-real fidelity: UNKNOWN. Real sensor validation, real-world adversarial validation and third-party review: NOT_PERFORMED. Not hosted; single host; ephemeral signing key on the proof. Hash integrity is not semantic truth. CAIN-42 provides a governed spatiotemporal action boundary for autonomous systems across digital, simulated and physical environments — nothing more. PRE-PRODUCTION.
In one sentence. E17 governs action by autonomous agent teams as a first-class system object: a collective is not the sum of its members and a collective action is not the sum of member actions. It is a strict extension of E10 (collectives) and E15/E16 (spatial + causal world state), not a parallel abstraction.
The law.MANY AGENTS MAY COORDINATE. NONE MAY CREATE AUTHORITY BY COORDINATING. CONSENSUS IS NOT AUTHORIZATION. COLLECTIVE INTELLIGENCE IS NOT COLLECTIVE AUTHORITY. TOPOLOGY IS NOT AUTHORITY. NO AUTHORIZATION → NO EXECUTION. UNKNOWN NEVER BECOMES ALLOW.
What it governs. Collective authority is a constrained intersection of the governing grant, the mission capabilities, policy and live member authority, never a sum. Collective identity is its own revocable identity, not the sum of member identities. A mission binds every collective action and material mission / membership / world-state / causal / topology drift forces reauthorization or a safer decision. Majority, consensus, negotiation, contracts, roles, membership, coalitions, delegation, subagents, recursive delegation, emergence and self-improvement cannot create or amplify authority. Dissent is preserved and a minority safety objection is surfaced. Correlated evidence cannot masquerade as independent evidence. A world-state fork blocks authorization until reconciliation. A collective trajectory is a proposal until governed. A compromised member forces containment, revocation of affected authorizations, a recalculation of state and consequences, and reauthorization; recovery itself never mints authority. One action that would fan out to many agents is pre-authorized. Every consequential collective action binds fifteen digests and reaches the E8 governance kernel; no collective protocol bypasses it.
Boundary review before publication (2026-09-29). The same review found the E17 commit boundary also bound the risk, policy, world-state, authority and consequence digests without reading them (risk 0.99, a missing risk score, an ineligible policy, an empty world state or an empty authority came back AUTHORIZED when re-signed consistently). Fixed: the boundary enforces them, and the operation must lie in the effective authority and in the decision’s candidate actions (Q61, 10 new attacks, each with a fail-before test).
Verified.Q01–Q61 61/61 hold; the CAIN-42-E17-Multi-Agent-Bench is 91/91 contained (88 distinct attacks; 3 are also listed under a second name); the 18-step end-to-end run and all 12 deliberate mutations behave as specified; 238 E17 tests pass, 0 failed; a clean-room verifier (92 checks, imports no CAIN-42 code) recomputes every digest, the fifteen-digest commit binding and the master proof signature and returns INTACT, and it rejects 18 kinds of tampering and tolerates served-page chrome. A token minted for one set of bindings authorizes no other.evidence page · master proof · attack manifest · fifteen-digest commit · end-to-end run · clean-room verifier (INTACT, 92 checks) · limitations
Limits. A TESTED library exercised against a governed reference collective. CAIN-42 deploys no fleet, robot, drone, vehicle or customer collective and drives nothing. No real sensor/actuator integration and no deployed multi-agent collective: NOT_IMPLEMENTED. Hardware attestation: UNKNOWN. Sybil-detection completeness and the semantic truth of observations, predictions or causal claims: UNKNOWN. World-model accuracy and sim-to-real fidelity: UNKNOWN. Real-world attack validation and third-party review: NOT_PERFORMED. Not hosted; single host; ephemeral signing key on the proof. Hash integrity is not semantic truth. A system outside CAIN-42's enforcement boundary remains UNCONTROLLED / UNVERIFIED / UNKNOWN. PRE-PRODUCTION.
2026-09-29 — Evolution 15: CAIN-42 governs the trust path to physical action — world state, trajectories, simulation and actuators
In one sentence. E15 establishes the interfaces and governance primitives for bringing spatial intelligence, world models, simulation, trajectories and physical actions into CAIN-42's governed trust path: from what a system perceives, through what it proposes and may cause, to what it is authorized to do and what the physical world then shows.
The law.PERCEPTION IS NOT TRUTH. MODEL OUTPUT IS NOT AUTHORITY. SIMULATION IS NOT REALITY. PREDICTION IS NOT FACT. A TRAJECTORY IS A PROPOSAL UNTIL GOVERNED. A PHYSICAL ACTION REQUIRES GOVERNED AUTHORIZATION. UNKNOWN NEVER BECOMES ALLOW.
What it governs. Signed sensor observations are admitted through the E12 evidence layer (identity, type, key, replay, freshness, per-sensor time order); cross-modal conflicts (camera vs lidar, GNSS vs inertial, map vs sensor, world model vs raw) block authorization; spatial identities keep continuity (no silent A-becomes-B); the world state is versioned, hash-chained and replayable and binds every ingested observation; a world model's output is PREDICTED evidence bound to model, configuration, world state and scenario; a trajectory is a proposal until a signed approval binds it; capabilities say WHERE, WHEN and UNDER WHAT CONDITIONS and never exceed authority; physical consequence and blast radius enter the E7 gate (UNKNOWN where not measurable); every physical action binds nine digests, crosses the E8 commit boundary and reaches an actuator adapter only with a single-use permit for that exact command; material drift invalidates the authorization and forces re-evaluation or a safe state whose semantics come from the system's own adapter.
Verified.P1–P36 36/36 hold; the CAIN-42-E15-Spatial-Physical-Bench is 55/55 contained; 19/19 end-to-end steps and 7/7 mutations governed; 175 tests pass, 0 failed; clean-room verifier INTACT (52/52 checks) and corrected for the hardened world-state/step schema; the bundle is rebuilt at the commit that contains the E15 code; the full suite is clean at 7,561 passed, 0 failed, 62 skipped, 4 xfailedevidence page · proof JSON · end-to-end run · attack manifest · clean-room verifier (INTACT, 52 checks) · limitations
Limits. A TESTED library exercised against a reference robot adapter and a reference kinematic simulator; CAIN-42 is not a vehicle or a robot, drives nothing and does not guarantee physical safety. Real sensor, vehicle, robot and actuator integration: NOT_IMPLEMENTED. Hardware attestation: UNKNOWN. World-model accuracy and sim-to-real fidelity: UNKNOWN. Real-world attack validation: NOT_PERFORMED. Not hosted; single host; ephemeral signing key on the proof; no third-party review. Systems outside the enforcement boundary remain UNCONTROLLED / UNVERIFIED / UNKNOWN. PRE-PRODUCTION.
2026-09-29 — Evolution 16: CAIN-42 governs the causal and temporal world state — 4D causal world intelligence fabric
In one sentence. E16 extends E15's governed world state with a temporal and causal dimension: events and intervals, typed causal and correlation relations, causal provenance, a world-state version graph with counterfactual branches, a predictive state engine, a causal intervention engine, prediction-vs-reality calibration, temporal authorization and a causal blast radius — all reaching the same governed commit boundary. It is a strict extension of E15, not a parallel abstraction.
The laws.CORRELATION IS NOT CAUSATION. PREDICTION IS NOT OBSERVATION. COUNTERFACTUAL IS NOT REALITY. FUTURE STATE IS NOT CURRENT STATE. A SIMULATED INTERVENTION IS NOT AN EXECUTED INTERVENTION. CAUSAL CONFIDENCE IS NOT AUTHORITY. CAUSAL REASONING CANNOT INCREASE AUTHORITY. UNKNOWN NEVER BECOMES ALLOW. Every consequential action reaches the one governed commit boundary; no causal shortcut bypasses the E8 kernel.
What it governs. A causal claim must carry provenance and is never a fact; temporal relations are validated against the intervals, causal relations are refused on temporal inversion and cycles, and CORRELATES_WITH is kept explicitly separate and never becomes a cause. Reality and simulated (counterfactual) branches are cryptographically distinct and cannot be merged without explicit reconciliation. A prediction is bound to model, world digest/version, horizon and assumptions, is never a fact and never authority. An intervention is a counterfactual branch that never executes and never mutates reality. Prediction error becomes evidence; a poorly-calibrated model is demoted and never gains authority. A temporal authorization binds world version, temporal window and prediction horizon. The causal blast radius propagates action → direct → second-order → dependency → system with per-edge uncertainty, and is UNKNOWN where not measurable.
Verified.Q1–Q42 42/42 hold; the CAIN-42-E16-Causal-World-Bench is 84/84 contained; the 10-step end-to-end run passes; 176 E16 tests pass, 0 failed; a clean-room verifier (69 checks, imports no CAIN-42 code) recomputes every digest and returns INTACT, rejects 12 kinds of tampering and tolerates served-page chrome. Full suite 7,561 passed, 0 failed, 62 skipped, 4 xfailed.evidence page · master proof · attack manifest · clean-room verifier (INTACT, 69 checks)
Limits. A TESTED library; it contains no learned world model, simulator, vehicle, robot, sensor or actuator controller and drives nothing. Real vehicle / robot / actuator / sensor integration and a hosted E16 service: NOT_IMPLEMENTED. World-model accuracy, the semantic truth of observations and causal claims, and sim-to-real fidelity: UNKNOWN. Real-world attack testing and third-party reproduction: NOT_PERFORMED. Hardware attestation: UNKNOWN. Hash integrity is not semantic truth. Single host; ephemeral signing key on the proof; no third-party review. PRE-PRODUCTION.
2026-09-28 — Evolution 14: CAIN-42 governs the power surface — capabilities, skills, tools and their supply chain
In one sentence. E14 makes every tool, skill, plugin, connector, model and subagent a governed object: CAIN-42 knows what it is, who published it, what artifact and dependencies implement it, what it may touch, and whether it may run at this exact moment. It binds that answer to the decision that uses it.
The law.A CAPABILITY IS A POWER SURFACE. DISCOVERY ≠ TRUST ≠ AUTHORITY ≠ AUTHORIZATION. A TOOL, SKILL, PLUGIN, MODEL OR CREDENTIAL IS NOT AUTHORITY. UNVERIFIED POWER MUST NOT EXECUTE. Effective capability is the intersection of eight envelopes, never a sum; a grant never exceeds its issuer; a subagent only ever gets less.
What it catches. Fake or substituted tools, publishers and artifacts; unsigned or broken provenance; dependency substitution, hidden dependencies and malicious or downgraded updates; replayed, expired or revoked leases; drift while leased; privilege escalation through delegation, subagents, collectives, memory, model output, tool output or credentials; dangerous capability combinations, even split across agents or chained; sandbox, network, filesystem and credential scope violations; stale decisions, policy, authority or evidence; decision, action and credential substitution; a revocation racing a commit; and a capability mutated between check and commit (the E8 token now binds six capability digests strictly). Building it, we found two Evolution 13 attack scenarios that had been counted as contained without being tested, and fixed both (the E13 bundle is rebuilt), and our own benchmark exposed quadratic lease issuance, now fixed with a regression test.
Limits. A TESTED library wired into the agent hypervisor in front of MCPGate, not a hosted service. Hardware attestation and vulnerability intelligence are UNKNOWN; multi-host scale is UNVERIFIED; sandbox profiles are policy-evaluated except what the ZoD confinement enforces at OS level; hash integrity is not semantic truth; the signing key is ephemeral; no third-party review. A system outside CAIN's enforcement boundary remains UNCONTROLLED / UNVERIFIED / UNKNOWN. PRE-PRODUCTION.
2026-09-28 — Evolution 13: CAIN-42 governs how a decision is formed, not just what enters it
In one sentence. E13 adds governed decision integrity: CAIN-42 binds evidence, policy, authority, consequence analysis and the canonical action into one verifiable decision state before execution, so a model's reasoning can propose but never authorize.
The law.REASONING MAY PROPOSE. EVIDENCE MUST SUPPORT. POLICY MUST CONSTRAIN. AUTHORITY MUST AUTHORIZE. CAIN-42 MUST DECIDE. MCPGATE MUST ENFORCE. EVIDENCE MUST REMEMBER. A model's opinion, confidence and narrative are context only, never authority. Authority is the intersection of every envelope, and reasoning can never expand it. No valid decision → no authorization → no execution.
What it catches. A policy conflict is surfaced and resolved only by documented precedence, never silently. Any material change (evidence, policy, authority, risk, consequence, identity, budget, trajectory, runtime) marks the decision stale and requires re-adjudication. A DENY cannot be converted to an ALLOW, a decision cannot be substituted after signing, and an old decision cannot be replayed against a new world state. The governance token now binds the decision, intent, policy, authority and risk digests — change any of them and the token is refused.
Limits. A TESTED library, not a hosted service. It governs decision construction from recorded inputs; it does not read or validate a model's private reasoning and stores no chain-of-thought. Policy conflict resolution is deterministic precedence, not a theorem prover; counterfactuals are bounded simulation; attestation is software/config digests, not hardware; performance is single-host, in-process, warm; no third-party review. A system outside CAIN's enforcement boundary remains UNCONTROLLED / UNVERIFIED / UNKNOWN. PRE-PRODUCTION.
2026-09-28 — Evolution 12: CAIN-42 governs what an agent is allowed to believe
In one sentence. CAIN-42 now governs the perception layer before every other layer: it identifies what was actually observed, where it came from, whether its provenance is trustworthy, whether it is current, whether it conflicts, whether it is only inferred, whether it is corroborated, and whether that evidence is authorized to influence a particular decision.
The laws.NO EVIDENCE → NO TRUST. OBSERVATION IS NOT FACT. INFERENCE IS NOT OBSERVATION. EVIDENCE IS NOT AUTHORITY. INTEGRITY IS NOT TRUTH. UNKNOWN MUST REMAIN UNKNOWN. A canonical observation carries a stable digest and a full source/provenance/time/trust record; a source whose identity cannot be established is UNKNOWN, never inferred; evidence cannot exist without observations and a provenance root; the epistemic machine never lets UNKNOWN jump to CORROBORATED or an INFERENCE become a FACT.
What it catches. Evidence authority is target-specific (evidence valid for a financial balance is not valid for identity verification). A material conflict is never silently resolved. Corroboration counts independent principals, not observations — 100 agents from one owner are one source. Stale, expired or superseded evidence cannot authorize. Retrieved, web and tool content is DATA, never policy. A valid hash proves bytes did not change, not that they are true. Reality drift forces re-evaluation, and revoking evidence invalidates the dependent claims, intents and governance tokens (an evidence blast radius).
Limits. A TESTED library, not a hosted service. Integrity does not establish truth; injection detection is pattern-based; independence is principal+lineage based; image/audio/video semantic authenticity is not established; attestation is software/config digests, not hardware; performance is single-host, in-process, warm; no third-party review. A system outside CAIN's enforcement boundary remains UNCONTROLLED / UNVERIFIED / UNKNOWN. PRE-PRODUCTION.
2026-09-28 — Evolution 11: CAIN-42 governs the information channel — what caused the agent to want that action?
In one sentence. CAIN-42 now governs what agents say to each other and what tools, MCP servers, memory and external content return, plus the intent an agent derives from it, so untrusted information cannot silently become trusted intent or unauthorized authority.
The laws.INFORMATION IS NOT AUTHORITY. A canonical signed message is bound to a nonce, session, recipient, expiry and the sender's passport digest — a signature proves who sent it, never what they may do. Tool and MCP output is classified but always treated as DATA, never policy and never authorization. Information never inherits the destination's trust (UNKNOWN stays UNKNOWN; SECRET to lower trust is refused). Taint propagates through derived intent — a provenance-risk signal, never proof of malice.
Intent integrity. An instruction hierarchy where textual order is never authority; an interpreted intent kept separate from the canonical action intent; an IntentSandbox that returns eligibility, never authority; conflict detection that never picks a side; intent-drift, confused-deputy, cross-collective and replay defences; and a quarantine that always preserves the evidence.
Limits. A TESTED library, not a hosted service; it runs no agents or message bus. Prompt-injection detection is pattern-based, not perfect semantic detection. Influence and provenance graphs are attribution evidence, not perfect causal explanations. Taint is a signal, not proof of malicious intent. Attestation is software/config digests, not hardware. Cross-domain trust requires an explicit trust root. No framework adapter is published. UNKNOWN MUST REMAIN UNKNOWN. PRE-PRODUCTION.
In one sentence. CAIN-42 now governs swarms, teams, hierarchies and dynamically assembled agent networks: it decides what happens when agents collaborate, delegate, agree, share resources and memory, form coalitions, attempt coordinated harmful behaviour, or produce behaviour no individual requested.
The law.ONE TRUSTED AGENT DOES NOT CREATE A TRUSTED COLLECTIVE. Collective authority is the intersection of the policy ceiling, objective scope, member authority envelope, trust/risk/delegation/provenance envelopes, budget and temporal envelope — never a sum. Membership changes are governed and grant no inherited authority; roles carry responsibility only.
Combination risk, collusion, Sybil. Individually-permitted actions (data + credentials + infrastructure + deploy) are classified HIGH_RISK/CRITICAL when combined, before commitment. Circular and reciprocal approval, quorum manipulation, identity splitting and authority fragmentation are detected. Sybil resistance counts independent principal + lineage + funding, so 100 identities from one principal are one trust source. Collective memory keeps conflicts unresolved, an epistemic state refuses UNKNOWN→VERIFIED without evidence, budgets are conserved per kind, and trust is bounded by its weakest dimension. Consensus does not equal authorization — a unanimous decision still returns authority NONE.
Limits. A TESTED library, not a hosted orchestration service; it runs no agents and sends no messages. Emergent/collusion findings are HEURISTIC, not semantic certainty. Sybil resistance cannot catch a principal that also fabricates distinct lineages and funding. Attestation is software/config digests, not hardware. Transaction guarantees cover the governed layer only. No framework adapter is published. UNKNOWN MUST REMAIN UNKNOWN. PRE-PRODUCTION.
2026-09-28 — Evolution 9: a signed Universal Agent Passport, an AgentBOM and a provenance graph for every governed agent
In one sentence. CAIN-42 can now answer, with machine-verifiable evidence, who is this agent, what exactly is running, who authorised its capabilities, what changed since attestation, and can a component be revoked without destroying the system — through a signed agent passport, an AgentBOM, a provenance graph and continuous attestation.
Implementation. A new provenance and composition layer (supporting Evolutions 1–8, not replacing them) separates identity, provenance, capability, authority, attestation and passport. IDENTITY ≠ AUTHORITY. MEMORY ≠ AUTHORITY. CAPABILITY ≠ AUTHORITY. A memory that claims authority is UNTRUSTED unless it resolves to a verified source event; delegation can never increase capability, scope, budget or duration; revoking an MCP server cascades to its tool, its capability attestation, the bound governance tokens and the affected agents. 46 tests pass, 0 failed; P1–P15 15/15 hold.
Mutation, published. A material runtime mutation changes the composition fingerprint: the attestation becomes MUTATED, the passport no longer matches, and the provenance-bound governance token is refused at the action-commit boundary; a new attestation and a new authority are required before the next consequential action. evidence page · Evolution 9 proof · schemas · performance · clean-room verifier
Limits. A TESTED library, not a hosted identity service. Attestation is over software and configuration digests, not hardware (hardware attestation stays UNKNOWN). No vulnerability database; no framework adapter is published, so none is described as supported; transaction guarantees cover the governed layer only; performance is single-host and in-process. No third party has reviewed it. UNKNOWN MUST REMAIN UNKNOWN. NO PROVENANCE → NO ELEVATED TRUST. PRE-PRODUCTION.
2026-09-28 — Evolution 7 + 8: CAIN-42 predicts consequences before it authorizes, and a signed governance token guards the action-commit boundary
In one sentence. CAIN-42 can now ask not only may this agent act? but what could happen if it does?, and let the answer bound authority rather than widen it: a governed world state and digital twin predict consequences and uncertainty, and a signed, short-lived, single-use governance token is checked at an action-commit boundary before any consequential execution.
Evolution 7 — Predictive Consequence Governance. A cryptographically tracked world state (every element carries source, timestamp, freshness, confidence, provenance and verification status), a versioned world-state graph, a digital twin (snapshot / clone / simulate / compare / rollback / replay that can never promote a simulation to reality), a counterfactual engine, a causal-dependency graph that never treats correlation as causation, a prediction-error engine whose errors raise uncertainty and can never be lowered by an agent, an uncertainty ceiling that only contracts authority, signed simulation evidence, a sandbox, shadow governance that can never enforce, long-horizon simulation, a 17-vector adversarial corpus, safe-alternative generation, irreversibility controls and predictive economic governance. 12 machine-checkable invariants (I1–I12) all hold.
Evolution 8 — Mandatory Agent Governance Kernel. A canonical action that binds authorization to the exact canonicalized parameters; a signed short-lived single-use governance token bound to the agent, action hash, capability, authority, trajectory, policy root, world-state root, consequence, risk ceiling, resource scope and nonce; an action-commit boundary (prepare → authorize → commit → execute → verify → record) with a TOCTOU re-check; a capability ratchet; execution-path bypass detection that names a bypass instead of hiding it; enforcement-depth that cannot be claimed beyond what is installed; execution rings; safe modes; kernel-level emergency stops outside the agent loop; multi-party authorization; and result-drift incidents. 22 machine-checkable invariants (K1–K22) all hold.
Wired to the CAIN-45 hypervisor (ZoD), restriction-only. Both fabrics are consulted after every hypervisor check and can only add a refusal; a hook that errors is fail-closed. 65 new tests passed, 0 failed; the 976-test hypervisor/L5 regression group is unchanged. reproduce · clean-room verifier (no CAIN imports) · Evolution 7 proof · Evolution 8 proof
Limits. Both fabrics are TESTED libraries on the operator host, not hosted services; the wiring is opt-in and restriction-only; enforcement depth on this host is APPLICATION/RUNTIME/CONTAINER, never OS or HARDWARE; the digital twin has no validated error bound; long-horizon depth is not reliability; no third party has reviewed the bundle. SIMULATION IS NOT AUTHORITY. NO VALID GOVERNANCE TOKEN → NO CONSEQUENT EXECUTION. PRE-PRODUCTION.
2026-09-28 — Governed adaptive evolution: an agent may learn, but a change to its memory, skills, tools or model becomes active only through a gate
In one sentence. When an L5 AI system proposes to change itself (a new memory, skill or tool, or a different model), CAIN-42 decides whether that change may take effect, and every decision is re-checkable.
What was verified. A clean-room verifier (no CAIN imports) recomputes all 11 recorded evolution decisions: 1 ACCEPT, 1 REQUIRE_APPROVAL (deployed only with operator approval), 6 REJECT, 3 QUARANTINE. 143 checks, VALID. It rejects a CAIN-signed but unjustified ACCEPT and 10 tamper classes. reproduce · verifier · transcript · the bundle
A fault, published. The first version of this layer was fail-open on 32 of 32 independent probes, and an earlier 33/33 invariant result had been measured against that version. Fixed in 71eecdb; the probes now find 0 open paths.
Limits. Claim C42-L5-ADAPTIVE-EVOLUTION is TESTED and labelled SIMULATED: an in-process library, not wired into the hosted gateway or MCPGate; a deterministic reference runner, no LLM; no multi-day run. Its keys are generated fresh for each build, so the bundle shows internal consistency and decision correctness, not provenance, and it is not signed by the evidence-root key. PRE-PRODUCTION.
2026-09-28 — Don't trust CAIN-42, verify it: the public proof fabric, a /verify page, an evidence API and a downloadable evidence pack
In one sentence. Everything needed to check CAIN-42 without trusting us is now published and signed: what is running, what it depends on, which tests ran and passed, test vectors for independent implementations, every published fault, and a verifier that recomputes all of it. Verify CAIN-42 in your browser.
What is running. A build manifest and per-file artifact list of the live gateway (990 source files; 958 byte-identical to the commit, the other 32 named), a CycloneDX SBOM (177 installed distributions with content hashes) with daily dependency-drift detection, and a deployment attestation that binds the running process to that artifact. There is no build step (CPython runs source) and hardware attestation is not available; both are stated, not glossed. build manifest · SBOM · deployment attestation
What was tested. A real run of the site, gateway, L5-governance, hypervisor, MCP-enforcement and Byzantine suites: 1857 tests, 1842 passed, 0 failed, 7 skipped and 8 expected faults (documented known gaps), each listed with its purpose, category and file hash, with the JUnit XML published. The run first reported the gateway suite as 0 tests (a path bug); the builder now refuses to publish a suite that collected nothing. test manifest
Check it with your own code. 76 public test vectors produced by the real CAIN-42 code: canonical JSON, domain-separated SHA-256, Ed25519 signatures for every signing domain (with negative cases), Merkle roots, policy precedence, authority intersection, blast radius, governance quorum and lease validity. No private key is published. test vectors
The clean-room verifier.verify_proof_fabric.py imports nothing from CAIN-42. It recomputes the artifact tree hash, the deployment id and configuration hash, the SBOM and test counts against the JUnit XML, every test vector with its own implementations, the provenance graph and the fault ledger, and with --claims fetches every signed claim's artifacts from all three sites. On its first run it caught a real inconsistency (a rounded timestamp in the deployment id), fixed in the generator. Its own tests include a tampered-and-re-signed bundle, which it still rejects. 32/32 PASS from each site. the verifier · reproduce
For procurement and auditors. A downloadable evidence pack (11 MB) with every claim-pinned artifact, the verifiers, the manifests, a 10-step verification workflow, limitations and the changelog; its manifest and a release statement are signed. evidence pack · signed release
Machines too. A read-only evidence API: /api/v1/proof, /claims, /claims/{id}, /bundles, /manifests, /artifacts/{sha256} (content-addressed), /verify, /status, /changelog. Its /verify runs on our server, so it is labelled a convenience, not independent verification.
Honest status model. Every signed claim now has a version, a category and a state: 19 REPRODUCIBLE, 13 TESTED, 5 CLAIMED, 1 SUPERSEDED, 0 INDEPENDENTLY VERIFIED: no third party has reviewed CAIN-42, and the registry cannot say otherwise. 19 fixed defects and 2 failed claims are listed in the fault ledger; every published benchmark lacks at least one required test condition, and the performance index says which. fault ledger · performance index · Byzantine index · provenance graph
Watched, not just published. An integrity monitor re-verifies the published evidence from outside every 6 hours and signs a hash-chained result. First run: PASS on all three sites; claims 31 PASS, 0 FAIL, 0 missing, 1 superseded, 5 not verified (claims that are themselves unverified). latest run
Security disclosure.security.txt no longer points at a PGP key and a careers page that did not exist, and no copy of it promises a bug bounty (there is none); the disclosure policy now covers all three sites and evidence problems: verification errors, inconsistent bundles, inaccurate claims and results you could not reproduce. How to report
2026-09-28 — CAIN-42 governs L5 AI systems: the system governor is switched on in the live gateway
In one sentence. An autonomous (L5) AI system can now only act through CAIN-42 on the hosted gateway: an unregistered system or an unsigned request is refused, and a registered system is checked, action by action, against its signed manifest, its policy, its authority limits and governance state signed by a quorum of the live cluster.
What changed./fabric/mcp/enforce is fail-closed for every tenant (CAIN_SYSTEM_GOVERNOR=1, gateway restarted 12:03 UTC). A system is registered by an operator as a governance-signed manifest of its agents, models, tools and resources; every agent request must be signed by that agent's registered Ed25519 key (60 s window, nonce replay refused); governance state (policy, resources, trust) authorizes only when the live cluster cain-mr-01 has committed its digest and the gateway verified the 3-of-4 quorum certificate itself (only digests and a tenant hash are ordered, never names). Emergency freezes are operator-signed, scoped and expiring; lifting one needs two operators. Decision records are append-only in the database.
Verified on the live gateway, through all three domains. 13 of 13 cases behaved as specified: an in-scope read was allowed on each domain; an unregistered tenant, an unsigned request, another agent's key, a replay, an action outside the system's authority, a swapped model, a subagent WRITE, an unlisted tool and an emergency freeze were refused; one-operator recovery was refused and two-operator recovery restored service. State certified at cain-mr-01 sequence 20167 (3 signers); 8/8 decision signatures valid; the 18-event chain verifies. A clean-room verifier (no CAIN imports) re-checks all of it and, with --live, confirms all three sites publish the same governance key and the cluster's own public record names this run's state digest: 41/41 VALID. reproduce · verifier · transcript · the run
CAG-L5 verification matrix. 12 governance capabilities, each with only the status its evidence supports: 6 VERIFIED on the live path (agent identity, dynamic authority, system governance, resource governance, containment, evidence fabric) and 6 PARTIAL (continuous authorization, trajectory, MCP execution, risk, trust, independent verification: tested, verified offline or in part, not fully exercised live). the matrix
Claims. Six L5 claims were added to the Ed25519-signed registry (now 37): C42-CAG-L5-HOSTED-GOVERNOR (LIVE VERIFIED), C42-CAG-L5-SYSTEM-GOVERNANCE, C42-L5-TRAJECTORY-GOVERNANCE and C42-L5-IDENTITY-AUTHORITY (TESTED), the negative-evidence claim C42-L5-TRAJECTORY-FAIL-OPEN-FOUND, and C42-L5-UNIFIED-V1-SUPERSEDED for the earlier bundle. The public evidence inventory re-hashed 1,944 files fetched from the three sites: 0 different, 0 missing, 0 hash mismatches; 787 published files have no signed claim and are labelled UNVERIFIED. Verification Center · inventory · signed machine index
Homepages. The three homepages now say plainly that CAIN-42 governs L5 AI systems: simple at the top, technical further down. Text only; the page structure is byte-identical (checked tag by tag, and the frontend lock reports 0 changes across 73 pages). The production-gate row for the 72-hour soak now reads FAILED (checkpoint 32), replacing the stale “every checkpoint so far is valid”.
Limits, stated. The live run used an operator self-test tenant and a scripted agent: no customer and no LLM agent is governed end to end yet. The hosted endpoint returns a signed verdict and execution commitment; the caller's own gate executes. Leases live in memory (at most 1 h), so a gateway restart denies until they are re-issued. CAG-L5 is CAIN's own governance designation, not the SAE driving scale. Three operators, one provider, no hardware attestation, no third-party review.
2026-09-28 — Continuous trajectory governance: 13 fail-open paths found and closed; CAG-L5 system governance; soak status
Prompt 3 — we attacked our own trajectory authorizer and it failed 13 of 13. The continuous-authorization layer published earlier today returned ALLOW for a lease the agent signed itself, an unsigned lease, a lease belonging to another agent or trajectory, a lease with no expiry, a lease with empty scope (treated as unlimited) or no policy version; it allowed PAUSED, ESCALATED and REAUTHORIZATION_REQUIRED trajectories to act; containment could revive a TERMINATED trajectory and relax a quarantine; and the plan→action binding was never checked. All 13 now fail closed (commit 040cee2): leases must be signed by a governance key (never the agent's), bound to the agent and trajectory, time-bounded (≤1 h), and fully scoped; only ACTIVE/LIMITED trajectories may act; containment only tightens; plan, intent, action, parameters, resource and context must match what governance bound; subagent risk is charged to every ancestor so splitting work across subagents cannot evade cumulative limits. before/after probe record
Correction. Earlier today this changelog said the trajectory layer had “15 executable invariants” and that the unified bundle verified 22/22. Five of those invariants were the constant True, and the bundle's ALLOW came from the fail-open authorizer. All 15 now execute a code path. The old bundle is left byte-identical (its manifest pins it) with a SUPERSEDED note. The new clean-room verifier recomputes the decision and nine adversarial requests instead of trusting them: 43/43 VALID. verifier (no CAIN imports) · transcript
Prompt 4 — CAG-L5 system governance (CAG-L5 = CAIN Autonomous Governance Level 5, CAIN's own governance designation; not SAE Level 5). One decision now composes: emergency freeze → 2f+1 governance-state quorum → attested, fresh state → a governance-signed system manifest (agents, models, tools, resources, system ceiling) → model identity → tool registry → exact-capability resource checks (READ≠WRITE≠DELETE≠ADMIN≠GRANT_ADMIN) → deterministic policy precedence (a lower ALLOW never beats a higher DENY) → authority intersection (agent ∩ delegator ∩ system ∩ trajectory lease) → the trajectory authorizer → graph-derived blast radius and reversibility, where irreversible or critical actions need two distinct operators. The MCPGate side re-verifies CAIN's signed decision and execution commitment, blocks missing, forged, mutated and replayed calls, and compares the actual effect with the committed one. Emergency controls are scoped, expire within 24 h, and need two operators to lift. The layer plugs into the MCPGate SDK interceptor's existing restriction-only hook.
Evidence — reproduce it yourself. Part 41 Tests A–M on a reference system (primary agent, subagent, 2 MCP tools, databases, config, a 4-node quorum): ALLOW / DENY×3 / REASSESS on policy change / DENY on trust drop / REASSESS on model swap / DENY subagent escalation / MCP bypass blocked×3 / Byzantine disagreement DENY / ESCALATE then ALLOW with two operators / PAUSE on freeze / ALLOW after two-operator recovery. Test N: a clean-room verifier recomputes policy, authority, blast radius, quorum and step-up for every decision, and rejects an ALLOW that CAIN signed but that is not justified: 148/148 VALID, checked from all three sites. 16 system invariants and 16 trajectory invariants PASS; 110 tests in the published run (901 across the regression group). Measured single-process: system decision p50 1.85 ms (≈500/s); MCPGate-side check p50 0.36 ms. reproduce · manifest (SHA-256) · system verifier · transcript · control map · benchmark
Limits, stated. The system governor is a TESTED library. It is wired into the MCPGate SDK as an opt-in hook that is OFF by default, and the hosted gateway path does not use it. Its control map governs 15 of 17 domains; NETWORK and SECRETS are not governed by it. Keys in the bundles are ephemeral. There is no third-party review, no hardware attestation, and no real LLM agent governed end-to-end. No L5 claim is made.
72-hour multi-region soak: still running, and it will be recorded as FAILED. At 37.7 of 72 hours (ends about 2026-09-29 21:40Z), the live cluster cain-mr-01 has had 107 replica kills and 107 restarts, with 0 divergences and 0 anomalies; 37 of 38 checkpoints verify, each with 48 quorum certificates. Checkpoint 32 (hour 32) does not: its MCPGate-enforced checkpoint authorization did not commit (CONSENSUS_TIMEOUT). The soak's own pre-committed rule is that every checkpoint must carry that enforcement evidence, so its verifier already returns FAIL, and no later hour can change that. Consensus safety held; one hourly enforcement proof was missing. We publish that as a fault, not as a pass. the failing checkpoint · verifier transcript (run from clawx.click) · verify all checkpoints
2026-09-28 — L5 agent identity & authority: an independent verifier refuses 25 attack classes; all evidence is now on all three sites
Every claim's evidence, on every site, independently checked. The two evidence roots were mirrored so all 919+ files and 63+ bundles of published proof are served identically by cainstudio.online, mcpgate.online and clawx.click (cross-site one-root-only: 443 → 0). The signed claims registry, the full public evidence inventory, the signed machine index and the one-command verifier are linked from the evidence pages, and verify_all.py re-derives every claim's artifact SHA-256 from all three sites (186/186). signed claims registry · full public evidence inventory · signed machine index · verify it yourself
Independent authority verifier (Prompt 2, Part 41). A clean-room verifier that imports nothing from CAIN independently re-derives RFC-8785 canonical JSON, domain-separated Ed25519 signatures, expiration, revocation, delegation scope, authority intersection, policy binding and action binding for AgentIdentity, AuthorityGrant, DelegationGrant and AuthorizationDecision. It refuses forged, altered, replayed, expired, revoked and key-substituted identities; scope expansion and constraint widening through delegation; delegation depth and delegations outliving their parent; expired/revoked grants, trust-floor bypass and policy downgrade; self-authorization, policy-scope escape, action substitution, cross-tenant access, single-use token replay and over-authorization. Running it on a signed valid bundle returns VALID; on a tampered bundle it returns INVALID and the reason codes. the verifier · worked example · the tampered bundle it rejects
Independently verified from more than one source (2026-09-28). The published evidence is re-verified by five independent verifier implementations that share no code — verify_all.py (every claim and artifact, from all three sites), two separately-written clean-room L5 authority verifiers (verify_authority_bundle.py and verify_authority_bundle_engine_b.py, both VALID on the same bundle), verify_l5_bundle.py, and the multi-source driver's own registry check — and they all agree. multi-source verification report · transcript · run it yourself. Scope: this is multi-implementation verification by the same project; no third party has reviewed CAIN-42 and it is not a certification.
Honest status: INCOMPLETE, not A+. The verifier is self-attested (same operator; no third party, same as every other bundle here). The L5 identity/authority runtime layer in cain45/l5 is owned by a separate session and is not claimed here. Performance is NOT_VERIFIED. The bypass report declares messaging and email NOT_IMPLEMENTED and the secrets broker NOT_IMPLEMENTED, and states the unconfined-process (RAW) gap: a process that does not route through CAIN or MCPGate is not seen. conformance report (PASS/INCOMPLETE/NOT VERIFIED) · bypass report (Part 27) · forensic inventory
The runtime layer behind the independent verifier.cain45/l5/ now implements a first-class signed, versioned AgentIdentity (model/runtime identity, owner, policy binding, key lifecycle: create/rotate/revoke/reissue, signed identity statements) and a dynamic authority fabric: capability-scoped, resource-scoped, operation-scoped AuthorityGrants with temporal bounds, trust floors, budgets, environment and policy binding; non-escalating DelegationGrants that cannot expand capability, resource or time and cannot outlive their parent; and explainable AuthorizationDecisions with machine-readable reason codes (DENY_INSUFFICIENT_AUTHORITY, DENY_EXPIRED_GRANT, DENY_TRUST_BELOW_FLOOR, DENY_DELEGATION_DEPTH, DENY_REPLAY, ...). Authority is the deterministic intersection of the narrowest valid constraints — never an average.
Enforcement. The L5 boundary is wired restriction-only into the Agent Hypervisor and MCPGate: an L5 ALLOW is "no additional restriction", and an L5 decision can never loosen a hypervisor or MCPGate denial. Caller↔subject authentication closes the "caller-supplied agent string" gap: a caller must present a signed assertion from a registered caller identity whose subject equals the principal it claims. The hosted gateway service (platform-gateway/cain_l5_gateway.py) and the /l5/* API (agents, authority, delegation, authorize, explain, audit, conformance) are opt-in via CAIN_L5_GATEWAY=1 and fail closed when enabled without registered credentials.
Evidence — reproduce it yourself. 90 new tests pass (49 constitution + 11 wiring + 5 gateway + 20 identity/authority + 5 soak/verifier), with 206 more passing across the hypervisor/MCPGate regression group. The kernels expose 30 executable invariants (20 L5 safety + 10 identity/authority) and all hold. Two clean-room verifiers that import nothing from CAIN return VALID: verify_l5_bundle.py (10/10) and verify_authority_bundle.py (22/22), the latter independently re-deriving canonical JSON, signatures, expiration, revocation, delegation scope, authority intersection, policy binding and action binding. A 3,000-step long-horizon soak records 0 governance violations. Measured: L5 gate 53.6µs/op ALLOW, 45.3µs/op DENY.
Bugs the suites caught and fixed. The identity/authority attack tests found and closed three real defects before shipping: single-use token replay was not detected when the nonce was reused; delegation narrowing was not applied to evaluation (a delegate could reach resources outside its delegated scope); and revocation mutated the signed grant body, invalidating its signature (revocation is now an external registry fact).
Honest status: INCOMPLETE, not L5. The runtime is a TESTED library; hosted enforcement is opt-in and not yet the default path. No real (non-scripted) LLM agent is governed end-to-end; no hardware root of trust; one provider; no third-party review. The repository-wide bypass audit found 57 ungoverned consequential paths (e.g. cain/guard.py falls back to local evaluation; cain/mcp_proxy.py swallows trajectory-gate exceptions) — documented, not hidden. No L5 claim is made.
2026-09-28 — Independent verification: three clean-room verifiers, both evidence roots, all VALID
What was verified. Three verifier implementations that share no code and import nothing from CAIN independently re-derive canonical JSON, Ed25519 signatures, the trajectory hash chain and its RFC-6962-style Merkle root, delegation non-escalation, authority intersection, policy/action binding and the invariant matrices. All three return VALID against the published bundles: verify_l5_unified.py (22/22), verify_authority_bundle.py (22/22) and verify_l5_bundle.py (10/10). The signed artifacts and the verifiers are published on both evidence roots so either site can be checked by hand. reproduce it with one command · manifest with per-file SHA-256 · the unified verifier (no CAIN imports) · the signed bundle
What this proves, and what it does not. It proves the artifacts are internally consistent and cryptographically sound under a verification implementation that shares no code with the runtime. It does not prove independent third-party review: the verifiers, the runtime and the operator are the same, on one host, with one provider, and no external party has reproduced it. So we do not claim CAIN-42 is "fully independently verified from more than one source" — that would be false today. What is true is narrower and checkable: multiple independent verifier implementations agree, on published signed artifacts. No L5 claim is made.
2026-09-28 — Six authority fabrics: intelligence may propose, only a quorum-certified decision authorizes
New governed libraries, none of which can authorize anything. A Trajectory Firewall hash-chains a long-horizon run and flags plan/authority drift, scope creep, privilege accumulation, tool/model/identity/memory substitution, stale authorization, delegated escalation and suspicious retries. Stopping Intelligence reaches STOP/WAIT/REQUEST_APPROVAL/REPLAN/ROLLBACK/QUARANTINE/ESCALATE and can only ever make an action less permissive. A Swarm Authority Fabric keeps CHILD ≤ PARENT and SWARM ≤ POLICY, and treats unanimous agent votes as informational. A Governed Tool lifecycle makes discovery and creation grant NO AUTHORITY. A Governed Memory Fabric classifies every item, calibrates it, and cannot become policy. Resource Authority is time/scope/resource/policy/trajectory-bound, revocable and non-escalating. They encode one rule: LEARNING, PREDICTION, MEMORY, SIMULATION, DISCOVERY and AGENT CONSENSUS may change capability but never create execution authority. 419 new unit tests plus one executable Part XXVIII invariant matrix.
Limits. These six fabrics are TESTED unit libraries, not VERIFIED: no published independent evidence bundle exercises them, and they are not wired into the hosted enforcement path. The world model is tabular, not neural; the memory is not a vector store. The hosted runtime remains PRE_PRODUCTION. see every claim's evidence and limits
2026-09-28 — Governed policy evolution: learning can propose, only the cluster and a human can authorize
Policy changes are governed. A tenant's policy (which capabilities a ZoD may hold, the largest budgets it may get) now becomes active only when the live cluster cain-mr-01 commits its activation. Widening it needs a registered human who is not the proposer; narrowing it needs no one, because authority may always go down. On the live cluster: an agent's first policy was approved by a human and activated (QC 16148); the agent then proposed an expansion and approved it itself — refused, and the cluster was never asked; a fault lab's restriction was activated (QC 16151) and a running ZoD lost its authority on its next call; a ZoD above the ceiling was refused. verify: python3 verify_e8_governance.py . -> 19/19 checks, VERIFIED
Predictions, simulations, agent votes and memories are not authority. Four things an intelligent system produces were presented to the hypervisor as the basis for a ZoD: a world-model prediction with 0.99 confidence, a simulated ALLOW citing a real certified sequence, ten agents' unanimous signed vote, and a memory replaying a real decision with the verdict changed. Each was refused because the live cluster had not certified it; across the run exactly one ZoD was ever authorized.
Limits. Scripted identities, not a real LLM agent. CAIN does not contain a world model, digital twin or learning memory: the run shows their outputs cannot become authority. The governor runs as a library on the gateway host. The registry now also names seven older files on the sites whose self-asserted statuses (CERTIFIED, PRODUCTION_HARDENED, OPERATIONAL_PROVEN...) no evidence supports; they stay for history, marked superseded.
2026-09-28 — Fail-open defects found and fixed; the authority check is no longer quadratic
Four ways authority could survive what should end it, found by an independent probe, all fixed. Moving the clock back revived an expired grant (now: a stored time high-water mark refuses a clock that goes backwards). A tool could run while the evidence log was unwritable (now: the intent is recorded before the effect, so no log means no execution). A failing trust service, and a cluster that errored during authorization, raised instead of refusing (now: recorded refusals). Tests: 4 former gaps now pass, and fail on the previous code.
Faster. Every action re-verified every signature since the ZoD began. Now each entry is re-hashed but its signature verified once: gate p50 with 100 ZoDs in the store went from 113 ms to 18.7 ms (1,000 ZoDs: 36 ms; p99 about 0.3 s). Measured on the gateway host.
Limits. Library-level fixes in the hypervisor on the gateway host; the p99 tail is not yet explained.
2026-09-28 — Authority lapses on policy change, cluster membership/epoch change and spent risk/blast-radius budgets
Evolution #7: the five conditions Evolution #6 left open, on live authority. Every ZoD was authorized by the live cluster cain-mr-01 (decision QC 15876, ZoD QCs 15880-15892), made one successful tool call, and was refused on the next call with the tool never running once: the policy root changed; the policy source became unreadable (unknown is refused, never read as unchanged); the risk budget was spent; the blast-radius budget was spent (actions now carry consequence classes C0 read to C4 security/infrastructure); and a delegate spent its parent's budget — delegates are charged up the whole chain, so splitting work across children cannot multiply authority. Each ZoD is bound to the cluster's real membership configuration (hash recomputed, a quorum of replicas agreeing), re-read before every action (36 live reads in this run); a changed epoch, a changed membership and an unreachable cluster were each refused. Also fixed: a retry after a replica committed but timed out used to be refused as 'not committed'; the client now takes the committed sequence from the replica's cached reply and accepts it only if that certificate verifies over the exact request. verify: python3 verify_e7_lease.py . -> 60/60 checks, VERIFIED
Limits. Stated, not hidden: the three membership/epoch changes were INJECTED into the hypervisor's view (the live cluster was not re-keyed); the policy and budget trips are real. Enforcement is the hypervisor library on the gateway host. Only tool-call budgets were exercised live.
2026-09-28 — Agent Hypervisor (ZoD) authorized by the live cluster; authority leases that expire, revoke and cascade
Agent Hypervisor / ZoD runtime, authority from the live cluster. An agent never holds execution authority; it acts only inside a ZoD (Zone of Decision), and only after the live 4-server cluster cain-mr-01 has committed that ZoD's authorization with a quorum certificate (3 of 4 Ed25519 signatures) that the hypervisor checks itself. Code runs under real confinement (bubblewrap namespaces + cgroup v2, no network, host tree invisible). Two ZoDs were authorized at cluster sequences 13379 and 13380; 10 attacks were refused, each as a signed DENIED entry; 45 evidence entries, hash-chained. verify: python3 verify_cain45_zod.py . -> 10 PASS, VERIFIED (about 0.3 s)
Authority leases, tripped live (Evolution #6). A ZoD is a temporal authority lease. For each of 9 conditions a fresh ZoD was authorized by cain-mr-01 (decision QC 15746, lease QCs 15748-15759), one tool call succeeded under that live authority, the condition was tripped, and the next call was refused with the tool never running: TTL expiry, trust below floor, agent identity swapped, tool schema changed (rug-pull), security context changed, trajectory fork, explicit revocation, parent quarantined (child loses authority with it), required evidence deleted. Four of these were holes found and closed this release: before the fix a child ZoD kept acting after its parent was quarantined, a tool whose schema changed after authorization was still called, a re-registered (swapped) agent identity kept acting, and deleting the evidence log did not stop execution. verify: python3 verify_e6_lease.py . -> 48/48 checks, VERIFIED
Limits. Stated, not hidden: the invalidation logic runs in the hypervisor library on the gateway host, not on the cluster nodes; what comes from the cluster is the authority being invalidated. The evidence-deletion row is SELF-REPORTED: its result is signed by the run's hypervisor, but the log that would prove it is the one deleted. Not implemented yet: invalidation on policy, epoch or membership change, risk and blast-radius budgets. A separate 4-node 'authoritative state' layer in the code is SIMULATED (one process holds all 4 keys) and is not used for any of this evidence. seccomp, egress allowlists and hardware attestation are not established.
2026-09-27 — Verify your own decision records offline; disk and memory monitoring
Customers can now export any of their decisions exactly as stored and signed (GET /fabric/decisions/{id}/signed-record) and verify it offline with the published verifier, which contains no CAIN code. New disk and memory watcher on all four servers, after /tmp filled up on the Atlanta server; every server is currently below 80% disk use.
2026-09-27 — Gate X: every hosted decision record is signed
Every hosted decision record is now Ed25519-signed by a key kept outside the database, so an edit is detectable even if its digest is recomputed; that covers the stages after consensus and the final verdict. Public key at /fabric/decision-signing-key. Verified live. Not covered: root on the gateway server. Gate X PASS (5 of 9).
2026-09-27 — 13 test faults fixed; tampered-evidence flag traced and corrected
The previous full run's 13 test faults traced and fixed without weakening a check (latest run: 5453 passed; its remaining faults belong to a change still in progress). The Verification Center correctly flagged one claim as TAMPERED: a soak verifier had been overwritten after signing. The signed bytes are restored and the fix is published as v2. That soak's real outcome is recorded: it stopped at 24 of 72 hours and its verifier returns FAIL. The daily signed sync now measures the live 4-region cluster.
Two-replica storage loss, rebuilt from off-host backups. On the live 4-server cluster, the Miami and Silicon Valley replicas lost their storage at the same time and were rebuilt only from backups held in other regions. While both were down the cluster committed 0 of 4 writes; afterwards 0 decisions were lost and all four were identical 10.3 s after restart. verify 416 certificates
MCPGate enforcing live consensus. Authorizations committed by the live 4-server cluster; every tool call went over HTTP through the MCPGate proxy to a separate MCP server process. 5 authorized calls ran (per the server's own log); 12 attacks were blocked, and each caller received the gate's signed denial. verify with one command
Hosted decisions: the gateway now checks the quorum certificate itself. Security fix: the hosted consensus stage used to accept a replica's word that a decision was committed, so one lying replica could have authorized a decision with no quorum. The gateway now verifies 3 pinned Ed25519 signatures over the digest it computes for that decision, and shows the check on every decision. verify a decision yourself
Formal models checked. TLA+ models of the PBFT commit/view-change rules and of the MCPGate gate, checked exhaustively by TLC: 0 violations in 7.3 million distinct states, and all 8 deliberately broken variants caught. An earlier run had been recorded as incomplete because the checker stopped at the model's normal end state; fixed. models and results
Claims registry rebuilt from current evidence. 24 signed claims. It had still said one host and no formal verification, and still called the failed single-host 72-hour soak 'in progress'; it now records that soak as FAILED and the multi-region soak as running. Gates: 14 of 15 (A-O) and 3 of 9 (P-X); hardware attestation is blocked (no TPM, SEV or TDX on any server). verify the registry
One-way network partitions. On the live 4-server cluster: a replica that can talk but not listen, a one-way link between two backups, and a replica that can listen but not talk. The cluster kept committing in each case, went through view changes, and all four replicas held identical decision chains after each heal. verify 968 certificates
Daily restore validation. Every day each replica's newest off-host backup (8 replicas, 2 clusters) is fetched from the server in another region that holds it and proven to be a quorum-signed prefix of the live history; tampered backups fail even with a re-hashed manifest. verify
Signed evidence index for crawlers and AI agents. /cain42-evidence-index.json on all three sites: every claim with its status, limits, artifact hashes and verification command, every gate, and the live endpoints, generated from the signed registry and signed with the evidence-root key; llms.txt carries the same, generated. claims registry
Degraded network: safe, but slow. 10% packet loss, 120±40 ms jitter, 5% duplication and reordering on all four replicas of the live 4-server cluster for 4 minutes: no fork, but throughput fell from 1.76 to 0.16 commits/s and 22 of 61 writes timed out; it recovered fully afterwards. The evidence publisher now runs the privacy firewall before anything reaches the sites (a bundle was briefly public with an internal subnet in its description). verify 2,728 certificates
Engine 948b189 on the 4-server cluster: fewer view changes, same throughput under loss. View-change backoff now resets only when a view commits, and a fresh view is not accused. Released reproducibly (two independent builds, identical image ID; signed release manifest 17/17), upgraded replica by replica under live traffic (each caught up in 11-31 s, no quarantines). Re-running the same degraded-network test: view changes fell from 14 to at most 6, but throughput under 10% loss stayed about the same (0.16 -> 0.18 commits/s). The storm was not the bottleneck; message delivery under loss is. Safety held (4,448 certificates, no fork). before/after, verify 4,448 certificates
2026-09-27 — SDK guard is now default-deny
The self-hosted SDK and MCP proxy now hold any undeclared action for approval instead of allowing it. Authorized tools are declared with guard(allow=[...]), allowed_tools=[...] or CAIN_ALLOWED_ACTIONS. Opting out (CAIN_UNKNOWN_ACTION_POLICY=allow) is explicit and recorded on every decision. 1516 dependent tests pass.
Free shadow mode for every customer; paid plans can switch themselves to enforce mode (POST /fabric/settings). The 4-server cluster's image was reproduced exactly by two independent builds (signed manifest 17/17). SDK allowlists and opt-in default-deny. Audit fixes applied. 13 of 15 gates pass.
2026-09-27 — Four servers, four regions: any single server can fail
cain-mr-02 runs one replica on each of Atlanta, Los Angeles, Miami and Silicon Valley. Every server was taken offline in turn, and it kept committing each time (6/6, with a leader change each time). With two down it refused. 264 certificates, 40/40. Only the provider (Vultr) remains a single point of fault. 12 of 15 gates pass.
Two independent from-scratch builds of one commit gave the same image ID, with every layer identical. Backups are also stored on another region's host. The live cluster moves to the reproducible image after the soak.
2026-09-26 — Byzantine replicas handled across three regions; proof every 30 minutes
A forging replica's votes were rejected everywhere (6/6 committed). An equivocating primary was proven from its own signatures, quarantined by all 3 honest replicas and replaced (6/6 committed). 29/29 checks. This ran on a disposable cluster with the same placement. A signed operational proof is published every 30 minutes. The test suite is fully green (870/0), including a fixed approval-workflow bug. 11 of 15 gates pass.
2026-09-26 — Signed release manifest; published test report
Same image on every host; 1,461 image files byte-identical to the commit; 47-package SBOM; Ed25519-signed (verifier 16/16). Tests: 865 passed, 4 failed; the faults predate this work and are listed by name.
2026-09-26 — Network partitions on the live cluster; operational drill
With Miami cut off, the other three committed 6/6 and the isolated replica committed nothing. In a 2|2 split neither side committed, so there was no split brain. All four agreed within about 3 s of each heal (2,960 certificates, 32/32). The anti-entropy fix (81bdf84) is rolled out live. Drill: rolling restart under writes 83/83 with 0 faults; disk-loss rebuild in 13.6 s. 7 of 15 production gates pass.
2026-09-26 — Live drill: a real defect found and fixed; production gates published
Every homepage lists the fifteen production gates with evidence links (5 of 15 pass today) and a live cluster-state line. A load test on the live cluster exposed a real defect: a replica signed after losing primacy and accused honest peers with a mismatched-signer proof. Safety held. Fixed in 9fedb49 with tests and rolled out live the same day as a rolling upgrade; all four replicas agree. Also: health endpoint, rolling upgrades, online backups.
2026-09-26 — CAIN-42 PBFT cluster live in three regions
LIVE · VERIFIABLE
4 PBFT replicas on 3 hosts in Atlanta, Los Angeles and Miami over WireGuard (n=4, f=1, quorum 3). Fault injection on the live cluster: Miami down, 6/6 committed; one Los Angeles replica down, 6/6; whole Los Angeles host down, 0/3 (refused, as required); Atlanta and the primary down, view change, then 6/6. 336 certificates, 49/49 standalone checks. The signatures confirm that no decision taken during an outage was signed by a stopped replica. Scope: three operators, one provider; not yet in the hosted decision path.
2026-09-24 — PBFT Evolution 2: quorum certificates you can verify in your browser
SELF-ATTESTED
Evolution 2 of the PBFT engine is committed (364f1bf). It adds up to 4 proposals in flight, a pacemaker that only sets timeouts and cannot authorize anything, and an AuthorizationCertificate that is valid only with a valid COMMIT quorum certificate and a request whose intent, proposal and action hashes match. It also fixes a real defect: the post-commit authorization proof hardcoded trust_state=HIGH and risk_state=LOW, which it never evaluated. It now says NOT_EVALUATED. Tests: 135/135 PBFT Evolution 1+2 and 167/167 wider Byzantine/cluster suites. Public evidence: a disposable 4-node cluster built from c188442 committed 20 decisions across a primary failover. All 160 quorum certificates are published with the signed votes, a standalone verifier that uses no CAIN code, and a page that checks them in your browser (29/29, including 7 tamper controls that must fail). MCPGate is not yet wired to consume the AuthorizationCertificate. The run used one host. Later the same day the live cain-vc cluster was upgraded to this build, node by node: state was preserved on all 4 nodes, a smoke write committed, and rollback copies were kept. Its first new decision's COMMIT and PREPARE certificates and AuthorizationCertificate verify on all 4 nodes. Its first two decisions predate certificates, so its history cannot be verified from genesis, and its API is not publicly reachable.
2026-09-22 — Last-mile enforcement wired into a live route; infrastructure hardening
SELF-ATTESTED
Not production in the business sense: no customer traffic, same-operator infrastructure, no third-party review. What changed: cain_agi_control_boundary.ControlBoundary.submit_proposal() — the one pipeline here that calls MCPGateLastMileEnforcer (in-flight parameter-mutation defense) after issuing a signed Proof-Carrying Decision — was fully built and tested but reachable only from pytest before today; grepped every live route file for a reference and found none. Now live at /fabric/agi/propose (auth-gated, execution scoped to a small registered sandbox tool set).
Also added: cain_agent_trust_passport.py, composing existing identity attestation, evidence-backed trust state, and capability-delegation-chain verification into one signed artifact; fails closed rather than fabricating a trust score.
Also fixed: a BFT certification harness bug that hardcoded "state_transfer_implemented": false in every rejoin-stage result regardless of actual outcome. The protocol is real; the field now reflects a live probe instead of a constant.
Also removed (twice — written by two different concurrent sessions): a draft evidence page claiming "108/108 tests, 4/4 nodes OPERATIONAL" for modules that do not exist anywhere in this repository. Never linked or deployed — caught before publication.
Infrastructure (verified, not new): DNS for all three domains resolves to this host; valid auto-renewing TLS; gateway runs under systemd with Restart=always. Still open: multi-node BFT rejoin certification has not passed the full pipeline, and most of the larger "autonomous agency" roadmap this codebase is periodically asked to build remains intentionally unbuilt.
Doctrine:COMPROMISED COGNITION ≠ COMPROMISED AUTHORITY ≠ COMPROMISED WORLD STATE — Consequential autonomy is continuously bound, observable, cryptographically evidenced, independently verifiable, and recoverable from cognition through real-world effect.
Observation ≠ Authority Sensory inputs require quorum attestation and cannot elevate authority.
ActionProofObject (24 Fields) 24-field proof bound before MCPGate socket execution.
Closed-Loop Reconciliation Tool return 0 is not success; postconditions verified against reality.
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.