# Actenon Kernel MCP server

> Verifies proof-bound consequential AI actions at the execution edge to ensure authorized intents are not mutated or replayed.

- Repository: https://github.com/Actenon/actenon-kernel
- Page: https://hostedmcp.org/servers/actenon/actenon-kernel
- Transport: stdio
- Stars: 2
- License: Apache-2.0
- Latest version: 1.2.2

## Install

### Claude Code

```sh
claude mcp add actenon-kernel -- uvx actenon-kernel
```

### Cursor (`~/.cursor/mcp.json`)

```json
{
  "mcpServers": {
    "actenon-kernel": {
      "command": "uvx",
      "args": [
        "actenon-kernel"
      ]
    }
  }
}
```

### VS Code (`.vscode/mcp.json`)

```json
{
  "servers": {
    "actenon-kernel": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "actenon-kernel"
      ]
    }
  }
}
```

### VS Code CLI

```sh
code --add-mcp '{"name":"actenon-kernel","type":"stdio","command":"uvx","args":["actenon-kernel"]}'
```

### Claude Desktop (`claude_desktop_config.json`)

```json
{
  "mcpServers": {
    "actenon-kernel": {
      "command": "uvx",
      "args": [
        "actenon-kernel"
      ]
    }
  }
}
```

### Codex

```sh
codex mcp add actenon-kernel -- uvx actenon-kernel
```

### Codex config.toml (`~/.codex/config.toml`)

```toml
[mcp_servers.actenon-kernel]
command = "uvx"
args = ["actenon-kernel"]
```

### Gemini CLI

```sh
gemini mcp add -s user actenon-kernel uvx -- actenon-kernel
```

### Gemini settings.json (`~/.gemini/settings.json`)

```json
{
  "mcpServers": {
    "actenon-kernel": {
      "command": "uvx",
      "args": [
        "actenon-kernel"
      ]
    }
  }
}
```

## Tools (4)

- `actenon_verify`: DEMO MODE — ephemeral key, not for production. Verify an Actenon proof (PCCB) against an exact action intent and return the typed outcome. This is pure verification: it performs no side effect, consumes no replay state, and emits no receipt. Use it to ask 'would this proof be accepted for this exact action?'. Returns outcome VALID or INVALID with a machine reason_code and a human-readable reason.
- `actenon_gate`: DEMO MODE — ephemeral key, not for production. Evaluate an action intent at the execution edge and return ALLOW or a typed refusal. This is the enforcement path: it verifies the proof, consumes single-use replay state, and emits a hash-chained Receipt (on allow) or Refusal (on deny) retrievable via actenon_receipt. Call it WITHOUT a proof to see the default-deny behaviour and the exact reason. When retrying with a proof, pass back the `intent` it was issued for — a proof is bound to one exact intent. The proof must come from your trusted host or authority broker; a model must never mint its own authority.
- `actenon_receipt`: DEMO MODE — ephemeral key, not for production. Return the hash-chained Receipt or Refusal artifact for a prior decision made by this server, addressed by receipt_id or refusal_id. Each log entry commits to the previous entry's hash, so a caller can detect a rewritten history. Call with no id to list the chain.
- `actenon_demo_grant`: DEMO MODE — ephemeral key, not for production. Issue a proof scoped to one exact action. This tool exists ONLY in demo mode and is ABSENT from a production server: in a real deployment the grant comes from your authority broker (actenon-permit) after human approval, and the verifier never issues its own authority. It is here so a single connected client can walk the full refuse → grant → retry → receipt loop offline.

## FAQ

### Does the kernel make policy decisions?

No, the kernel is a verifier that defines what a valid proof is and verifies proofs at the execution edge, but it issues no grants or policy decisions.

### Where can the kernel be integrated?

It can be integrated at the agent framework level (such as LangChain or MCP tools) or independently at the resource boundary like a FastAPI or Express route.

### What languages are supported?

The kernel provides a Python reference implementation along with verifier SDKs for TypeScript, Go, and Rust.
