🕸

Holon Fabric

Structured AI knowledge exchange between agents and machines
"Every holon has a destination. Every machine has an inbox."
How it works MCP integration

What is Holon Fabric?

Holon Fabric is the inter-agent communication layer of the Kevin platform. It routes holons — structured markdown knowledge units — between Claude Code sessions, AI agents, and any machine running a Kevin daemon.

Send a spec from your laptop to a build machine. Route a review from one Claude session to another. Deposit a knowledge artifact into an agent's inbox from an email. The channel doesn't matter — the inbox is always waiting.

MCP-native

Seven Claude Code tools for sending, receiving and managing peers. Use holons directly from your session, with no shell or scripts.

Three inbound channels

HTTP POST, filesystem drop folder, and email IMAP. Any route reaches the same inbox.

Cross-machine routing

Target any online Kevin daemon by name. A peer list and the device registry keep the address book, so you never paste URLs into commands.

AI-classified

Inbound email is triaged by the Kevin AI layer into four tiers before it becomes a holon. Noise is dropped.

Observable

Every deposit fires an SSE event. Subscribe to /api/holons/stream (Server-Sent Events) and watch the fabric in real time.


Three inbound channels

Any channel deposits to the same inbox. Your agent doesn't care how a holon arrived.

Channel 1

HTTP POST

Drop structured markdown directly into any daemon's inbox. Works from Claude Code, a script, or any HTTP client. Local or remote.

Channel 2

Drop Folder

Write a .md file to the vault's inbox/holons/ folder. The daemon picks it up from there.

Channel 3

Email IMAP

Send email to your fabric mailbox. The AI classifier reads it, assigns a tier from 1 to 4, and creates a holon for tier 2 and above.

All three channels write to the same vault inbox and fire the same SSE event. Downstream agents see a uniform stream regardless of origin.


MCP integration

Add tools/holon-mcp/server.py to your project's .mcp.json. Claude Code picks up the tools on the next restart.

{ "mcpServers": { "holon": { "command": "python", "args": ["tools/holon-mcp/server.py"], "env": { "DAEMON_URL": "http://localhost:", "VAULT_INBOX": "/inbox/holons" } } } }
holon_send

Deposit a holon locally or to a named machine (to="build-box"). Resolves names via the peer registry.

holon_broadcast

Send to every registered peer at once. Optional targets list to restrict to a subset.

holon_inbox

List holons waiting in the local vault inbox, newest first. Optional since timestamp filter.

holon_receive

Read full content of a specific holon by filename.

holon_machines

List all known peers — from the peers file and the device registry.

holon_peer_add

Register a machine by name. One call — no more raw URLs in commands.

holon_peer_remove

Remove a machine from the peer registry.

Pure standard-library Python, so there is nothing to pip install. Run python tools/holon-mcp/install.py once per machine to wire the MCP entry and seed the peer registry. Restart Claude Code and the tools appear.

Cross-machine routing

Each machine in your fleet runs its own Kevin daemon. Register them by name, then route a holon to any of them:

// From Claude on one machine — send a review holon to another by name holon_send({ content: "# Review: auth module\n\nAll clear on the Grant check...", to: "build-box" // resolved via ~/.kevin/holon-peers.json }) // Broadcast a spec to every known machine at once holon_broadcast({ content: "# Sprint brief\n\nShipping Grant integration by Friday...", targets: ["build-box", "design-box"] // omit targets to hit all peers }) // Add a new machine — no IP hardcoding after this holon_peer_add({ name: "design-box", url: "http://design-box.local:" })

The receiving daemon deposits it to its vault inbox and fires an SSE event. Claude on the receiving machine sees it immediately via holon_inbox.

Peer URLs live in ~/.kevin/holon-peers.json, managed by holon_peer_add. Once registered, a machine is always reachable by name. Run install.py once per machine to seed the file and wire the MCP entry.


Architecture

Holon Fabric sits between the agent layer and the Kevin bus. Holons are the structured artifacts agents produce and consume; the fabric is the transport that gets them where they need to go.

Claude Code (sender) Kevin Daemon (any machine) │ │ │ holon_send(content, target_url) ──────►│ POST /api/holons/upload │ │ └─► vault/inbox/holons/*.md │ │ └─► SSE event → /api/holons/stream │ holon_inbox() ◄────────────────────────│ reads vault/inbox/holons/ │ holon_receive(filename) ───────────────│ reads specific file

Each daemon also exposes GET /api/holons/stream as a Server-Sent Events endpoint. Any subscriber — Mona, another daemon, a script — can watch the fabric in real time.


Part of the Kevin platform

Part of Kevin
Holon Fabric sits alongside the bus, the vault, retrieval and fleet monitoring.