The CAIN-42 agentic evidence portal · live evidence for autonomous AI agents
Everything needed to audit CAIN-42 is on this one site, checked by your browser.
Auditors only need clawx.click. The live production clusters, real quorum certificates, live decisions, every signed claim with its real status, every evidence file, the signing keys, the public Sigstore anchors and the offline verifiers are all reachable from this page. Nothing requires an account, and nothing asks you to trust us.
CAIN-42 is a Byzantine trust fabric. This site is where its evidence is kept: the Ed25519-signed claims register, every evidence bundle, the hash-chained proofs written by the two live validator clusters, and the monitors that re-check them. Statuses are copied from the signed files exactly as published, whatever they say. When this page loads, it recomputes the hashes and verifies the signatures with your browser's own WebCrypto. You don't have to take our word for anything.
Why execution-layer governance
- Evidence-root key (Ed25519)
loading…- Signed evidence index digest
loading…- Catalog generated
loading…
The architectural case
More capable agents. Explicit authority. Verifiable evidence.
Authorization claims should be checkable.
Long-running agents and coordinated swarms need more than instructions. They need clearly bounded authority, enforceable tool access, operational continuity, and records that can be checked. These 13 talks and demonstrations explain complementary parts of that challenge. Every one can be played on this page.
An agent's ability to propose an action is not the same as its authority to execute it. CAIN-42 is designed to place an enforceable authorization boundary between AI agents and governed tools or real-world effects, with evidence of authorization decisions.
The goal is not to make agents less useful. It is to make broader autonomy practical by keeping permissions, limits, revocation, and evidence outside the model's discretion. Prompts guide behavior. Execution controls determine which governed actions may actually run. Security-critical authorization should not depend solely on the model following its prompt.
The industry is converging on the execution layer
The same requirement is now being described in public by some of the largest names in the field, each from its own position. Speakers and publishers in the 13 sources below include:
- Anthropic
- AWS
- Microsoft (speaker)
- NVIDIA
- Visa
- Okta
- Kong
- The Linux Foundation
- LF Decentralized Trust
- Moonshot AI (Kimi)
- EnforceAuth
Independent sources, not CAIN endorsements. These sources discuss related architectures and engineering principles. None of them mentions CAIN-42. CAIN-specific capabilities and performance require CAIN-specific evidence, which is linked on every card.
Where the boundary sits
- ProposeAn agent or swarm proposes an action.
- CheckThe authorization boundary checks policy and delegated authority.
- Execute if authorizedThe governed tool runs only on ALLOW.
- RecordDecision and execution evidence are recorded as supported.
- Monitor and revokeMonitoring and revocation stay available within the documented scope.
A recorded authorization decision shows what was permitted. It does not prove the action succeeded, and not every external effect can be reversed.
What this means
- Prompts guide the agent.
- Policies define permitted actions.
- Enforcement controls governed execution.
- Evidence supports later verification.
- Revocation limits future authorized activity within the system's actual coverage.
This site holds the records: who proposed an action, which decision was made, and the signed, hash-chained entry that says so, with verifiers that run offline. Four things are kept distinct: an approval, an attempted execution, a completed execution, and a successful outcome. A valid signature can establish the origin and integrity of a record. It does not, by itself, establish that the record is complete, that every assertion is true, or that the underlying action succeeded. The validator clusters that co-sign records are operated by the vendor across several regions; they are not independently administered.
Watch the 13 sources
13 relevant talks and demonstrations.
-
SOURCE 01 OF 13 · OPEN-SOURCE PROJECT TALK
Policy-Checked, Attributable, Revocable, Provable AI Agent Authorization
How it relates to CAIN-42: It makes the same separation CAIN-42 is built on: what an agent is able to do is a different question from what it holds authority to do, and the second must be answered outside the model.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Introduces Caracal, an open-source AI authorization project in the LF Decentralized Trust mentorship program. The publisher's description says it covers why API-key and identity models fall short for agents, what authority means for autonomous systems, and an architecture for policy-based authorization, attribution, revocation and auditability.
- How CAIN applies this principle
- MCPGate refuses a governed tools/call that does not carry a signed, short-lived capability token bound to that call's parameters and usable once. A changed argument or a replayed token is refused. Implemented; public evidence limited
- What this does not prove
- Caracal is a separate project. Its talk does not mention, validate or endorse CAIN-42.
- CAIN evidence and documentation
- Try a blocked tool call in the MCPGate playground · Where MCPGate sits in the request path
-
SOURCE 02 OF 13 · INDEPENDENT TECHNICAL PRESENTATION
Trust and Guardrails Governing Autonomous AI Agents on Azure
How it relates to CAIN-42: That dedicated layer between proposal and execution is the position CAIN-42 occupies.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: authorization changes once software interprets intent and acts for a user. Agents should have their own identities and narrowly scoped permissions, and policy such as spending limits and approval thresholds should live in a dedicated layer between the agent's proposed action and execution, not inside a prompt.
- How CAIN applies this principle
- CAIN decisions are made per proposed action. Only ALLOW is executable; REQUIRE_APPROVAL pauses for a person; unknown or error states are denied. Budget and spending envelopes exist in the AOS mission runtime, which is a reference implementation. Implemented; public evidence limited
- What this does not prove
- This is an individual's presentation about building on Azure. It is not presented here as official Microsoft policy.
- CAIN evidence and documentation
- Try a blocked tool call in the MCPGate playground · Agentic 75 governance map
-
SOURCE 03 OF 13 · VENDOR PRESENTATION
How to Build Audit-Ready Governance for Autonomous AI Agents | Okta
How it relates to CAIN-42: Attributable actions and permission management across an agent's whole lifecycle, including the ability to stop it, are core CAIN-42 requirements.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: a masterclass on keeping a traceable, verifiable audit trail as autonomous systems act for an enterprise, moving from static security snapshots to continuously enforced identity controls, with clear ownership and accountability.
- How CAIN applies this principle
- Every MCPGate decision is tied to an agent identity and written to a hash-chained, signed record. Revocation is checked mid-flight at the boundary, and a fleet quarantine (kill switch) stops further authorized actions by an agent or swarm. Implemented; public evidence limited
- What this does not prove
- "Audit-ready" is the vendor's phrase, not an independent compliance finding, for Okta or for CAIN-42. A kill switch stops future governed actions; it does not undo completed ones.
- CAIN evidence and documentation
- CAIN-42 evidence registry · Offline verifiers
-
SOURCE 04 OF 13 · VENDOR PRESENTATION AND DEMONSTRATION
Agentic Identity: Securing MCP Servers with Kong AI Gateway
How it relates to CAIN-42: A gateway placed between agents and MCP tools, acting as both network and identity perimeter, is the architectural position of MCPGate.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: agents should stop carrying every credential themselves and route actions through a governed gateway. Covers monitoring MCP traffic, inbound identity, outbound credential translation, token vaulting and fine-grained authorization policy at the gateway.
- How CAIN applies this principle
- MCPGate is a JSON-RPC proxy (stdio and HTTP) between an agent and its MCP servers. A tools/call that is unknown, malformed or unauthorized gets a JSON-RPC error and is not forwarded to the server. Implemented; public evidence limited
- What this does not prove
- A gateway governs only the calls routed through it. Tools reached with other credentials or by another path are outside its control, for Kong's gateway and for MCPGate alike.
- Publisher's chapter timestamps
- 5:59 Gateway identity perimeter · 8:17 MCP governance ladder · 23:25 Gateway authorization models
- CAIN evidence and documentation
- Where MCPGate sits in the request path · Try a blocked tool call in the MCPGate playground
-
SOURCE 05 OF 13 · CONFERENCE TALK
Trust Is the Next Bottleneck: Why the Agentic Economy Needs Confidential Computing
How it relates to CAIN-42: CAIN-42 shares the goal of substantiating execution claims with evidence that a relying party can check, instead of only recording an identity.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's abstract: agents can authenticate but cannot yet prove what actually ran. OAuth handles authorization, not runtime integrity; prompt-level governance shapes intent, not enforceable policy. The talk applies hardware attestation and measured execution to agent trust and names four gaps, including measured policy-as-code and portable attestation evidence.
- How this informs CAIN's roadmap
- CAIN-42 today produces software-signed, hash-chained records with offline verifiers. Hardware-backed attestation is on the roadmap: an appraisal engine exists in code, and no trusted-execution hardware is deployed. Planned
- What this does not prove
- Signed application records are not hardware attestation. CAIN-42 does not claim hardware-attested execution.
- CAIN evidence and documentation
- Offline verifiers
-
SOURCE 06 OF 13 · VENDOR PRODUCT PRESENTATION
The Authorization Gap: Securing Autonomous AI at Runtime
How it relates to CAIN-42: Per-action authorization during ongoing agent activity, rather than a one-time login check, is how CAIN-42 treats authority.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: the central question for AI security moves from "who are you?" to "what are you allowed to do right now?", answered by runtime authorization enforcement with policy-as-code and auditability for agents, machine identities and MCP tools.
- How CAIN applies this principle
- Each governed call is decided at the moment it is proposed. The proxy fails closed: a gate error, an unknown trust state or an unavailable replay store refuses the call. Implemented; public evidence limited
- What this does not prove
- Latency, scale and "immutable" audit figures in this video are the vendor's own claims about its own product. They are not repeated here and say nothing about CAIN-42.
- CAIN evidence and documentation
- Try a blocked tool call in the MCPGate playground
-
SOURCE 07 OF 13 · CONFERENCE TALK
Claude for Long-Horizon Tasks
How it relates to CAIN-42: Separating the reasoning model from the environment where actions run is where an authorization boundary naturally sits. The talk covers the harness; CAIN-42 covers who may act through it.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: lessons on building agent harnesses for reliable and secure long-horizon work, including decoupling the brain and hands, self-verification, self-learning, and designing harnesses that evolve.
- How CAIN applies this principle
- The CAIN AOS mission runtime journals each step, writes an execution intent before an effect, and requires independent verification before a mission is accepted. It is a reference implementation and is not deployed. Demonstration only
- What this does not prove
- Session persistence is not authorization enforcement, and this talk is about Anthropic's platform, not CAIN-42.
- CAIN evidence and documentation
- Agentic 75 governance map
-
SOURCE 08 OF 13 · WORKSHOP
Anthropic Workshop: Build Agents That Run for Hours
How it relates to CAIN-42: If an agent runs for hours, its permissions and stop controls have to stay meaningful for hours. The workshop's point that a producer should not grade itself matches CAIN-42's rule that a producer never verifies its own work.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: why self-evaluation is a trap and adversarial evaluator agents work better, why structured handoffs beat context compaction for coherence drift, decomposing work into testable contracts, and reading traces as the main debugging loop.
- How CAIN applies this principle
- In the CAIN workforce fabric a result is accepted only after a different agent re-checks it. Published endurance evidence is scoped: one continuous one-hour mission (252 of 252 tasks verified) and 1,018 aggregate worker-hours across concurrent workers. Implemented and publicly evidenced
- What this does not prove
- Hours of demonstrated operation in a workshop do not establish multi-day endurance, and CAIN-42 has not demonstrated a multi-day mission.
- Publisher's chapter timestamps
- 2:29 Challenges: context, planning and judgment · 17:28 State-of-the-art harness patterns · 25:04 The generator-evaluator contract
- CAIN evidence and documentation
- Evolution 81 workforce evidence bundle
-
SOURCE 09 OF 13 · CONFERENCE TALK
Your Old Prompts Are Making Claude Worse
How it relates to CAIN-42: Reliable autonomy is a system-engineering problem as well as a prompt-writing one. Prompts still matter; they guide the agent.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: auditing prompts for outdated habits, using the prompt cache, designing evals a model can climb, and how a managed-agent harness that separates brain from hands keeps days-long agents reliable and secure.
- How CAIN applies this principle
- CAIN-42 keeps security-critical authorization out of the prompt: a model, a memory or a plan may propose an action, and none of them can authorize one. Implemented; public evidence limited
- What this does not prove
- The talk does not say prompts are unnecessary, and neither does CAIN-42. Cost and benchmark figures in the talk are Anthropic's own.
- Publisher's chapter timestamps
- 1:32 Audit your prompts · 18:53 Harnesses for days-long agents · 20:21 Managed agents: separating brain from hands
- CAIN evidence and documentation
- Agentic 75 governance map
-
SOURCE 10 OF 13 · COURSE LESSON AND DEMONSTRATION
Multi-Agent Patterns: Agent Swarms
How it relates to CAIN-42: When leadership moves between agents, authority has to stay explicit at every handoff. That is the delegation problem CAIN-42 addresses.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: in a swarm, agents share a workspace, each with its own tools, prompt and specialization. They hand off to each other dynamically and no single agent is permanently in charge.
- How CAIN applies this principle
- In the CAIN workforce fabric a worker acts only under a signed grant attenuated from its mission, plus a single-use ticket for one task. A child cannot exceed its parent's envelope, and registering a worker grants nothing. Implemented and publicly evidenced
- What this does not prove
- Swarm coordination does not by itself demonstrate security, correctness or general intelligence.
- Publisher's chapter timestamps
- 1:30 Configuration and safety · 2:48 Execution and shared state
- CAIN evidence and documentation
- Evolution 81 workforce evidence bundle
-
SOURCE 11 OF 13 · PRODUCT DEMONSTRATION
Meet Kimi K2.6 Agent Swarm
How it relates to CAIN-42: Hundreds of sub-agents taking thousands of steps make bounded authority and per-agent attribution a practical necessity.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- A product demonstration of the Kimi K2.6 Agent Swarm. The publisher advertises up to 300 sub-agents and 4,000 coordinated steps; those are the publisher's figures.
- How CAIN applies this principle
- CAIN-42 has run 1,000 real worker processes on one host, each with its own generated Ed25519 identity and every result independently re-checked. Those workers ran deterministic tools, not model reasoning. Implemented and publicly evidenced
- What this does not prove
- Advertised scale is not evidence of reliability, and CAIN-42's worker count is not a claim about model intelligence.
- CAIN evidence and documentation
- Evolution 81 workforce evidence bundle
-
SOURCE 12 OF 13 · VENDOR PRESENTATION
Visa Intelligent Commerce: Building Trust for the Future of Agentic Commerce
How it relates to CAIN-42: An agent being able to start a payment is different from holding authority to make it. That is the capability-versus-authority distinction applied to money.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: as agents search, compare and transact for consumers, trust has to come first. Consumers need confidence the agent stays within their instructions; merchants and issuers need visibility into intent, identity and authorization; consumer control is preserved through clear authorization and secure credential handling.
- How CAIN applies this principle
- CAIN-42 ships wallet-mandate and checkout-mandate review engines that check a supplied mandate record against published rules and sign the result. Implemented; public evidence limited
- What this does not prove
- CAIN-42 has no integration, approval or partnership with Visa, and its mandate engines review records; they do not process payments.
- CAIN evidence and documentation
- Agentic 75 product engines
-
SOURCE 13 OF 13 · KEYNOTE HIGHLIGHTS
Jensen Huang's Keynote Highlights at NVIDIA GTC Berlin 2026
How it relates to CAIN-42: Execution governance is one component of a much larger agent stack that runs from chips to robots.
What it explains, how CAIN applies it, and what it does not prove
- What the source explains
- Per the publisher's description: how AI factories are evolving to run agents and why physical AI is the next frontier, with announcements across AI infrastructure, safe agents, open models, enterprise AI, healthcare, mobility and robotics.
- How this informs CAIN's roadmap
- CAIN-42's physical-systems work is simulation only. No hardware is governed today, and physical deployment is on the roadmap. Planned
- What this does not prove
- A keynote vision does not establish CAIN-42's suitability for safety-critical physical deployment.
- CAIN evidence and documentation
- Agentic 75 governance map
What these sources do, and do not, establish
They do establish
- That identity providers, gateway vendors, model developers, cloud platforms, payment networks and open-source foundations are publicly treating agent authorization, attribution, revocation and evidence as engineering requirements.
- That separating the reasoning model from the place where actions execute is a mainstream design for long-running agents.
- That swarms of specialized agents are a shipping pattern, which makes delegated authority a live problem.
They do not establish
- That any of these organizations has reviewed, endorsed, partnered with or integrated CAIN-42.
- That CAIN-42 was developed in response to these talks, or that CAIN-42 meets any vendor's stated performance.
- That any system here has passed an independent audit or is safe for every deployment. Vendor presentations are not peer-reviewed research.
2027–2028 outlook: thousands of governed agents, with a kill switch
The goal FIRME AI CORPORATION is building CAIN-42 toward: thousands of specialized AI agents working for thousands of hours across many different fields, every action authorized before it runs, every result backed by evidence, and one kill switch that sits outside the model. Governed swarms of specialists, one vertical at a time, are our path to that.
This is a goal and an outlook, not a forecast presented as fact. If agents become more persistent, more interconnected and more economically consequential, their authority will need to remain explicit and enforceable throughout their operation. CAIN-42 is being developed around that requirement.
Where that path stands today, measured
- 1,000 real worker processes on one host, each with its own signed identity, every result independently re-checked.
- 1,018 aggregate worker-hours across concurrent workers. That is a sum over workers, not continuous elapsed runtime; the longest single continuous mission is one hour.
- 12 fields in one mission, with every result re-checked by an agent from a different field. Those tasks were deterministic text operations, not model reasoning.
- Fleet quarantine that stops further governed actions by one agent or a whole swarm. It stops what comes next; it cannot reverse what is already done.
- Next: the same controls held across more hosts, multi-day missions and model-backed specialists.
CAIN-42 does not claim general intelligence, and nothing here predicts when or whether it arrives. The claim is narrower: whatever agents become capable of, their authority should be granted, bounded and revocable from outside the model.
CAIN evidence and documentation
- Evidence registry
- MCPGate live playground
- Evolution 81 evidence (current)
- Offline verifiers
- Published incidents
- Agentic 75 governance map
Source review date: 2026-11-15. For each of the 13 sources the link, title, channel, publication date and publisher's description were checked on that date, and timestamps are the publisher's own chapter markers. Summaries restate the publisher's description; they are not transcripts or quotations. CAIN-42 evidence is produced and hosted by FIRME AI CORPORATION and has not been audited by a third party.
THE 2027 STANDARD · CAIN-42 AGENTIC 75
The 2027 standard for agentic autonomy
The integration of the CAIN-42 Agentic 75 suite is a foundational shift for autonomous AI: away from probabilistic prompt-layer suggestions and toward deterministic, zero-trust execution governance. As multi-agent systems and autonomous swarms scale into production through 2027, prompt-based alignment and conversational guardrails have repeatedly proven insufficient. The Agentic 75 architecture shifts control from the model’s intent to the system’s physical and computational execution boundaries.
1. Execution-Layer Governance Over Probabilistic Prompt Filters
Traditional AI safety operates almost entirely in the conversation channel, parsing natural-language instructions and trying to filter malicious tokens before the model processes them. Autonomous agents do not merely converse: they invoke tools, write files, run shell commands, modify databases and transfer capital through protocols such as the Model Context Protocol (MCP).
- The paradigm shift: CAIN-42 intercepts governed requests at the execution boundary before the side effect occurs. Calls that bypass the boundary are not governed by it; that limit is stated openly.
- Mechanism: every governed tool call routed through the boundary is evaluated against authorization boundaries, structural schemas and policy rules. If an action lacks verified permission it is blocked before execution. Unknown or errored states default to denial rather than model judgment.
2. Proof-Carrying Software and Tamper-Evident WORM Auditing
Verifying that an autonomous agent behaved correctly during a multi-hour or multi-day coding session should not require trusting verbose logs or post-hoc summaries.
- The paradigm shift: the Agentic 75 introduces proof-carrying development and operation. CAIN LongProof, CAIN LoopTrace and the Tamper-Evident WORM Evidence Notary generate tamper-evident, hash-chained records with Ed25519 signatures and SHA-256/RFC 6962 Merkle roots.
- Mechanism: governed actions, decisions and state changes produce cryptographically verifiable artifacts that anyone can re-run and verify offline without importing CAIN code. The record proves integrity and binding to the supplied evidence; it does not prove the evidence is complete or true. The design is intended to support EU AI Act record-keeping under Articles 12, 19, 26(6) and 73(6). No notified body has reviewed CAIN and no certification is claimed.
3. Byzantine-Resilient Quorum Co-Signing
Single-server logging architectures remain vulnerable to administrative tampering, compromised internal endpoints and silent state overwrites.
- The paradigm shift: CAIN-42 can have governed records ordered and co-signed by a multi-region Practical Byzantine Fault Tolerance (PBFT) cluster: N=4, f=1, Q=3, across four Vultr regions under one account. That is geographic separation, not provider or administrative independence.
- Mechanism: hosted decisions are evaluated and co-signed by a 3-of-4 quorum. The consensus layer orders and co-signs; it cannot override a denial or manufacture permission. A compromised replica cannot silently change a quorum record — this is tamper-evident assurance, not an absolute guarantee against every hostile deployment. The quorum is operated by FIRME AI CORPORATION, not an independent witness network.
4. Granular Runtime Cages and Rapid Swarm Containment
Autonomous agent swarms running in parallel create catastrophic blast radiuses if a loop goes rogue, hallucinates destructive arguments or is steered by prompt injection.
- The paradigm shift: the Agentic 75 provides fine-grained runtime isolation combined with fleet-wide emergency circuit breakers.
- Mechanism: tools are wrapped in execution boundaries such as CAIN RuntimeCage and the MCPGate Boundary Appliance. Cross-process SQLite WAL synchronization shares revocation state, and the local containment path is measured and reported with its tests. We do not claim an unmeasured global sub-50ms guarantee or instantaneous cross-region revocation; distributed propagation is a separate, measured question.
5. Deterministic Defect Detection and Automated Verification
AI-written code has a familiar failure mode: uncomputed results, hard-coded success claims and security checks written to return unconditional approval.
- The paradigm shift: deterministic static analysis (FALSEWORK) alongside KEYSTONE and PROOFLOOP requires evidence, not confidence, before a fix is accepted.
- Mechanism: a patch proposed by an AI coding agent is validated only when an independent test suite fails on the vulnerable code, passes on the patched code inside a locked sandbox, and clears structural safety re-scans. This produces verifiable evidence about that test and that patch; it is not a proof of general correctness, and FALSEWORK is heuristic — determinism is not correctness.
NO VERIFIED IDENTITY → NO VALID AUTHORITY → NO GOVERNED EXECUTION.
Summary: The 2027 Standard for Agentic Autonomy
The CAIN-42 Agentic 75 architecture redefines AI agents by proving that capability does not equal authority. By combining zero-trust execution gating, Byzantine quorum co-signing, offline-verifiable evidence and independent test validation, it turns autonomous agents from unpredictable experiments into accountable, auditable systems.
It does not turn every engine into a certified production control. The claim is narrower and testable: show the record, and let anyone re-check it.
What is verified today
- 75 of 75 Agentic products are DELIVERABLE, each with published rules and a live try-it.
- All 75 signed samples re-verify offline with their own pinned key.
- 2,598 Agentic 75 tests pass; the catalog selftest is 75/75.
- The public evidence bundle is on clawx.click, with a verifier that imports no CAIN code.
What is not claimed
- Not a production assessment for every engine: several are static, heuristic or simulation-only, and say so.
- Not universal enforcement: only calls routed through the declared boundary are governed.
- Not a global real-time revocation guarantee, hardware-attested identity, or independent certification.
- No SOC 2, ISO 42001, EU AI Act certification or third-party audit.
- The validator quorum is vendor-operated, not an independent witness network.
The model is a commodity. The closing loop is the moat: detect → act → prove → sign → verify offline. Built by FIRME AI CORPORATION — Vicente Fernando Noriega (founder) and his two co-founders.
AGENTIC 75 · PRODUCT EVIDENCE
75 productised offers. 75 engine-backed and verified today. Every status published.
LIVE IN PRODUCTION: 75 OF 75 · NEWEST: #75 OF THE TOP 75
CAIN-A75-075 · Delegation Measurement Review · Observational evidence of larger task delegation · Signed evidence
Also live: CAIN-A75-071 · CAIN-A75-074 · CAIN-A75-073
All 75 live Agentic 75 products and their evidence (newest first)
| # | SKU | Product · the 2026 development | Engine | Evidence · verify it |
|---|---|---|---|---|
| 75 | CAIN-A75-075 | Delegation Measurement ReviewTop-75 #75: Observational evidence of larger task delegation | cain_a75_engines/delegation/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 74 | CAIN-A75-071 | Proactive Agent Lease ReviewTop-75 #71: Proactive personal assistants | cain_a75_engines/proactive/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 73 | CAIN-A75-074 | Mobile Expansion ReviewTop-75 #74: Broader international mobile-agent deployment | cain_a75_engines/mobileexpansion/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 72 | CAIN-A75-073 | Industrial Knowledge ReviewTop-75 #73: Industrial expertise captured as agents | cain_a75_engines/procedure/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 71 | CAIN-A75-070 | Brand Agent ReviewTop-75 #70: Retailer-controlled agents in search | cain_a75_engines/brandagent/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 70 | CAIN-A75-069 | Interop Authority ReviewTop-75 #69: Agentic advertising interoperability standards | cain_a75_engines/interop/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 69 | CAIN-A75-068 | Third-Party Agent ReviewTop-75 #68: Bring-your-own-agent advertising | cain_a75_engines/byoagent/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 68 | CAIN-A75-067 | Campaign Authority ReviewTop-75 #67: Agent-to-agent advertising execution | cain_a75_engines/campaign/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 67 | CAIN-A75-066 | Browser Errand ReviewTop-75 #66: Mobile browser agents for real-world errands | cain_a75_engines/errand/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 66 | CAIN-A75-065 | Mobile Data Boundary ReviewTop-75 #65: Work–personal data separation for mobile agents | cain_a75_engines/mobileboundary/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 65 | CAIN-A75-064 | Agent Inventory ReviewTop-75 #64: Enterprise agent inventory and cost accountability | cain_a75_engines/agentinventory/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 64 | CAIN-A75-063 | Chat Approval ReviewTop-75 #63: Agent permission review inside collaboration tools | cain_a75_engines/chatapproval/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 63 | CAIN-A75-062 | Local Agent Containment ReviewTop-75 #62: Local AI coding on personal computers | cain_a75_engines/localagent/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 62 | CAIN-A75-061 | Domain Model Authority ReviewTop-75 #61: CRM-specialised reasoning models | cain_a75_engines/domainmodel/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 61 | CAIN-A75-059 | Browser Agent Control ReviewTop-75 #59: More efficient browser representations and action loops | cain_a75_engines/browserbatch/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 60 | CAIN-A75-058 | Framework Evaluation ReviewTop-75 #58: Repeated-run comparisons of agent frameworks | cain_a75_engines/frameworkeval/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 59 | CAIN-A75-056 | Benchmark Evidence ReviewTop-75 #56: Visually complex knowledge-work evaluation | cain_a75_engines/benchevidence/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 58 | CAIN-A75-055 | Memory Evaluation ReviewTop-75 #55: Multi-session memory evaluation | cain_a75_engines/memeval/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 57 | CAIN-A75-054 | Deployment Trace EvaluationTop-75 #54: Deployment-driven agent benchmarks | cain_a75_engines/tracebench/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 56 | CAIN-A75-053 | Consumer Agent Authority ReviewTop-75 #53: Consumer agents connected to real services | cain_a75_engines/consumeragent/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 55 | CAIN-A75-052 | Agent-to-Agent Deal ReviewTop-75 #52: Controlled agent-to-agent commerce experiments | cain_a75_engines/a2adeal/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 54 | CAIN-A75-051 | Agent Identity ReviewTop-75 #51: Know Your Agent identity intelligence | cain_a75_engines/agentidentity/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 53 | CAIN-A75-050 | Agent Interaction Risk ReviewTop-75 #50: Banking detection of agent activity | cain_a75_engines/agentrisk/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 52 | CAIN-A75-047 | Commerce Protocol Authority ReviewTop-75 #47: Universal commerce protocol | cain_a75_engines/commerceauthority/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 51 | CAIN-A75-046 | Ontology & Policy ReviewTop-75 #46: Business ontologies for regulated-industry agents | cain_a75_engines/ontologypolicy/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 50 | CAIN-A75-045 | Approval-Gated Remediation ReviewTop-75 #45: IT investigation with approval-gated remediation | cain_a75_engines/remediationgate/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 49 | CAIN-A75-044 | Contract Evidence ReviewTop-75 #44: Evidence-based construction change orders | cain_a75_engines/contractevidence/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 48 | CAIN-A75-043 | Physical Schedule Assurance ReviewTop-75 #43: Agentic construction scheduling | cain_a75_engines/constructionschedule/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 47 | CAIN-A75-042 | Background Agent Lease ReviewTop-75 #42: Continuous creative-production agents | cain_a75_engines/backgroundlease/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 46 | CAIN-A75-041 | Creative Workflow ProvenanceTop-75 #41: Multistep creative agents | cain_a75_engines/creativeprov/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 45 | CAIN-A75-039 | Fast-Path Authority ReviewTop-75 #39: Faster models for collaborative subagents | cain_a75_engines/fastpath/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 44 | CAIN-A75-038 | Parallel Agent Run ReviewTop-75 #38: Multi-agent desktop supervision | cain_a75_engines/parallelruns/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 43 | CAIN-A75-037 | Enterprise Execution GovernanceTop-75 #37: Enterprise agent execution with governance | cain_a75_engines/executiongov/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 42 | CAIN-A75-036 | Threat Investigation Evidence ReviewTop-75 #36: Evidence-grounded threat investigation | cain_a75_engines/threatevidence/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 41 | CAIN-A75-035 | Real-Time Agent Gate ReviewTop-75 #35: Voice agents that reason while listening | cain_a75_engines/realtimegate/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 40 | CAIN-A75-034 | Regulated Workflow Evidence ReviewTop-75 #34: Clinical-trial oversight agents | cain_a75_engines/regulatedevidence/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 39 | CAIN-A75-032 | Research Retrieval ProvenanceTop-75 #32: Agent-assisted search through biological archives | cain_a75_engines/retrievalprov/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 38 | CAIN-A75-031 | Context Graph ReviewTop-75 #31: Shared organisational context graphs | cain_a75_engines/contextgraph/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 37 | CAIN-A75-029 | Personal Context ReviewTop-75 #29: Personal context connected to mobile actions | cain_a75_engines/personalcontext/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 36 | CAIN-A75-028 | Mobile Agent Action ReviewTop-75 #28: Cross-application mobile task execution | cain_a75_engines/mobilegate/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 35 | CAIN-A75-027 | Agent Lease ReviewTop-75 #27: Always-on workplace teammates | cain_a75_engines/agentlease/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 34 | CAIN-A75-025 | Fleet Governance Design ReviewTop-75 #25: Reported orchestration of 10,000 concurrent agents | cain_a75_engines/fleetdesign/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 33 | CAIN-A75-024 | Coding-Agent Action GateTop-75 #24: Coding agents inside native development tools | cain_a75_engines/codinggate/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 32 | CAIN-A75-020 | OS Containment ReviewTop-75 #20: Operating-system-enforced agent containment | cain_a75_engines/oscontainment/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 31 | CAIN-A75-019 | Runtime Containment AuditTop-75 #19: Runtime agent quarantine | cain_a75_engines/runtimecontainment/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 30 | CAIN-A75-018 | Enterprise Agent Governance ReviewTop-75 #18: Full-stack agent safety infrastructure | cain_a75_engines/enterprisegov/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 29 | CAIN-A75-016 | Memory Consolidation ReviewTop-75 #16: Offline memory consolidation (dreaming) | cain_a75_engines/memoryconsolidation/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 28 | CAIN-A75-015 | Context Integrity ReviewTop-75 #15: Retained reasoning and context compaction | cain_a75_engines/contextcompaction/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 27 | CAIN-A75-013 | Multi-Model Orchestration ReviewTop-75 #13: Multi-model workflow orchestration | cain_a75_engines/modelorchestration/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 26 | CAIN-A75-012 | Research Evidence ReviewTop-75 #12: Experimentally validated biological binder discovery | cain_a75_engines/binderevidence/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 25 | CAIN-A75-011 | Formal Artifact ReviewTop-75 #11: Self-supervised theorem discovery | cain_a75_engines/formalartifact/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 24 | CAIN-A75-010 | Failure-Driven Improvement AuditTop-75 #10: Failure-driven agent improvement | cain_a75_engines/failurefix/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 23 | CAIN-A75-009 | Autonomous R&D Change ReviewTop-75 #9: End-to-end autonomous R&D loops | cain_a75_engines/rndchange/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 22 | CAIN-A75-008 | Robotics Release Gate ReviewTop-75 #8: Robot programming through agent teams | cain_a75_engines/roboticsgate/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 21 | CAIN-A75-007 | Physical Action Twin ReviewTop-75 #7: Digital twins for safe physical agent actions | cain_a75_engines/physicaltwin/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 20 | CAIN-A75-005 | Research Provenance ReviewTop-75 #5: Open-world multi-agent mathematical discovery | cain_a75_engines/researchgraph/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 19 | CAIN-A75-004 | Proof-Carrying Change ReviewTop-75 #4: Machine-checkable security proofs | cain_a75_engines/proofreview/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 18 | CAIN-A75-003 | Discovery Loop Evidence ReviewTop-75 #3: Closed-loop experimental discovery | cain_a75_engines/discoveryloop/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 17 | CAIN-A75-002 | Physical Autonomy Assurance ReviewTop-75 #2: Agent-operated molecular-biology laboratories | cain_a75_engines/labpreflight/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 16 | CAIN-A75-072 | Saved Workflow ReviewTop-75 #72: Reusable user-defined workflow skills | cain_a75_engines/savedworkflow/engine.py | selftest manifestpython3 verify_agentic75.py |
| 15 | CAIN-A75-060 | Research Toolchain ReviewTop-75 #60: Composable web-research toolchains | cain_a75_engines/researchtool/engine.py | selftest manifestpython3 verify_agentic75.py |
| 14 | CAIN-A75-057 | Commerce Refusal ReviewTop-75 #57: Shopping benchmarks that reward refusing bad purchases | cain_a75_engines/commercerefusal/engine.py | selftest manifestpython3 verify_agentic75.py |
| 13 | CAIN-A75-049 | Web Tool Definition ReviewTop-75 #49: Structured website actions through WebMCP | cain_a75_engines/webtool/engine.py | selftest manifestpython3 verify_agentic75.py |
| 12 | CAIN-A75-048 | Agent Checkout Mandate ReviewTop-75 #48: Browser payments without exposing card details | cain_a75_engines/checkoutmandate/engine.py | selftest manifestpython3 verify_agentic75.py |
| 11 | CAIN-A75-040 | Creative Tool Boundary ReviewTop-75 #40: Native creative-project editing through MCP | cain_a75_engines/creativetool/engine.py | selftest manifestpython3 verify_agentic75.py |
| 10 | CAIN-A75-033 | Clinical Tool Boundary ReviewTop-75 #33: Pathology agents as interoperable MCP tools | cain_a75_engines/clinictool/engine.py | selftest manifestpython3 verify_agentic75.py |
| 9 | CAIN-A75-030 | Business-System Connector ReviewTop-75 #30: Agent communication across business systems | cain_a75_engines/bizconnector/engine.py | selftest manifestpython3 verify_agentic75.py |
| 8 | CAIN-A75-026 | Signed Deliverable PackTop-75 #26: Finished knowledge-work deliverables | cain_a75_engines/wormevidence/engine.py | selftest manifestpython3 verify_agentic75.py |
| 7 | CAIN-A75-023 | Vulnerability-to-Patch ProofTop-75 #23: Autonomous vulnerability investigation and repair | cain_a75_engines/vulnpatch/engine.py | selftest manifestpython3 verify_agentic75.py |
| 6 | CAIN-A75-022 | Agent Wallet Mandate ReviewTop-75 #22: Bounded agent identities and wallets | cain_a75_engines/walletmandate/engine.py | selftest manifestpython3 verify_agentic75.py |
| 5 | CAIN-A75-021 | Agent Credential ReviewTop-75 #21: Task-scoped, short-lived agent credentials | cain_a75_engines/credentialreview/engine.py | selftest manifestpython3 verify_agentic75.py |
| 4 | CAIN-A75-017 | Portable Skill ReviewTop-75 #17: Agent skills as a portable ecosystem standard | cain_a75_engines/skillreview/engine.py | selftest manifestpython3 verify_agentic75.py |
| 3 | CAIN-A75-014 | Memory Authority AuditTop-75 #14: Persistent, correction-aware agent memory | cain_a75_engines/memoryauthority/engine.py | selftest manifestpython3 verify_agentic75.py |
| 2 | CAIN-A75-006 | Swarm Delegation AuditTop-75 #6: Single-prompt coordination of specialised agent teams | cain_a75_engines/swarmdelegation/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
| 1 | CAIN-A75-001 | Long-Run Engineering AttestationTop-75 #1: Full-day autonomous software engineering | cain_a75_engines/longrun/engine.py | signed sample + verify_offline.pypython3 verify_offline.py run.json --pinned-key "$(cat public_key.txt)" |
Bundle: /evidence/agentic-75-products-2026-11-12/ · SELFTEST.json · verify_agentic75.py (no CAIN import).
The Agentic 75 turns the 75 most significant 2026 agentic-AI developments into fixed-scope CAIN-42 products and services. 21 of them run a real engine in the CAIN-42 repository and produced a manifest that re-verified. The other 0 are labelled honestly: 0 pilot, 0 advisory, 0 design. Nothing here calls a pilot a finished product.
That all 75 engine-backed SKUs ran on fixed samples and their SHA-256 manifests match the delivered files, and that every one of the 75 offers has a published status, scope and limit. Re-run verify_agentic75.py yourself; it imports no CAIN code.
That the 0 non-engine offers are finished engines, that a customer ran any of this, or that the manifests are signed. They are integrity records, not attestations. No vendor partnership or third-party audit is claimed.
Open the evidence bundle · verify_agentic75.py · CATALOG.json · SELFTEST.json · try-it RESULTS.json (live route + browser run on all four surfaces)
Use the catalog on cainstudio.online/agentic-products, the developer home on mcpgate.online/agentic-75, and the CAIN-42 Hugging Face Space. The governance map for all 75 developments is cainstudio.online/agentic-75.
Auditor console: CAIN-42 in production, live
Everything in this console comes from the production system, live. Your browser reads the two validator clusters directly through this site, downloads real quorum certificates and checks every validator signature itself, triggers real decisions, and tries to forge certificates to show that the checks catch it. Every result is added to an audit log you can download. Labels say which results your browser verified and which a CAIN server reported.
That the certificates you verify were signed by at least 3 of the 4 member keys pinned in the signed proof index, that the gateway made the decision you sent, and that the seven forgeries are rejected.
Independence: all validator nodes are run by FIRME AI CORPORATION (vendor-operated). The PBFT quorum tolerates one faulty node, but it cannot vouch for an operator who controls every node. Cluster health is reported by the gateway.
cain-mr-02 · retired 2026-11-15 after a safety finding · history kept, not a live anchor
cain-mr-01 · vendor-operated
Verify any quorum certificate yourself
Try to forge a certificate (tamper lab)
Takes the last certificate your browser verified and makes seven forgeries: a forged signature, too few signers, COMMIT votes relabelled as PREPARE, a different decision, a cross-cluster replay, a cross-view replay, and a vote edited after signing. Every one must be rejected. If any is accepted, the checks are worthless, and this panel says so.
Make a real decision in production
POST /fabric/try) on a throwaway tenant with enforcement on. It returns the verdict, every pipeline stage and the stored record's digest. The record's integrity is reported by the gateway, not verified by your browser.Published keys vs pinned keys
Every day since the first proof (24/7 record)
One cell per UTC day for each cluster, built from every proof in the signed proof index. The color is the share of proofs that day whose verdict was OPERATIONAL. A gray cell means no proof was written that day. Gaps and failures are shown, not hidden.
Live evidence timeline
- waiting for the first refresh…
Anchored outside CAIN: Sigstore Rekor
Verify your own evidence (customers)
Your decision records are private to your tenant, so this panel opens only with your CAIN-42 API key. A free key takes a minute, and no card is needed. The key stays in this browser tab's memory. It is sent only to this site's gateway, in the X-API-Key header, and it is forgotten when you lock the panel or close the tab.
Want this evidence for your own agents? CAIN-42 records, signs and anchors every decision your agents make, and this page lets you verify it any time. Start free · Plans · Quickstart
Your agents
Every agent in your tenant, with decision counts and verdicts from the gateway. Decisions load 200 at a time, and Load all my decisions pages through your entire history. Show filters the table below, and Verify all checks every record of that agent in your browser.
Your decision records
For each record your browser downloads the record exactly as stored and signed (/fabric/decisions/<id>/signed-record) and runs the four checks of the published verify_decision_record.py. ENCODING: no field can be re-split. DIGEST: SHA-256 recomputed here from the record's own fields. KEY: the key ID matches the published decision-signing key. SIGNATURE: the Ed25519 signature verifies. A changed verdict fails DIGEST, and a changed verdict with a recomputed digest fails SIGNATURE. Signed record downloads the file, so you can run the verifier offline as well.
Look up one decision
One agent run, step by step
Check an evidence bundle you received (evidence.zip)
Choose the evidence.zip from an audit, review or PROOFLOOP run. It is unpacked and checked inside your browser and never uploaded. The checks are the same as the bundle's own verify_keystone.py: every record's SHA-256 content hash, every Ed25519 signature against the issuer key (copy here, original at cainstudio.online/keystone/public-key), the chain links, each artifact digest, that report.md and findings.json match the signed record, that the signed head lists exactly these records in order, and the manifest hashes.
Verification run (in this browser, now)
Each line below is computed on this page from the published files. Nothing is cached server-side and nothing comes from a stored result. Reload the page to run it again.
| # | Check | Result | Detail |
|---|---|---|---|
| Running… | |||
Hash-chained cluster proofs
Each validator cluster writes a proof about every 30 minutes. Every proof carries the SHA-256 of the one before it and is signed by the evidence-root key. Below are the 24 most recent proofs of each cluster. Your browser re-hashes each one, checks its signature and checks the link to the proof before it. Select a block to open the raw file.
That each recent proof is intact, signed by the evidence-root key and linked to the one before it.
That the proofs' measurements are correct. The evidence-root key belongs to the vendor, so independence comes from the outside anchors (Rekor, timestamp authorities) and from witnesses.
cain-mr-01
cain-mr-02 · retired 2026-11-15 · proof history kept
etcd coordination cluster: live verification
A three-member etcd cluster (Atlanta, Los Angeles, Miami). Every minute, our server makes the four read-only requests that the published verifier makes, through the same public endpoint any auditor uses, and publishes the raw responses at etcd-live.json. Your browser then re-runs the verifier's five checks against the signed 2026-10-15 capture. The responses are fetched by our server, so for a check that doesn't depend on us, run the command below yourself.
Checks re-run in this browser
Members (live)
Last 2 hours (one block per minute)
Run it yourself:
Transparency log, outside timestamps and witnesses
The proof chains are also published as an append-only Merkle-tree transparency log in the same form as Certificate Transparency and the Go checksum database: RFC 6962 trees with C2SP signed-note checkpoints. Every new checkpoint is also timestamped by two outside RFC 3161 timestamp authorities, FreeTSA and DigiCert, which receive only its SHA-256. Your browser checks the log signature, recomputes the Merkle root from the signed proofs, checks that every earlier checkpoint is still a prefix of the tree, and finds the checkpoint hash inside each timestamp token.
That the published proofs form one append-only sequence: no proof was removed, changed or reordered after a checkpoint was issued. It also shows that each checkpoint existed by the time two independent timestamp authorities stamped it.
That what the proofs say is true. A log proves that entries were registered, not that their content is correct. Until an independent witness cosigns, a log operator who showed different visitors different histories would be caught only by visitors who compare checkpoints. The log key is held by FIRME AI CORPORATION.
cain-mr-02 log · retired 2026-11-15, history kept
cain-mr-01 log
Watch this log yourself, 24/7 (independent monitor)
Don't trust this page: run the monitor on your own machine or in your own CI. It imports no CAIN code, keeps its own copy of every checkpoint it sees, and on every run re-checks each checkpoint's signature against the key you pinned, recomputes the Merkle root, checks that every earlier tree is still a prefix, and checks that no earlier proof changed. It prints ALARM and exits 2 on a fork, a rewrite or a bad signature. Two monitors that compare their saved checkpoints can also catch a log that shows different visitors different histories.
pip install cryptography curl -fsSLO https://clawx.click/evidence/tlog/verify_tlog_monitor.py.txt && mv verify_tlog_monitor.py.txt verify_tlog_monitor.py python3 -I verify_tlog_monitor.py --state ~/.clawx-monitor --vkey "$(curl -fsS https://clawx.click/evidence/tlog/vkey.txt)" # then hourly (cron): 17 * * * * python3 -I verify_tlog_monitor.py --state ~/.clawx-monitor
verify_tlog_monitor.py · GitHub Actions workflow (runs it hourly in your own repository) · log verifier key:
Want to cosign as a witness? Witness operators can contact firmeai2026@gmail.com. Cosignatures will be shown here and counted in each checkpoint.
Incident history and availability
When each vendor-operated validator cluster was not operational, according to its own signed proofs, and its availability over 7, 30 and 90 days.
Anything between two proofs (about 30 minutes apart), or the availability of the customer-facing gateway, which is tracked under Monitors.
Signed claims register
Every public claim CAIN-42 makes, with its status, limits, pinned artifacts and the command that re-checks it. Source: cain42-evidence-index.json (Ed25519-signed) and CAIN42_FINAL_PUBLIC_CLAIMS.json. Re-hash downloads each pinned artifact and compares its SHA-256 with the signed value. The status vocabulary is VERIFIED, TESTED, BENCHMARKED, SIMULATED, UNVERIFIED, FAILED and NOT_IMPLEMENTED. A feature that is not implemented is listed as not implemented, not left out.
| Claim | Status | Level | Statement · limits | Artifacts | Re-check |
|---|---|---|---|---|---|
| Loading… | |||||
Production gates
The gate table from the signed evidence index. Each row gives the requirement, its status, the evidence and its limits. Gates A to O are the 15 production gates, and the totals above show how many of 15 pass. Gates P to X are the further gates. Open gates are listed with their real status.
| Gate | Requirement | Status | Evidence and limits |
|---|---|---|---|
| Loading… | |||
All evidence bundles
Every directory and document served under /evidence/, with nothing left out. Source: evidence-catalog.json, an unsigned listing rebuilt from the served files. Files lists every file with its SHA-256. Re-hash downloads the files and compares them: files pinned by a signed claim are compared with the signed hash, and all other files with the listing.
| Bundle | Date | Files | Size | Signed claims | Open | |
|---|---|---|---|---|---|---|
| Loading… | ||||||
Monitors
FALSEWORK self-scan of the CAIN-42 codebase (every 42 s)
Source: keystone-codebase-scan-live.json
Open to every independent third-party auditor
What any auditor can do here, no account needed
- Download every evidence file: /evidence/, with a SHA-256 for each one in evidence-catalog-files.json.
- Read the source of every verifier. Each one is published next to its evidence as a
.py.txtfile, and none imports CAIN code. - Use the open-source releases (Apache-2.0, signed checksums): FALSEWORK, PROOFLOOP and their verifiers.
- Get the auditor kit: IHVRK evidence kit, the Verification Center and the verify_all.py source.
- Check the signing key: one Ed25519 evidence-root key, published at evidence-root.pub.json and on both other sites.
- Check outside our servers: the proof ledger is anchored in the public Sigstore Rekor log (anchors).
- Report a discrepancy: security reporting or email. Corrections are published as new, superseding evidence. Old evidence is never deleted.
How this registry stays unbiased
- Every status on this page is copied from a signed or published file. None is typed into the page, so FAILED, SIMULATED, UNVERIFIED and NOT_IMPLEMENTED appear exactly as recorded.
- Every check that runs here can come out FAIL. A check that cannot run shows NOT CHECKED, never PASS.
- This page is served by us, so it does not replace your own check. Run the offline verifiers below on your own machine.
- No independent third-party audit has been completed yet. Every result here was produced by CAIN-42 itself, and this registry exists so that an outside auditor can repeat each check.
Known limitations, as published
Verify offline, without this page
This page runs inside our own site, so the strongest check is one you run yourself. These verifiers import no CAIN code.
| What it checks | Command |
|---|---|
| Evidence-root key identical on all 3 sites; evidence index and claims register re-hash and verify | curl -so verify_all.py https://clawx.click/verify_all.py.txt && python3 verify_all.py |
| Signed claims register (every claim, every pinned artifact) | curl -so verify_claims.py https://clawx.click/evidence/claims/verify_claims.py.txt && python3 verify_claims.py https://clawx.click/evidence/claims/CAIN42_FINAL_PUBLIC_CLAIMS.json |
| Whole hash chain of cluster proofs from genesis, with every quorum certificate | curl -so verify_hourly_proofs.py https://clawx.click/evidence/hourly-proof/verify_hourly_proofs.py.txt && python3 verify_hourly_proofs.py https://clawx.click/evidence/hourly-proof/ |
Verification Center · Browse /evidence/ · Sigstore Rekor anchors · Daily evidence · Changelog · Previous homepage · Auditor pack · auditor.json
Integrations
Keep your control plane. Add the receipt.
CAIN-42 plugs into the consoles you already own. Splunk, Prisma, Zenity and Microsoft keep the control plane; CAIN supplies the signed, offline-verifiable record their dashboards cannot hand an auditor.
Connectors · Proof Standard · Pricing and Proof SLA · Evidence bundle