Actenon Kernel MCP Server

Actenon Kernel

The open verifier for proof-bound consequential execution. Defines what a valid proof is. Verifies proofs at the execution edge; issues no grants; runs no policy decisions.

Every claim above is machine-verified

The claims: machine-verified badge links to a CI gate (verify-claims.yml) that fails on every PR, push to main, and once a day if any factual claim this README makes about the kernel stops being true:

• Zero network calls during verification — tests/test_neutrality.py runs in the gate, not just behind a badge link.
• Runs without Permit, Cloud, or Scan — tests/test_independence.py, plus a source scan proving the kernel never imports Cloud or Permit, plus scripts/assert_dep_direction.py (runtime deps are exactly actenon-protocol).
• The conformance count — "51 conformance vectors" is compared against what actenon-kernel conformance run actually executes; the vector files themselves are hash-locked by scripts/verify_conformance_manifest.py.
• Install commands — every pip install in this README is resolved against the live registry; the Python badge is generated, not hand-edited.
• The ecosystem table — rendered from the protocol's ecosystem.yaml, never hand-edited.

The Invariants workflow additionally proves on every PR that a clean, no-extras install verifies the full conformance surface — 33/33 tests, zero skips — including Ed25519.

If a claim drifts, the badge goes red before a human notices.

---

The Actenon ecosystem

The Kernel is one of five independent repositories that together close the execution gap — the gap between upstream authorization and the execution edge that actually performs a consequential side effect.

Optional: actenon-cloud — a managed control plane (source-available; see its LICENSE). Not required by any component above; every capability in this ecosystem works without it.

Every repo can be adopted independently. The Kernel in particular can be wired in at the agent framework (LangChain tool, MCP tool, Claude Managed Agents custom tool, etc.) or independently at the resource boundary (FastAPI route, Express route, Go HTTP handler). Both placements are first-class.

---

What this is

The Kernel is the trust anchor of the Actenon ecosystem. It is:

• Independent — runs without Permit, Cloud, or Scan. Zero network calls during verification.
• The verifier at the execution edge — the PCCBVerifier is pure and stateless; the ProtectedExecutor enforces replay, escrow, idempotency, and credential brokering at the edge before any side effect, then emits the Receipt or Refusal.
• Conformance-locked — 51 conformance vectors define exactly what "a valid PCCB" means, in any language.
• Multi-language — Python reference, plus TypeScript, Go, and Rust verifier SDKs that all conform to the same vectors.
• Framework-agnostic — proof verification is a function call, not a framework. The same verifier runs inside a LangChain _run, an MCP tool handler, an Express route, or a Go HTTP handler.

The Kernel does one thing: it verifies that a PCCB (Proof of Constrained Capability Bound) authorizes an exact Action Intent for this caller, this target, this audience, this scope, this time window, and this single execution attempt — and the ProtectedExecutor refuses the attempt (no side effect, structured Refusal emitted) if verification fails. The Kernel does not issue grants or make policy decisions — that's Permit's job.

Why it exists

Modern agent stacks already answer the upstream question — should this requester be allowed to do this kind of thing? — with authentication, policy engines, approval workflows, and audit logs. They still leave open the question the execution edge needs to answer:

Is the exact action about to execute still the exact action that was authorized — for this endpoint, this tenant, this subject, this target, and this time window?

That unanswered question is the execution gap. It is where parameter mutation between approval and execution, replay of valid-looking proof, presentation to the wrong endpoint, tenant/subject rebinding, and stale-proof reuse actually happen. The Kernel closes it.

Read the canonical problem statement in THE_EXECUTION_GAP.md.

The two places you can wire it in

This is the single most important architectural decision in any Actenon adoption, and the Kernel is explicitly designed for both placements.

Placement A — at the agent framework (brokered mode)

The Kernel verifier runs inside the agent's tool implementation. The agent calls a tool; the tool verifies proof; the tool executes. The agent never holds a production credential — the broker resolves it after verification.

agent → framework tool (LangChain / MCP / Claude / CrewAI / ...)
          ↓ verifies PCCB locally
          ↓ brokers credential
          ↓ executes side effect
       Receipt or Refusal

This is the path you take when you control the agent framework and want to bind every tool call to proof. See INTEGRATIONS.md for the six ranked framework paths.

Placement B — independently at the resource boundary (resource-owned mode)

The Kernel verifier runs inside the resource itself — a FastAPI route, an Express endpoint, a Go HTTP handler, an internal service method. The resource is the protected endpoint. The agent (or any caller) must present a valid PCCB to cause a side effect, regardless of how it got there.

any caller (agent / human / service / attacker)
          ↓ presents PCCB
   resource boundary (FastAPI / Express / Go / ...)
          ↓ verifies PCCB locally
          ↓ executes side effect
       Receipt or Refusal

This is the path you take when you cannot fully trust the agent framework, when the resource is shared by multiple callers, or when the resource team and the agent team are different organizations. See the Boundary Kit in actenon-permit and the BoundaryVerifier API in this repo.

Both placements use the same Kernel, the same PCCB shape, the same conformance vectors, and the same Receipt/Refusal artefacts. You can mix them in one deployment.

The 15-step verification pipeline

Pre-auth failures collapse to a single public-safe code PROOF_INVALID. Post-auth failures disclose the specific code (AUDIENCE_MISMATCH, ACTION_MISMATCH, REPLAY_DETECTED, etc.) only to trusted callers. This two-layer refusal model is part of the protocol — see actenon-protocol.

What the Kernel produces

Signed receipts — what the agent had permission to do, what it did or tried, and how

Every execution attempt produces one of two canonical, machine-readable artefacts:

• A Receipt when the side effect executed (or was definitively refused before execution, in the refused-receipt path).
• A Refusal when the protected endpoint refused the attempt before any side effect.

Both are structured, hash-chained, and stable at the contract level. They answer, for any retrospective reviewer (engineer, auditor, regulator, insurer):

• What the agent had permission to do — the Grant's scopes.allow, scopes.deny, budget, rate, expires_at, and approval rules. The receipt cites the exact grant and proof that authorized this attempt.
• What it did or tried to do — the exact Action Intent (action name, target, tenant, subject, audience, parameters), the action-hash (SHA-256 over RFC 8785 canonical JSON), and the execution state (succeeded, failed, refused, outcome_unknown).
• How it did it — the brokered or resource-owned execution mode, the credential reference (not the secret), the adapter / endpoint that performed the side effect, the provider response or refusal code, and the receipt's own signature.

For deployments that need portable cryptographic attestation of origin, the Kernel can wrap any v1 Receipt or Refusal in an Outcome Attestation envelope (v2alpha1, opt-in). The attestation is signed with an Ed25519 key whose lifecycle (active / retired / suspended / soft-revoked / hard-revoked) is itself part of the public contract. A hard-revoked key's historical artefacts remain verifiable only if an independently verified external anchor proves the artefact digest existed before the compromise — see REVOCATION_AND_RECEIPT_DURABILITY.md.

Outcome Attestation is v2alpha1 and is excluded from the 1.0 compatibility promise. It is opt-in, alpha, and may change or be removed in any release until it reaches v2. See VERSIONING.md §1.2.

Install

Python 3.10+ for the Kernel alone. The full stack including Permit requires 3.11+.

pip install actenon-kernel            # full verifier: HMAC and Ed25519

Since 1.1.0 the base install verifies everything the ecosystem produces, including Ed25519 proofs and Outcome Attestations. (The [asymmetric] extra still resolves for backward compatibility; it installs nothing additional.)

Connect it to an agent (MCP, 60 seconds, zero install)

The Kernel ships a runnable MCP server, so a model can ask it whether an action is allowed before the action runs — and read back exactly why it was refused. Paste this into any MCP client (Claude Desktop, ChatGPT, or anything else that speaks MCP):

{
  "mcpServers": {
    "actenon": {
      "command": "uvx",
      "args": ["--from", "actenon-kernel[mcp]", "actenon-mcp", "--demo"]
    }
  }
}

uvx fetches and runs it — nothing to install first. --demo runs offline with an ephemeral key and in-memory state; it is clearly marked DEMO MODE in every tool description and must not be used in production.

Three tools: actenon_verify (is this proof good for this exact action?), actenon_gate (ALLOW or a typed refusal), actenon_receipt (the hash-chained receipt for a prior decision). Every refusal carries both the machine code and the human-readable reason.

Full walkthrough, including a real transcript of an agent being refused for widening a refund and then succeeding within scope: docs/integrations/MCP_QUICKSTART.md.

Use as a verifier (resource boundary)

from actenon.proof import PCCBVerifier, build_local_proof_signer

# For production, use a file-based or KMS-backed signer (see
# docs/PRODUCTION_INTEGRATION.md §1). The local HMAC signer below is
# development-only — it uses a public test secret.
signer = build_local_proof_signer()    # development only
verifier = PCCBVerifier(signer=signer)

# Raises ProofVerificationError on any failure; returns silently on success.
verifier.verify(intent, pccb, context)

Production key custody: the local HMAC signer above is for development only. For production, use a file-based Ed25519 key or a KMS-backed signer. See docs/PRODUCTION_INTEGRATION.md §1 for the three custody tiers and the ACTENON_ALLOW_PILOT_LOCAL_EDDSA_IN_PRODUCTION flag documentation.

Use as a boundary verifier (Boundary Kit, resource-owned mode)

from actenon.boundary import BoundaryVerifier, BoundaryVerificationRequest

verifier = BoundaryVerifier()
result = verifier.verify_boundary(BoundaryVerificationRequest(
    proof_token="v1.eyJ...",
    action_type="payment.refund",
    action_hash="abc123...",
    audience="service:payments",
))
# result.valid         → True / False
# result.refusal_code  → "PROOF_INVALID" | "REPLAY_DETECTED" | ""
# result.proof_id      → "proof_..."  (for receipt correlation)

Use as a minter + executor (brokered mode, full local proof)

python3 -m pip install -e .
python3 -m actenon.cli up
python3 -m actenon.cli doctor
python3 -m actenon.cli simulate --incident replit

Then protect a real endpoint:

python3 -m examples.refund_guard_local.server --runtime-dir artifacts/local_runtime

Multi-language SDKs

Every SDK runs against the same 51 conformance vectors. See SDK_SELECTION_GUIDE.md.

Framework & platform adapters

The repo ships ranked, ready-to-run examples showing the Kernel wired into the major agent surfaces. MCP is the hero path; the rest are distribution-supporting.

Additional examples (not in the ranked launch set, but production-quality):

Every example keeps the same boundary: the protected endpoint receives an Action Intent + PCCB + local context, verifies proof before any side effect, and returns a canonical Receipt or Refusal. No example requires a hosted control plane.

The incident library — see the gap, then see it closed

The repo ships a local simulator that lets you watch real-world incident patterns unfold, then watch the same pattern get refused at a protected endpoint. Run any of them in seconds:

actenon-kernel simulate --incident replit           # Replit-style destructive DB drift
actenon-kernel simulate --incident prod-delete      # Generic production destructive action
actenon-kernel simulate --scenario mcp-tool-proof-laundering
actenon-kernel simulate --scenario iam-escalation
actenon-kernel simulate --scenario data-export

These pages are source-disciplined: they use incident names as pattern language, not as factual incident reports, and they explicitly do not assert uncited facts about any named incident. They show where the execution gap appears and how a protected Actenon boundary would require preflight, proof, credential brokering, and Receipt/Refusal artefacts before side effects. Use INCIDENT_ANALYSIS_TEMPLATE.md to write your own.

Then open the local Trace Viewer to inspect the Intent Record, Action Intent, PCCB, Receipt, Refusal, replay entries, and protected-endpoint state for any simulation:

actenon-kernel up
# → http://127.0.0.1:8421

The viewer renders local artefacts produced by the repo's existing proof paths — Intent Record, Action Intent, PCCB, Receipt, Refusal, replay entries, protected-endpoint state, and execution flow reconstructed from those artefacts. It requires no hosted services, operator workflow state, or paid-layer runtime infrastructure. See TRACE_VIEWER.md.

Multi-agent execution model

In a multi-agent system, every additional hop between decision and execution creates more room for proof laundering — treating proof, approval state, or "allowed" context gathered upstream as if it were sufficient authorization for a different downstream execution edge. The Kernel's rule does not weaken because an orchestrator "already checked":

Each protected execution edge verifies its own proof before side effects.

A PCCB is bound to a specific audience, tenant, subject, action, target, scope, expiry, and nonce. Forwarding it across an agent boundary does not make it valid for a different tool. Full doctrine in MULTI_AGENT_EXECUTION_MODEL.md.

Key lifecycle & receipt durability

Issuer signing keys move through five states, each with explicit verification semantics:

Hard revoke is used only when key compromise means the issuer's own timestamps can no longer separate legitimate historical artefacts from backdated ones. The Kernel's external-anchor MVP lets a deployment preserve verifiability of historical artefacts even after hard revoke, without changing the issuer-signed bytes. Full lifecycle in REVOCATION_AND_RECEIPT_DURABILITY.md.

Compliance mappings (partial, honest)

The Kernel maps cleanly to the execution-edge portions of common frameworks. It is not a certification, a full crosswalk, or a claim of complete coverage.

Full mapping in COMPLIANCE_MAPPING.md.

Conformance

actenon-kernel conformance run --require-complete
# → 51 tests pass. Mark: Actenon Verified (Conformance 1.0.0)

The active v1 compatibility surface is: Action Intent, PCCB, Receipt, Refusal, Protected Endpoint, Replay. Reserved surfaces (Reconciliation, Policy Bundle) are not active v1 conformance targets. Third-party verifier implementers should target these surfaces and run the same suite. See CONFORMANCE.md.

Audit responses

The repo ships an auditor-readable THREAT_MODEL.md and an AUDIT_RESPONSES.md that ties common diligence questions to specific source files:

• Payload tampering — strict RFC 8785 JCS canonicalisation; floats rejected; duplicate object keys rejected before canonicalisation.
• Clock drift — configurable, validated clock_skew_tolerance on not_before and expires_at; strict zero by default.
• Concurrency replay (double-spend) — atomic transactional claim against a unique replay_key in a durable store, plus mutation lock and monotonicity assertion. Verified under a 32-worker concurrency race: exactly one execution succeeds; the rest are refused with REPLAY_DETECTED.

What the Kernel does NOT do

Actenon gates explicit execution-edge actions; it does not inspect or filter prompts, model output, or in-band response content. It can require proof for an explicit export or transmit action, but it does not stop data disclosed inside ordinary output unless that disclosure is itself modeled and routed as a protected action.

• Issue grants or proofs — that's Permit's job.
• Resolve credentials — that's the broker's job.
• Execute provider calls — that's the adapter's job.
• Manage tenants — that's Cloud's job.
• Inspect prompts, model output, or in-band response content. It is not a prompt filter or general DLP.
• Prove that an upstream policy or approval was correct.
• Prove that a provider executed correctly on its end (it observes the provider response; it does not validate the provider's internal state).
• Stop a malicious or buggy adapter that lies after control passes to it.
• Replace production key custody or HSM-backed signing (the interface is ready; the deployment wires the provider).

The edge guarantee applies only when the protected edge is the only path to the resource, the backend accepts only brokered credentials issued after verification, and the agent has no standing credential or alternate route. Full scope in docs/SCOPE_AND_GUARANTEES.md.

Signing backends

See the signing backends table above for the exact wiring paths. The full production integration guide is in this repo at docs/PRODUCTION_INTEGRATION.md (Apache-2.0, self-contained, does not require actenon-cloud).

What's in this repo

Independence

The Kernel depends only on actenon-protocol. It does not depend on Permit, Cloud, or Scan. A third-party proof that conforms to the Kernel's conformance vectors will be accepted by the Kernel verifier, regardless of who issued it. The verifier makes zero network calls during verification.

License

Apache-2.0 — see LICENSE.