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 the 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.

Guarantee precondition: the edge guarantee holds 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. If those conditions are not met, the Kernel still refuses invalid proofs — but it cannot prevent a caller that bypasses it from reaching the resource. Full scope in docs/SCOPE_AND_GUARANTEES.md.

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