$ 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