A real mission has been running for 12.00 hours — 2142 research cycles, 2136 useful, 214 signed checkpoints
External long-horizon rank: UNRANKED. No external METR-style time-horizon evaluation has been run for CAIN, so a top-10 position cannot be claimed. The measured local run is reported instead.
Why this is evidence and not a badge: every cycle does a capability induction on a never-seen task family, records the raw outcome, and appends a SHA-256 hash-chained journal record; a corrupted chain or memory digest makes the mission refuse to resume (exercised). A running daemon is not a completed mission — completion requires 43,200 real seconds, and the panel reports the wall clock it actually has. AGI status: NOT ACHIEVED.
Open the live lab → · mission JSON · SWE-bench board · evidence bundle
$ mcpgate --policy "no authorization, no execution"
The authorization boundary for MCP tool calls.
MCPGate sits between your AI agent and the MCP servers it calls. Every tools/call is stopped at the boundary. It goes through only when CAIN-42's validator quorum has committed an authorization bound to that exact call: the tool, the arguments, the scope, the identity, the security context and an expiry, usable once. Anything unknown, malformed or unauthorized gets a JSON-RPC error and never reaches your server.
# the agent asks for a tool call → {"jsonrpc":"2.0","id":7,"method":"tools/call","params":{"name":"send_payment","arguments":{"to":"acct-991","amount":25000}}} # MCPGate: no quorum-committed authorization for this exact call, so it never reaches the server ← {"jsonrpc":"2.0","id":7,"error":{"code":-32000, "message":"CAIN Frontier Gate DENIED execution of 'send_payment': …", "data":{"decision":"DENY","action":"send_payment","enforcement":"BLOCKED_AT_BOUNDARY","evidence_hash":"…"}}}
The error format is the one in the proxy's code (SECURITY_DENIAL = -32000, enforcement: BLOCKED_AT_BOUNDARY). Malformed requests get -32600.
The architectural case
More capable agents. Explicit authority. Verifiable evidence.
An instruction is not an enforcement boundary.
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.
MCPGate sits in the request path between the agent and the MCP server: agent, then MCPGate, then server. It reads each JSON-RPC tools/call, checks the tool and its arguments against a scoped, expiring, single-use authorization, and forwards the call only on ALLOW. Anything unknown, malformed or unauthorized is answered with a JSON-RPC error and never reaches the server; if the gate itself errors, the call is refused. The boundary covers calls routed through MCPGate. A tool the agent can reach another way, or with a credential MCPGate never sees, is outside it, so deployments must make the gate the only route.
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.
Agentic AI 75: use the engines developers can actually run
The Agentic 75 turns the 75 defining 2026 agentic-AI developments into fixed-scope CAIN-42 products, built one at a time. Pick a live engine below, run its honest sample or one of its failure cases, edit the record and run it again: the live route evaluates the product's published rules, the same file its offline verifier embeds. Products without an engine yet are labelled pilot, advisory or design; none is presented as a finished engine.
Use it now
- The 75-product catalog — status, price, scope and exclusions on every page
- The governance map — the authority, evidence and containment each 2026 development needs
- Catalog JSON — machine-readable, for your own tooling
- Try-it JSON API —
POST /api/v1/agentic-products/<SKU>/reviewwith{"record": {...}}or{"case": "<name>"} - Operator self-test: all 75 engine-backed SKUs run and verify their manifest before each release
What is verified today
- 75/75 engine-backed SKUs produced a verified SHA-256 manifest on fixed samples
- 75 unique SKUs; status counts add to 75
- Three full sample deliveries are published with an offline verifier that imports no CAIN code
- The manifest is unsigned: it detects a changed file, not who produced it
- No customer run, partnership, certification or third-party audit is claimed
curl -s https://mcpgate.online/api/v1/agentic-products/CAIN-A75-045/review \
-H 'Content-Type: application/json' -d '{"case": "self_approved"}'Open the 75 products See the product evidence on clawx.click Use it in the Hugging Face Space
Use the catalog to pick an engine and a scope. Use MCPGate below to enforce it at the tool boundary. Use clawx.click to check what was actually run.
AGENTIC 75: the top 75 agentic-AI developments of 2026, turned into CAIN-42 products one at a time. See which are live.
What MCPGate is
MCPGate is the enforcement boundary of CAIN-42, built for the Model Context Protocol. It's a JSON-RPC 2.0 proxy that speaks MCP on both sides, over stdio (Claude Desktop, Cursor, Windsurf, Cline, custom agents) and over HTTP/SSE (remote MCP servers). Your agent talks to MCPGate as if it were the MCP server, and MCPGate talks to the real server only for calls that are authorized.
It is
- A gate on the execution channel, the tool calls, not the chat text
- Default-deny: unknown tools, malformed requests and errors never become an allow. The SDK is default-deny too, and opting out is explicit and recorded.
- Bound authorization: the authorization covers one exact call, expires, and is single-use (no replay, no swapping the tool or the arguments)
- A guard stack on every call: data-exfiltration killswitch, skill scope, delegation (swarm collusion), memory firewall, supply chain
- Evidence: every allow and every denial is signed and hash-chained, and you can verify it offline
It is not
- A prompt filter or a chat moderation layer
- An authorizer by consensus: the quorum commits and co-signs a decision, and it can never turn a denial into an allow
- A guarantee for calls that bypass it: tools your agent reaches without MCPGate are not governed
- A public download today: the self-hosted appliance is packaged, and access is on request (see below)
- Partial hosted enforcement (2026-11-13): hosted
/mcpcalls tocall_servicenow require an authenticated caller, pass the real MCPGate interceptor and an E8 single-use commit before the tool body. The other hosted tools remain under restriction-only guard stages; the full customer-call claim is still not made.
Where it fits
┌──────────────┐ tools/call ┌───────────────────────────────┐ authorized only ┌──────────────┐
│ AI agent │ ──────────────▶ │ MCPGate │ ──────────────────▶ │ MCP server │
│ Claude, IDE, │ ◀────────────── │ guard stack · bound authz │ ◀────────────────── │ tools · data │
│ your agent │ result / -32000│ signed evidence │ result │ APIs · DBs │
└──────────────┘ └───────────────┬───────────────┘ └──────────────┘
│ commit the exact call
┌─────────▼─────────┐
│ CAIN-42 validator │ PBFT, N = 4, quorum 3
│ quorum cain-mr-03 │ 4 servers, 4 US regions
└───────────────────┘ vendor-operated
The call path, step by step
- Intercept. The agent's
tools/callreaches MCPGate, not the server. Requests that aren't valid JSON-RPC are refused with-32600. - Canonicalize. The call becomes a canonical action: tool, arguments, scope, the agent's identity and its security context.
- Guard stack. Killswitch (bulk exfiltration), skill scope, delegation loops, forged memories, typosquatted packages. Any stage can stop the call.
- Authorize. The call runs only with a PBFT-committed authorization bound to that exact action, scope, identity, context and expiry. Its capability token is short-lived (the TTL is capped) and single-use.
- Forward or deny. Authorized calls are forwarded unchanged. Everything else returns
-32000withenforcement: BLOCKED_AT_BOUNDARYand an evidence hash. - Evidence. The decision is signed and chained, so you can re-check it later without CAIN code.
Live playground
Every panel calls a live production route on this site. Nothing here is simulated in the browser.
Paste a tool definition (name, description, input_schema), or load a sample. The deterministic MCP security scanner looks for poisoned descriptions, hidden instructions, credential references and unbounded parameters. POST /mcpgate-keystone/scan-source
Send a sequence of agent tool calls through the stage code MCPGate runs on every governed call: killswitch, skill scope, delegation, memory firewall and supply chain. POST /api/v1/mcpgate/guard-stack/run
Send a scenario to the hosted trust fabric on a throwaway tenant with enforcement on, and get the verdict and every pipeline stage. No account needed. POST /fabric/try?scenario=…
Download the newest COMMIT and PREPARE certificates from the live validator cluster and check every member's Ed25519 signature in your browser against keys pinned from the signed proof index, which this page re-verifies against the evidence-root key before it uses them. Free: no key, no account — keep the certificate JSON if you want it. GET /api/v1/live-cluster/qc/{seq}?cluster=cain-mr-03
Paste your MCP server's tools/list result: {"tools":[...]}, a bare array, or a whole JSON-RPC response. Every tool is scanned by the same deterministic scanner, at most 50 per run, because the public scanner allows 60 scans per visitor per hour. POST /mcpgate-keystone/scan-source × N
Send a real decision request with your own key, then check the signed record yourself. Your browser runs the four checks of the published verify_decision_record.py: ENCODING, DIGEST recomputed from the record's fields, KEY, and the Ed25519 SIGNATURE. The key stays in this tab's memory and is sent only to this site. POST /fabric/decisions GET /fabric/decisions/{id}/signed-record
Quickstart
The hosted path works today: get a free API key (no card), then ask for a decision before your agent calls a tool. Run the tool only if the verdict is exactly ALLOWED.
export CAIN_API_KEY=... # from https://cainstudio.online/signup
curl -s https://mcpgate.online/fabric/decisions \
-H "X-API-Key: $CAIN_API_KEY" -H "Content-Type: application/json" \
-d '{"agent_id": "billing-agent", "service": "payments", "path": "/tools/send_payment",
"payload": {"to": "acct-991", "amount": 25000}}'
# => {"verdict": "ALLOWED" | "BLOCKED" | "REQUIRE_APPROVAL" | …, "decision_id": "fd_…", ...}import os, requests
def guarded(tool, args, agent="billing-agent"):
r = requests.post("https://mcpgate.online/fabric/decisions",
headers={"X-API-Key": os.environ["CAIN_API_KEY"]},
json={"agent_id": agent, "path": f"/tools/{tool}", "payload": args}, timeout=30)
d = r.json()
if d.get("verdict") != "ALLOWED": # BLOCKED, REQUIRE_APPROVAL, *_DEGRADED, errors: do not run it
raise PermissionError(f"{tool}: {d.get('verdict')} ({d.get('decision_id')})")
return d["decision_id"] # keep it: the signed record is your evidence
decision = guarded("send_payment", {"to": "acct-991", "amount": 25000})export async function guarded(tool: string, args: Record<string, unknown>, agent = "billing-agent") {
const r = await fetch("https://mcpgate.online/fabric/decisions", {
method: "POST",
headers: { "X-API-Key": process.env.CAIN_API_KEY!, "Content-Type": "application/json" },
body: JSON.stringify({ agent_id: agent, path: `/tools/${tool}`, payload: args }),
});
const d = await r.json();
if (d.verdict !== "ALLOWED") throw new Error(`${tool}: ${d.verdict} (${d.decision_id})`); // fail closed
return d.decision_id as string;
}func Guarded(tool string, args map[string]any) (string, error) {
body, _ := json.Marshal(map[string]any{"agent_id": "billing-agent", "path": "/tools/" + tool, "payload": args})
req, _ := http.NewRequest("POST", "https://mcpgate.online/fabric/decisions", bytes.NewReader(body))
req.Header.Set("X-API-Key", os.Getenv("CAIN_API_KEY"))
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil { return "", err } // network error: do not run the tool
defer resp.Body.Close()
var d map[string]any
if err := json.NewDecoder(resp.Body).Decode(&d); err != nil { return "", err }
verdict, _ := d["verdict"].(string)
id, _ := d["decision_id"].(string)
if verdict != "ALLOWED" { return id, fmt.Errorf("%s: %s", tool, verdict) } // fail closed
return id, nil
}curl -s https://mcpgate.online/fabric/decisions/$DECISION_ID/signed-record -H "X-API-Key: $CAIN_API_KEY" > record.json curl -s https://mcpgate.online/fabric/decision-signing-key > key.json curl -sO https://clawx.click/evidence/decision-signing-2026-09-27/verify_decision_record.py.txt python3 verify_decision_record.py.txt record.json --key key.json # ENCODING / DIGEST / KEY / SIGNATURE
Every customer can also verify all of their agents' records in the browser at clawx.click → Verify your own evidence.
MCPGate Connect: guard any MCP server today (open source)
MCPGate Connect wraps any stdio MCP server. Every tools/call your client sends is decided first by the hosted decision API with your key, and it reaches the server only on exactly ALLOWED. Anything else, including a timeout, a network error or a missing key, returns -32000 BLOCKED_AT_BOUNDARY. All other MCP messages pass through unchanged. It's one file, uses only the Python standard library, and is Apache-2.0.
pip install https://cainstudio.online/open-source/mcpgate_connect-0.1.0-py3-none-any.whl export CAIN_API_KEY=... # free: https://cainstudio.online/signup mcpgate-connect --agent my-agent -- npx -y @modelcontextprotocol/server-filesystem ~/projects
{"mcpServers": {"files-guarded": {
"command": "mcpgate-connect",
"args": ["--agent", "desktop-agent", "--", "npx", "-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"],
"env": {"CAIN_API_KEY": "..."}}}}Check what you install
The wheel, source zip and tar.gz are listed in the signed SHA256SUMS (Ed25519, signature). Run python3 verify_release.py from cainstudio.online/open-source to check every download.
Source: mcpgate-connect-0.1.0.zip · .tar.gz
Connect vs the appliance
With Connect, the decision is made by the hosted CAIN-42 trust fabric and recorded as a signed record for your tenant (verify yours). The self-hosted appliance also binds a quorum-committed, single-use capability token to the call at your server. Hosted call_service now gets an E8 single-use commit, not a quorum-committed capability; Connect still does not bind one.
API reference (live routes)
| Method & path | Auth | What it does |
|---|---|---|
POST /fabric/decisions | API key | Decide one intended tool call before it runs: verdict, stages, signed record |
GET /fabric/decisions?limit&cursor&agent_id | API key | Your decisions, newest first, cursor-paged; filter by agent |
GET /fabric/agents/summary | API key | Every agent in your tenant: decision counts by verdict, first and last seen |
GET /fabric/decisions/{id}/signed-record | API key | The record exactly as stored and signed, as input to the offline verifier |
GET /fabric/decision-signing-key | none | The Ed25519 key that signs every decision record |
POST /fabric/mcp/enforce | API key + signed agent manifest | The MCPGate enforce endpoint: refuses any tenant without a registered, governance-signed system manifest and any request not signed by the agent's key |
POST /fabric/try?scenario= | none | A real decision on a throwaway tenant (demo); GET /fabric/try lists scenarios |
POST /mcpgate-keystone/scan-source | none | Deterministic security scan of one MCP tool definition |
GET /api/v1/mcpgate/guard-stack/presets · POST …/run | none | Run agent call sequences through the guard-stack stage code |
GET /api/v1/live-cluster/health?cluster= | none | Validator cluster health (reported by the gateway) |
GET /api/v1/live-cluster/qc/{seq}?cluster= | none | COMMIT and PREPARE quorum certificates for one sequence |
GET /.well-known/cain-keys.json | none | Published validator member keys |
Interactive reference: /docs. Machine-readable index for auditors and AI reviewers: clawx.click/auditor.json.
Self-hosted appliance
MCPGate is designed to run inside your network, next to your MCP servers, so tool traffic and evidence stay on your infrastructure. It ships as a Helm chart that runs the gateway and the MCP proxy as a fail-closed deployment.
replicaCount: 2 security: failClosed: true enforceZeroTrustFloor: true airGapped: false service: gatewayPort: 8000 mcpProxyPort: 8421 metricsPort: 9090
Availability today
The appliance is a packaged Helm chart. No public self-hosted installer is published, and the chart, image and proxy source are not public downloads. Design partners get access on request.
Free and open source today: MCPGate Connect, FALSEWORK, PROOFLOOP and their verifiers (Apache-2.0) at cainstudio.online/open-source.
Status & limits, read live from the signed register
Statuses and limits below come from the Ed25519-signed claims register and are not typed into this page.
One system, three sites
cainstudio.online
The hosted runtime and console: accounts, plans, products and the CAIN Studio dashboard. Start there to buy or to run CAIN for a team.
mcpgate.online you are here
For developers: what MCPGate is, the live playground, the quickstart, the API, and the self-hosted appliance.
clawx.click
The evidence portal: every signed claim, proof chain and evidence file, checked in your browser, plus an independent log monitor.
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
What CAIN-42 has and has not been measured on
CAIN-42 is governed AGI infrastructure; it is not yet AGI. No recognized AGI benchmark has been passed or scored at a competitive level. This table separates what was run from what was not, and why.
| Benchmark | Status | CAIN-42 run | Limit / blocker |
|---|---|---|---|
| AMA-Bench (long-horizon agent memory, ICML 2026) | IN PROGRESS | E115 Track A: official token-F1 on the real-world open-ended set (2,496 QA; dev 636 / sealed 1,860), memory arms M0-M4 | the paper's headline accuracy uses an LLM judge (Qwen3-32B or GPT-5.2) that cannot run here: judge accuracy BLOCKED; F1 only |
| ARC-AGI-2 (abstraction and reasoning) | PLANNED | none yet; planned with a governed local model after the E113 sealed run frees the CPU | local 0.5B-1.5B CPU models; expected near-zero; the public set is not the private leaderboard |
| ARC-AGI-1 | NOT TESTED | none | |
| Humanity's Last Exam | BLOCKED | none | needs a frontier model; the configured API key has no credit; local 0.5B-1.5B models are not meaningful here |
| GPQA Diamond | NOT TESTED | none | |
| GAIA (general assistant) | BLOCKED | none | needs web/tool access plus a frontier model; no API credit |
| SWE-bench Verified | BLOCKED | none | needs container-isolated repository execution and a frontier model; no API credit |
| OSWorld / WebArena (computer and web agents) | NOT TESTED | none | |
| LongMemEval / LoCoMo (conversational memory) | BLOCKED | none | official scoring uses an LLM judge that cannot run here |
| GSM8K (grade-school math) | RAN | E72 small sample: 1/10 with a local model | 10 items; tiny local model; not a benchmark result |
Internal constructed suites (not AGI benchmarks): E75 single-function repair 8/8; E93 procedure synthesis 369/510; E95 composition 79/90; E107/E108 hidden-rule discovery; E110 transfer 4/5 pathways; E113 collective vs individual (running); E114 research lab.
Does verified memory help a model learn on an outside benchmark, even under attack?
Preregistered (sha256 31ae27decaa41bf9…) on AMA-Bench (ICML 2026, real-world agent trajectories, official token F1). The model-backed results do not exist yet: paid model arms are BLOCKED (no API credit), local model arms are pending.
- Retrieval diagnostic (dev, 4000-token budget, novel-token recall): M0_none 0.000; M1_naive 0.393; M2_evidence 0.409; M3_causal 0.391; M4_validated 0.391; R_recent 0.351. This is a retrieval diagnostic, not an AMA-Bench score.
- Rule discovery on sealed shift worlds: open enumerator 33/60 vs fixed grammar 18/60. On frontier worlds whose rules neither grammar can express: 0/60 and 0/60. This test needs a model.
Interim bundle · README · Preregistration · Verifier · CAIN Studio mirror · AGI benchmark status
CAIN-42 is not yet AGI. Team: Vincent Noriega (founder) and two co-founders.
A governed research loop that tests its own next capability
CAIN-42 now runs a governed research loop: a director proposes hypotheses, experiments run only under signed grants, an independent verifier recomputes and signs every verdict, and evidence-native memory keeps only what validates. The lab then ran its own top two follow-up experiments as a second cycle. It does not create AGI.
Confirmed by independent recomputation
- Information-gain experiment selection identified hidden causal rules in 10.28 experiments vs 18.48 for random (120 sealed worlds, 110 wins / 4 losses).
- A memory-learned prior transferred to new 6-variable worlds (p = 0.009).
- Memory rejected a poisoned prior; a naive agent that accepted it fell to 0.69 identification.
- Routed experts beat naive continual learning on 10/10 sealed seeds with zero forgetting.
- 44/44 governance attacks held; 0 effects after KILL across 16 processes.
- A SIGKILLed mission resumed in a new process with 0 duplicate effects (30/30 steps).
Not confirmed (published): the memory prior on sealed worlds, all 5 self-improvement candidates (0 promoted), skill transfer to new task families, and the lab's own two follow-up experiments (context-gated skills, grammar growth).
Lab 3.0 page · Evidence bundle · Executive summary · Gate matrix · Failures · Limitations · Standalone verifier · CAIN Studio mirror
Verifier: python3 -I verify_e114_offline.py . dh2HhSlgp/Dqjxx/7NUqXPRpC4lpIgYofDqsGxN/I9Q= (pins the verdict key). Constructed simulations, one host, no model inference, not production MCPGate, no external reviewer. CAIN-42 is not AGI. Team: Vincent Noriega (founder) and two co-founders.
Can a governed, model-backed collective beat its strongest individual agent?
Preregistered; the primary result does not exist yet. Real local models (Qwen2.5-0.5B, Qwen2.5-1.5B, SmolLM2-135M on CPU); every model call and tool run needs a single-use signed permit and leaves a signed, hash-chained receipt. The comparison is preregistered with the sealed task hash committed before any sealed model output. It does not create AGI.
| Gate | Status | Measured |
|---|---|---|
| G10_autonomous_research | NOT TESTED | pending |
| G11_self_improvement | NOT TESTED | pending |
| G12_byzantine_verification | NOT TESTED | pending |
| G13_governance_integration | NOT TESTED | attack lab 18/18; per-call permits running in the pool; decided at the end |
| G14_kill_revocation | PARTIAL | 5/5 multi-process KILL races, 0 effects after the fence; KILL engaged by a separate process |
| G15_memory_integrity | NOT TESTED | pending |
| G16_long_horizon | NOT TESTED | no 24-hour mission run |
| G17_operational_independence | BLOCKED | one host, one administrator |
| G18_independent_reproducibility | BLOCKED | no external reviewer |
| G1_baseline | PARTIAL | E112 33/33 and E111 87/87 reproduce; E112 headline numbers recomputed from raw rows |
| G2_integrated_architecture | NOT TESTED | pending the sealed run |
| G3_model_backed_agents | NOT TESTED | 660 real local model calls so far (dev/val); gate decided at the end |
| G4_memory | NOT TESTED | pending |
| G5_skills | NOT TESTED | pending |
| G6_collective_intelligence | NOT TESTED | primary endpoint pending (preregistered: G vs A* under matched compute) |
| G7_transfer | NOT TESTED | pending |
| G8_open_world | NOT TESTED | pending |
| G9_metacognition | NOT TESTED | pending |
README.md · E113_STATUS.json · PREREGISTRATION.md · verify_e113_interim.py · bundle · CAIN Studio mirror
Tiny CPU models, constructed tasks, one host, loopback enforcement (not production MCPGate), no external reviewer. Team: Vincent Noriega (founder) and two co-founders.
2,000 VAGI agents inside CAIN-42 governed AGI infrastructure
The lab now merges the two technologies at population scale: thousands of signed VAGI agent identities, every action through a single-use permit and resource-side check, every result signed and chained. It does not create AGI. It measures what the merge actually does.
| Gate | Status | Measured |
|---|---|---|
| G10_agi | FAIL | no AGI was created; the study measures governance, coordination and error structure |
| G1_population | PASS | 2000 unique identities, 2000 unique keys, 6 verticals |
| G2_governed_execution | PASS | 12000 governed executions, 10000 chained receipts, every result signed |
| G3_concurrency | PASS | 1,000 real processes; peak PSS 1456 MB; 15.832 s for 2,000 tasks |
| G4_scaling_efficiency | PARTIAL | 1 process 1.07 s vs 1,000 processes 15.832 s for the same tasks |
| G5_quality | PARTIAL | accuracy 0.736 constant across worker counts |
| G6_collaboration_specialization | PASS | routed six-specialist team 1.000 vs best single 0.167 on 600 cross-domain tasks (gain +0.833) |
| G6b_redundant_voting | FAIL | three-agent majority 1.000 equals one exact agent 1.000 (gain +0.000) |
| G7_governance | PASS | missing/forged/substituted/out-of-scope permits refused; 12602 issued, 0 denied |
| G8_kill_fence | PASS | 3652 effects before the KILL order, 0 after |
| G9_population_study | PASS | accuracy by 6 verticals and 3 strategies; calibration gaps [0.55, -0.1, 0.0918] |
What the lab found
- Identity scale is cheap. 2,000 unique Ed25519 identities cost seconds; identity never grants authority.
- Fan-out is overhead-dominated. 1 process finished 2,000 tasks in 1.07 s; 1,000 processes took 15.832 s.
- Quality is constant. Accuracy stayed 0.736 at every worker count; adding agents does not add correctness on independent tasks.
- Collaboration depends on complementarity. A routed six-specialist team solved 1.000 of 600 cross-domain tasks vs 0.167 for the best single specialist. Redundant three-agent voting scored 1.000, equal to one exact agent (gain +0.000): complementarity helps, duplication does not.
- Governance scales. 10,000 chained receipts; missing, forged, substituted and out-of-scope permits refused; 3652 effects before the KILL order and 0 after.
Lab 2.0 is a research instrument, not an intelligence breakthrough. It can instantiate thousands of governed agents and measure identity, execution, scaling, error structure, collaboration and fault tolerance. That is the foundation for studying VAGI agents inside AGI infrastructure.
Evidence bundle · Report · Study · Gate matrix · Limitations · Standalone verifier · CAIN Studio mirror
Deterministic procedures, constructed tasks, project-measured, no external reviewer. Team: Vincent Noriega (founder) and two co-founders.
MCPGate enforcement — implemented, tested, deployed, audited
E111 adds a coordinator-kill test, a restart-revocation test and a remote resource-side permit verifier. The table separates what exists from what does not.
| Property | Status | Evidence |
|---|---|---|
| Agent identity | IMPLEMENTED | Ed25519, self-generated keys |
| Scoped capabilities | LOCALLY TESTED | action/world/tool scope; policy epoch |
| Authorization | LOCALLY TESTED | decision service + single-use permits |
| Resource-side enforcement | LOCALLY TESTED | unknown/forged/replayed/expired refused |
| Revocation | LOCALLY TESTED | survives coordinator restart |
| Signed permits | IMPLEMENTED | Ed25519, short TTL |
| Execution receipts | LOCALLY TESTED | hash-chained resource ledger |
| Byzantine resilience | NOT DEMONSTRATED | no consensus in this boundary path |
| Kill switch | LOCALLY TESTED | 0/5 pre-issued permits after KILL |
| Evidence verification | LOCALLY TESTED | offline verifier, no CAIN imports |
| Network tested | PARTIAL | one remote resource host, same admin domain |
| Production deployed | NOT DEMONSTRATED | organism traffic does not use cain/mcp_proxy |
| Independently audited | BLOCKED | no third party |
Honest line: enforcement works while the coordinator is dead, in loopback and on one remote host. It is not production MCPGate, not independently administered, and not third-party audited.
Integrated generalization, memory, world model, transfer, collective & governance (research-lab update)
E116 demonstrates rule inference, memory gain, a world model, transfer and governed collectives on constructed tasks; it does NOT demonstrate AGI.
Measured & independently verified offline (54/54 checks)
- New sealed generalization suite (6 families, disclosed finite grammar): fixed baseline 0.306, per-task 0.939, world memory 0.983, memory+prior 0.989.
- Acquired capability R_world_memory_policy (validation-selected): sealed 0.817 → 0.950 (McNemar p=0.02148438), replicated on second sealed set 0.850 → 0.967 (p=0.0390625).
- Evidence-native memory survives serialization/reload (retained accuracy 0.989) and rejects poisoned rules (poisoned_rule_used=False).
- Hidden-mode world model: hybrid_two_mode 0.876 vs single-table 0.522; planning 0.850 vs 0.675; shift detected True.
- Transfer (5/5 E111 pathways supported, 4 harmful rejected), routed collective (1.000 vs 0.167), small tabular model adaptation (0.627 → 0.993), and governance (permit ablations & authority-granting skills refused; KILL 0 effects after order).
Negative & blocked results (preserved): H2 frequency prior rejected; H3 active support selection BLOCKED; redundant voting adds 0 gain over one exact agent; self-improvement promotion withheld awaiting owner approval; LLM fine-tuning BLOCKED (no GPU/API credit); 6h mission interrupted and 24h continuous mission BLOCKED; E115 baseline remains INTERIM (no model-backed AMA-Bench result yet); no external reviewer or independent administrative domain.
Show all 22 E116 gates (13 PASS / 7 PARTIAL / 2 BLOCKED)
| Gate | Status | Measured |
|---|---|---|
| G1_e115_baseline | PARTIAL | E115 de0bf05dc: tests 18 passed, verifier 7/7; status INTERIM — preregistered; primary model-backed results do not exist yet |
| G2_integrated_organism | PARTIAL | one runner integrates generalization, memory, world model, transfer, collective, governance; single host |
| G3_generalization | PARTIAL | sealed M4 0.989 vs fixed 0.306; finite disclosed grammar |
| G4_evidence_memory | PASS | 180 sealed tasks with provenance records; poison rejected True |
| G5_memory_improves | PASS | M2 0.939 -> M4 0.989; capability 0.817 -> 0.950 (p=0.02148438) |
| G6_five_skills | PASS | 5/5 promoted on sealed vs fixed baseline |
| G7_transfer | PASS | 5/5 E111 pathways; E116 memory policy transfers only where ambiguity exists |
| G8_research_gaps | PASS | 3 gaps identified from measured weaknesses |
| G9_research_cycle | PASS | gap -> H1/H2/H3 -> validation -> sealed -> replication; H2 rejected, H3 blocked |
| G10_world_model | PASS | hybrid 0.876 vs single 0.522; planning 0.850 vs 0.675; shift detected True |
| G11_cross_domain | PASS | 5/5 pathways across software, science, data, math, operations |
| G12_collective | PASS | routed specialists 1.000 vs best single 0.167; redundant voting 1.000 = single |
| G13_model_adaptation | PARTIAL | small tabular model 0.627 -> 0.993; LLM fine-tuning BLOCKED |
| G14_self_improvement | PARTIAL | PROMOTED_AWAITING_OWNER_APPROVAL: sealed 0.58 -> 0.86 |
| G15_governance | PASS | E112 permit ablations + skill gate {'valid': (True, 'ALLOW'), 'forged_authority': (False, 'SKILL_GRANTS_AUTHORITY'), 'revoked': (False, 'SKILL_REVOKED')}; KILL 0 after |
| G16_adversarial_memory | PASS | poison rejected True; E112 forged/scope/replay refused |
| G17_persistence | PARTIAL | 1h PASS, 6h cumulative 21639s interrupted, 24h BLOCKED; memory restart retained 0.989 |
| G18_open_world | PARTIAL | 6/6 real-source tasks; new sealed suite constructed |
| G19_independent_evidence | BLOCKED | standalone verifier; no external reviewer engaged |
| G20_operational_independence | BLOCKED | E111 remote host 6/6, but both hosts are owner-administered |
| G21_clawx | PASS | E116 bundle published and catalogued |
| G22_public_lab | PASS | research-lab update (not renamed 4.0) |
Evidence bundle · Executive summary · Gate matrix · Generalization report · World model report · Failures · Limitations · Standalone verifier (54/54) · CAIN Studio mirror
Verify offline (stdlib only, 0 CAIN imports): python3 -I verify_e116_offline.py . · Built by FIRME AI CORPORATION. CAIN-42 is not yet AGI.
Unseen combinations: a sealed OOD gain, and the negatives around it
E117 asks whether CAIN-42 can acquire a capability from component experience and use it on a sealed suite whose combinations were never available. On a disclosed finite grammar: yes, for three capabilities. Not AGI.
| Gate | Status | Measured |
|---|---|---|
| G10_research_cycle | PASS | 3 gaps, 4 hypotheses (H0 rejected, H1-H3 sealed), one cycle |
| G11_world_model | PARTIAL | hybrid 0.844 vs table 0.537; shift 66 with 27 stationary false alarms |
| G12_self_improvement | PASS | REJECTED; sealed 0.889 vs 0.889 (negative published); promotion withheld |
| G13_six_hour | BLOCKED | no continuous 6h E117 run; E111 1h PASS, 6h 21639s cumulative interrupted; 24h BLOCKED |
| G14_governance | PASS | E112 permit ablations; skill gate {'valid': (True, 'ALLOW'), 'forged': (False, 'GRANTS_AUTHORITY'), 'revoked': (False, 'REVOKED')}; KILL 0 after; memory poison rejected |
| G15_verifier | PASS | standalone verifier, no CAIN imports |
| G16_external_review | BLOCKED | no external reviewer engaged |
| G17_independent_admin | BLOCKED | no independent administrative domain |
| G18_public_lab | PASS | E117 update published; lab not renamed 4.0 |
| G1_e116_baseline | PASS | E116 3d9fbf152: 6 tests, 54/54 |
| G2_baseline_manifest | PASS | frozen before E117 scoring |
| G3_ood_suite | PASS | new generator; sealed hash frozen before scoring |
| G4_three_capabilities | PASS | C1 composition, C2 precondition, C3 evidence revision |
| G5_capabilities_pass | PASS | 3/3 passed sealed |
| G6_primary_ood | PASS | F 1.000 vs E_compose_pre 0.431; gain +0.569, p=0.0; replication +0.569, p=0.0 |
| G7_memory | PASS | memory 1.000 vs none 0.514 (p=1e-10); restart 1.000; poison rejected True |
| G8_transfer | PASS | 5/5 supported; 4 harmful rejected |
| G9_collective | PARTIAL | E112 routed specialists 1.000 vs best single 0.167; E117 integrated F 1.000 is not beaten by a team |
- OOD suite: components only in acquisition; sealed compositions disjoint from dev/val; hidden preconditions, conflicting support, incomplete observation, unanswerable support.
- Three capabilities: compositional synthesis (1.00 vs 0.00), precondition discovery (1.00 vs 0.00), evidence revision/abstention (1.00 vs 0.57).
- Memory: retained 1.000 after restart; poison rejected True.
- World model: hybrid 0.844 vs table 0.537; 27 stationary false alarms — PARTIAL.
- Collective: E112 routing 1.00 vs 0.17; E117 integrated F 1.00 is not beaten by a team — PARTIAL.
- Blocked: continuous 6 h, external reviewer, independent administration.
Evidence · Summary · Gates · Failures · Verifier · Mirror
Finite disclosed grammar, constructed tasks, project-measured, no external reviewer. Not renamed 4.0.
Unseen primitives, depth-3 composition, search-based acquisition
E118 upgrades E117 in the six ways that matter: held-out primitives and parameters, depth-3 shapes, search rather than added code, a real-data pathway, a second-host verifier execution, and a positive OOD self-improvement candidate. It is still not proof of AGI.
| Gate | Status | Measured |
|---|---|---|
| G10_external_reviewer | BLOCKED | no independent reviewer engaged |
| G11_continuous_6h | BLOCKED | E111 1h PASS; 6h 21639s cumulative interrupted; no continuous E118 6h |
| G12_governance | PASS | permit ablations; skill gate {'valid': (True, 'ALLOW'), 'forged': (False, 'GRANTS_AUTHORITY')}; KILL 0 after |
| G13_verifier | PASS | standalone verifier, no CAIN imports |
| G14_public | PASS | E118 update published; lab not renamed 4.0 |
| G15_independent_admin | BLOCKED | no independent administrative domain |
| G1_baseline | PASS | E117 6 tests/28/28; E116 6/54; E115 18/7 |
| G2_unseen_primitives | PASS | 11 held-out primitives/params vs 11 acquisition |
| G3_search_acquisition | PASS | compute-budgeted search over the full grammar; no sealed rule or op list supplied |
| G4_primary_ood | PASS | full 1.000 vs fixed_e117 0.264; gain +0.736, p=0.0; replication +0.778 |
| G5_capabilities | PASS | 3/3 pass sealed |
| G6_memory | PASS | 1.000 vs 0.167 (p=0.0); restart 1.000 |
| G7_real_world | PASS | breast 0.627 -> 0.972 (CV 0.953); iris 0.339 -> 0.947 |
| G8_self_improvement | PASS | PROMOTED_AWAITING_OWNER_APPROVAL; sealed 0.167 -> 1.000 (p=0.0); replicated 1.000 |
| G9_remote_verifier | PASS | verifier executed on a second host (same admin domain) |
Why this is stronger: the sealed suite holds out primitive families/parameters and requires depth-3 compositions; the learner searches the grammar under a candidate budget rather than receiving the sealed rule; memory is required because later tasks carry no support; the self-improvement search now produces a positive, replicated OOD candidate; and real public data is evaluated with an independent 5-fold oracle. Why it is not AGI: the grammar is finite and disclosed, tasks are constructed, the real-data tasks are small tabular models, and there is no independent reviewer or continuous 6-hour run.
Evidence bundle · Summary · Gate matrix · Upgrade matrix · Failures · Verifier · Mirror
Project-measured; no external reviewer; no proof of AGI. Team: Vincent Noriega (founder) and two co-founders.
The grammar is learned, the tasks are real, the six hours are running
E119 targets the two hardest upgrades. The macro grammar is mined from development experience (8 macros), and the sealed depth-3 test runs under a matched 8000-candidate budget: fixed 0.333 → learned 1.000 (gain +0.667, p≈1e-7), replicated +0.583. Real-source tasks: 8, 8 independently checkable. The 6-hour mission PASSED: 21,600 s of real wall-clock time, 39,449 tasks, and a 39,449-record SHA-256 chain with 0 breaks (33,813 solved; 5,636 science tasks failed). PASS = duration + journal integrity, not task success.
| Gate | Status | Measured |
|---|---|---|
| G10_public | PASS | E119 update published; AGI not claimed |
| G1_e118_baseline | PASS | E118 6 tests, verifier 26/26; E117 28/28; E116 54/54; E115 18/7 |
| G2_learned_grammar | PASS | 8 macros learned; sealed 0.333 -> 1.000, gain +0.667, p=1.192e-07; replication +0.583 |
| G3_grammar_not_received | PASS | macros mined from development programs; base instruction set supplied |
| G4_open_world | PARTIAL | 8 real tasks (8 independently checkable); constructed protocols, not an open-world benchmark |
| G5_independent_execution | PASS | verifier executed as a separate OS user on a second host |
| G6_external_reviewer | BLOCKED | packet prepared; no human reviewer engaged |
| G7_six_hour | BLOCKED | launched real 6h mission at 1795138211; state RUNNING at publication; not a PASS |
| G8_independent_admin | BLOCKED | separate OS user on the same owner-administered host |
| G9_verifier | PASS | standalone verifier, no CAIN imports |
What is genuinely new: the macro grammar is learned, not received; the sealed rule is never supplied; real-source tasks are evaluated; and the verifier runs as a separate OS user on a second host. What is not: the base instruction set is supplied, the sealed tasks are constructed, the 6-hour run is not complete, and there is no human external reviewer or independent administration.
Evidence · Summary · Grammar · Gates · Failures · Verifier · Mirror
What is verified, what is blocked, and what E120 must deliver
E121 is not another intelligence claim. It re-runs the published verifiers from clean copies, recomputes the headline metrics, and states exactly which external gates are still missing. E118 verifies 26/26 and E119 16/16; the six-hour mission is RUNNING; the external reviewer and independent administration are BLOCKED; E120's open-world and base-grammar evidence is PENDING.
| Gate | Status | Measured |
|---|---|---|
| G1_six_hour | RUNNING | state RUNNING; events 4145; passed False |
| G2_external_reviewer | BLOCKED | no human reviewer engaged |
| G3_independent_admin | BLOCKED | no independent administrative domain or separate key custody |
| G4_open_world | NOT TESTED | E120 PENDING; bundles [] |
| G5_base_grammar | NOT TESTED | E120 PENDING; merge adapter ready |
| G6_clean_archive_verifier | PASS | E118 rc=0, E119 rc=0 |
| G7_public_index | PASS | agi-evidence-index.html live |
| G8_independent_execution | PASS | verifier run as OS user nobody on a second host; same admin domain |
What E121 proves: the published E118/E119 bundles verify from clean copies and their headline metrics recompute. What it does not prove: an external review, independent administration, continuous six hours, open-world generalization or a learned base grammar. Those remain the five gates.
Verification bundle · Report · Gates · Reviewer packet · Verifier · Mirror
The honest ranking: unranked on general long tasks, measured on governance
METR measures the 50% task-completion time horizon: the human-task duration at which a system succeeds half the time. CAIN-42 has not run METR's HCAST/RE-Bench suite, so it cannot be placed on this axis. We publish the frontier table anyway, and we do not invent a composite score.
| # | Published model | Release | 50% horizon | Hours |
|---|---|---|---|---|
| 1 | claude_mythos_preview_early_inspect | 2026-04-07 | 1045 min | 17.4 h |
| 2 | claude_opus_4_6_inspect | 2026-02-05 | 719 min | 12.0 h |
| 3 | gemini_3_1_pro | 2026-02-19 | 384 min | 6.4 h |
| 4 | gpt_5_2 | 2025-12-11 | 352 min | 5.9 h |
| 5 | gpt_5_3_codex | 2026-02-05 | 350 min | 5.8 h |
| 6 | gpt_5_4 | 2026-03-05 | 342 min | 5.7 h |
| 7 | claude_opus_4_5_inspect | 2025-11-24 | 293 min | 4.9 h |
| 8 | gemini_3_pro | 2025-11-18 | 224 min | 3.7 h |
| 9 | gpt_5_1_codex_max_inspect | 2025-11-19 | 224 min | 3.7 h |
| 10 | gpt_5_2025_08_07_inspect | 2025-08-07 | 203 min | 3.4 h |
| 11 | o3_inspect | 2025-04-16 | 120 min | 2.0 h |
| 12 | claude_4_1_opus_inspect | 2025-08-05 | 100 min | 1.7 h |
| 13 | claude_4_opus_inspect | 2025-05-22 | 100 min | 1.7 h |
| 14 | claude_3_7_sonnet_inspect | 2025-02-24 | 60 min | 1.0 h |
| 15 | o1_inspect | 2024-12-05 | 39 min | 0.7 h |
| 16 | claude_3_5_sonnet_20241022_inspect | 2024-10-22 | 21 min | 0.3 h |
| 17 | o1_preview | 2024-09-12 | 20 min | 0.3 h |
| 18 | claude_3_5_sonnet_20240620_inspect | 2024-06-20 | 11 min | 0.2 h |
| 19 | gpt_4o_inspect | 2024-05-13 | 7 min | 0.1 h |
| 20 | gpt_4_1106_inspect | 2023-11-06 | 4 min | 0.1 h |
| 21 | gpt_4 | 2023-03-14 | 4 min | 0.1 h |
| 22 | claude_3_opus_inspect | 2024-03-04 | 4 min | 0.1 h |
| 23 | gpt_4_turbo_inspect | 2024-04-09 | 4 min | 0.1 h |
| 24 | gpt_3_5_turbo_instruct | 2022-03-15 | 1 min | 0.0 h |
| 25 | davinci_002 | 2020-05-28 | 0 min | 0.0 h |
| 26 | gpt2 | 2019-02-14 | 0 min | 0.0 h |
CAIN-42 — UNRANKED on this axis. No METR suite was run; there is no comparable 50% horizon. Its 6-hour governed workload is RUNNING at publication; if it completes, it is one 360-minute workload success, not a 50% horizon.
Where CAIN is better — and where it is not
| Dimension | CAIN-42 | Frontier METR-tested agents | Verdict |
|---|---|---|---|
| General long-task horizon | Unranked; 6h governed workload RUNNING | 50% horizons ~1–17h | Competitors better |
| Task breadth / open-world | Constructed, disclosed grammars | Broad software/research suites | Competitors better |
| Model capability | Deterministic procedures; no LLM training | Frontier foundation models | Competitors better |
| Resource-side authorization | Demonstrated (E121/E112) | Not measured by METR | CAIN measured |
| Single-use permits / receipts | Demonstrated; hash-chained | Not measured | CAIN measured |
| Revocation + KILL fence | Demonstrated, 0 effects after fence | Not measured | CAIN measured |
| Offline verifier | Imports no CAIN code | Not measured | CAIN measured |
| Public negative results | Published per evolution | Varies; not in METR table | CAIN policy |
| Commercial deployment | No scale; founder-attested early revenue | Commercial products | Competitors better |
No universal superiority is claimed. CAIN is better than the frontier on verifiable governance and public evidence; the frontier is better on general long-task autonomy and commercial deployment. “Better than ALL competitors” is not supported by the evidence.
Two axes, no composite score. METR models were not evaluated for permits, receipts, revocation or an offline verifier; CAIN was not evaluated on METR's suite.
Evidence bundle · Report · Verifier · METR method · Paper
External METR TH1.1 data; CAIN not a METR-tested system. No AGI claim.
A real 70B agent loop: 13/18, 2-hour-class on a CAIN-native suite
E124 fixes the harness bugs and runs a real multi-file agent loop on six repo tasks (2 to 120 human-minute estimates), three repetitions each. It solves 13/18; the fitted 50% horizon is ≈121 minutes on this suite. That is a genuine improvement from “unranked/no agent”, but it is not a METR score and it is still below the published frontier (6.4–17.4 h).
| Task | Human estimate | Success | Steps |
|---|---|---|---|
| T1 | 2 min | 3/3 | [2, 2, 2] |
| T2 | 5 min | 2/3 | [5, 8, 18] |
| T3 | 15 min | 2/3 | [4, 4, 8] |
| T4 | 30 min | 3/3 | [4, 4, 4] |
| T5 | 60 min | 2/3 | [7, 10, 7] |
| T6 | 120 min | 1/3 | [18, 7, 9] |
Two-axis ranking — no invented composite
| Axis | CAIN-42 | Frontier METR agents | Verdict |
|---|---|---|---|
| General long-task autonomy | ≈2.0 h CAIN-native (not METR) | 50% horizons 6.4–17.4 h | Frontier still leads |
| Governance / evidence | permits, receipts, KILL, offline verifier | not evaluated on this axis | CAIN leads by measured evidence |
CAIN is not ranked above the frontier on general autonomy. The honest high rank is on verifiable governance, not on METR.
Evidence · Report · Verifier · Full competitor board · Mirror
#1 in verifiable governance. Not #1 in general autonomy.
A single “best agent” rank would be dishonest. CAIN-42 leads the only axis it has fully evidenced — governance — and is placed honestly below the frontier on general long-task autonomy. This is the board we can defend line by line.
Axis A — General long-task autonomy (METR-compatible, external)
| # | Published model | 50% horizon |
|---|---|---|
| 1 | claude_mythos_preview_early_inspect | 17.4 h |
| 2 | claude_opus_4_6_inspect | 12.0 h |
| 3 | gemini_3_1_pro | 6.4 h |
| 4 | gpt_5_2 | 5.9 h |
| 5 | gpt_5_3_codex | 5.8 h |
| 6 | gpt_5_4 | 5.7 h |
| 7 | claude_opus_4_5_inspect | 4.9 h |
| 8 | gemini_3_pro | 3.7 h |
| 9 | gpt_5_1_codex_max_inspect | 3.7 h |
| 10 | gpt_5_2025_08_07_inspect | 3.4 h |
CAIN-42 — not ranked on METR. E124’s 70B agent solves 13/18 on a six-task CAIN-native suite with a fitted 50% horizon of ≈2.0 h. That is not METR HCAST/Re-Bench; it is a constructed suite with assigned human times. The frontier’s METR 50% horizons are 6.4–17.4 h. Frontier leads this axis.
Axis B — Verifiable governance (the axis CAIN leads)
| Requirement | CAIN-42 | Frontier METR agents | Evidence |
|---|---|---|---|
| Identity + scoped authority | Demonstrated | Not evaluated | E121 |
| Resource-side single-use permits | Demonstrated | Not evaluated | E116 |
| Signed receipts + chained evidence | Demonstrated | Not evaluated | E112 |
| Revocation + independent KILL fence | Demonstrated, 0 effects after fence | Not evaluated | E112 |
| Offline verifier (no vendor code) | Demonstrated | Not evaluated | E121 |
| Public negative results | Published | Not in METR table | E119 |
Why CAIN is better here: every consequential action has an attributable identity, a scoped, single-use permit, a resource-side check, a signed receipt and a revocation path; the KILL fence is tested; the evidence is re-checkable by a verifier that imports no CAIN code. Frontier agents are not evaluated for these properties, so the honest statement is “CAIN leads by evidenced capability,” not “CAIN beats them at everything.”
The verdict
Choose CAIN-42 when the requirement is governed execution with evidence. Choose a frontier agent when the requirement is the longest open-ended task. CAIN is #1 on the governance axis and not #1 on general autonomy.
METR TH1.1 raw data · METR paper · E124 long-horizon agent · E123 METR board · All evidence
External METR TH1.1 data; CAIN not a METR-tested system. No AGI claim.
CAIN-42: #136 of 136
Fixed scaffold: 70B tool-calling agent, one attempt, official SWE-bench evaluator. Rank is by resolution rate among the public SWE-bench Verified submissions in the experiments repository; scaffolds and model versions differ, so this is a SWE-bench rank, not METR HCAST.
| # | Submission | Resolved | Rate | 50% horizon |
|---|---|---|---|---|
| 1 | 20251215_livesweagent_claude-opus-4-5 | 396/500 | 79.2% | 4.3 h |
| 2 | 20251205_sonar-foundation-agent_claude-opus-4-5 | 396/500 | 79.2% | 4.2 h |
| 3 | 20250928_trae_doubao_seed_code | 394/500 | 78.8% | 4.1 h |
| 4 | 20251127_openhands_claude-opus-4-5 | 388/500 | 77.6% | 3.3 h |
| 5 | 20251120_livesweagent_gemini-3-pro-preview | 387/500 | 77.4% | 2.5 h |
| 6 | 20250902_atlassian-rovo-dev | 384/500 | 76.8% | 2.1 h |
| 7 | 20250804_epam-ai-run-claude-4-sonnet | 384/500 | 76.8% | 1.7 h |
| 8 | 20250819_ACoder | 382/500 | 76.4% | 1.9 h |
| 9 | 20250901_warp | 378/500 | 75.6% | 2.7 h |
| 10 | 20250612_trae | 376/500 | 75.2% | 1.7 h |
| 11 | 20251103_sonar-foundation-agent_claude-sonnet-4-5 | 374/500 | 74.8% | 2.6 h |
| 12 | 20250731_harness_ai | 374/500 | 74.8% | 1.4 h |
| 13 | 20250915_JoyCode | 373/500 | 74.6% | 2.3 h |
| 14 | 20250720_Lingxi-v1.5_claude-4-sonnet-20250514 | 373/500 | 74.6% | 1.7 h |
| 15 | 20251015_Prometheus_v1.2.1_gpt5 | 372/500 | 74.4% | 2.5 h |
| 16 | 20250603_Refact_Agent_claude-4-sonnet | 372/500 | 74.4% | 1.8 h |
| 17 | 20251103_SalesforceAIResearch_SAGE_OpenHands | 369/500 | 73.8% | 1.8 h |
| 18 | 20250522_tools_claude-4-opus | 366/500 | 73.2% | 2.3 h |
| 19 | 20251021_SalesforceAIResearch_SAGE_bash_only | 365/500 | 73.0% | 2.1 h |
| 20 | 20250522_tools_claude-4-sonnet | 362/500 | 72.4% | 2.0 h |
| 21 | 20260901_mini-v2.4.2_gemini-3-5-flash | 359/500 | 71.8% | 3.0 h |
| 22 | 20250807_openhands_gpt5 | 359/500 | 71.8% | 1.5 h |
| 23 | 20250929_Prometheus_v1.2_gpt5 | 356/500 | 71.2% | 1.7 h |
| 24 | 20250710_bloop | 356/500 | 71.2% | 1.4 h |
| 25 | 20251014_Lingxi_kimi_k2 | 356/500 | 71.2% | 1.2 h |
| 26 | 20250715_qodo_command | 356/500 | 71.2% | 1.2 h |
| 27 | 20250623_warp | 355/500 | 71.0% | 1.7 h |
| 28 | 20250611_moatless_claude-4-sonnet-20250514 | 354/500 | 70.8% | 1.3 h |
| 29 | 20250519_trae | 353/500 | 70.6% | 1.2 h |
| 30 | 20250610_augment_agent_v1 | 352/500 | 70.4% | 1.4 h |
CAIN row is highlighted in the source JSON. Full result: E124 evidence · report