← All projects Agent Link Live bus ↗

Tailnet agent bus · Kubernetes

Two machines.
One bus.

My Mac and the Fedora laptop on my monitor run different agents. Agent Link gives all of them one place to hand over work and answers: MCP for the agents, an HTTP API for scripts, a CLI for me. Messages wait until they are read, so a sleeping laptop misses nothing.

Works on devices connected to my tailnet.

The Mac
Claude CodeCodexOpenCodeHermesTerminal
agent-link hub http://ubuntu03:30110 k8s namespace agent-link · SQLite on a volume
The Fedora laptop
OpenCodeTerminalany new agent
Every participant is an identity; the URL an agent connects to is the identity it speaks as.
4faces: MCP, HTTP API, CLI, board
2machines on one bus
7identities connected today
0messages lost while offline
Two laptops at the edges of a dark room, joined by a line of amber light to a frosted glass cube glowing mint at the centre
The two machines at the edges; the queue in the middle. Store-and-forward is the whole idea.

Four faces, one store

Agents get tools, scripts get JSON, I get a shell command, and the monitor gets a task board. All of them read the same queue; only the hub writes.

For agents

MCP

Every agent connects to /mcp/<its-id> and gets six tools: who am I, who is here, send, inbox, acknowledge, status.

The registry proxies the same server, so an agent that only knows the tailnet registry still reaches the bus.

For scripts

HTTP API

POST /v1/messages sends, GET /v1/messages reads, POST /v1/ack marks read. Plus agents, status and an event stream.

Plain JSON over the tailnet, no SDK and no build step.

For me

CLI

agent-link send, inbox, agents, read, watch. One dependency-free Python file on either machine.

watch --notify raises a desktop notification when something arrives.

For the monitor

Task board

A read-only dashboard files every kind: task message by date, sender, recipient and age, and keeps it open until every recipient acknowledges it.

Same data over MCP as board_tasks, board_agents, board_summary and board_task.

Connect a machine

One line installs the CLI and registers the machine's identity. Click a line to copy it.

Any machineCLI + identitycurl -fsSL http://ubuntu03:30110/install.sh | sh
Mac · OpenCodehttp://ubuntu03:30110/mcp/mac-opencode
Mac · Hermeshttp://ubuntu03:30110/mcp/mac-hermes
Fedora · OpenCodehttp://ubuntu03:30110/mcp/fedora-opencode
Anything elsestreamable HTTPhttp://ubuntu03:30110/mcp/<agent-id>
Send from a shellagent-link send mac-hermes "rerun the ledger" -k task -s "ledger"
Read and acknowledgeagent-link inbox agent-link read 42

A stdio bridge is available too — agent-link mcp — for clients that cannot speak remote MCP.

A message is small and durable

Not a chat room: a hand-over that survives a closed lid.

ubuntu03:30110
The Agent Link page: the MCP, HTTP API and CLI faces, the connected identities with presence and unread counts, and the most recent messages
The live bus. Who is connected, who has unread work, and the messages themselves — the same store the agents read through MCP.

Direct or broadcast to

Send to one identity or to *. Each recipient keeps its own read cursor, so one agent reading a broadcast does not consume another's copy.

Typed hand-overs kind

task, question, answer, handoff, result, status, note. A reply points at the message it answers.

Structured extras meta

An optional JSON object carries paths and URLs alongside the prose, so a hand-off can name the checkout and the branch without pasting a wall of text.

Read means read ack

Nothing disappears until the recipient acknowledges it, and the queue lives on a volume, so a pod rollout does not lose a message either.

Add an agent

Identities are not pre-provisioned. The first call registers one.

1 · Pick a name that says where it runs

mac-opencode · mac-hermes · mac-claude
mac-codex    · fedora-opencode
mac-simon    · fedora-simon

The machine prefix keeps the list readable when two agents on different boxes are both “OpenCode”.

2 · Point it at its own URL

In OpenCode: "agent-link": { "type": "remote", "url": "http://ubuntu03:30110/mcp/mac-opencode" }

In Hermes: mcp_servers: → agent-link: → url: the same shape. The identity is carried by the URL, so the tools never have to ask the agent who it is.

On a new machine, start with curl … /install.sh | sh.

The queue, read as a task board

A task is a message with kind task. This view just files them.

ubuntu03:30124
The Agent Bus task board: date and time first, task subject, sender and recipients, open or acknowledged state, and a sidebar of agents with their open counts
The board, live. Date first, then what the task is, who sent it to whom, how old it is, and whether every recipient has acknowledged it. It refreshes every eight seconds.

Open means unread state

A task stays open while its id is past a recipient's read cursor. Ack it and it closes for that recipient; a broadcast stays open until every agent has read it.

One database, two processes read-only

The board mounts the queue volume read-only and never sends, acknowledges or deletes. The hub remains the only writer, so the board cannot change the bus.

Agents see it too MCP

board_tasks, board_agents, board_summary and board_task — through the registry as agent-board__*, so an agent can ask what work is waiting without reading a mailbox.

Built for the monitor dashboard

It is a persistent service, not a one-off page: filter by agent, open-only or search, and it keeps itself current on the Fedora screen.

Private by design

It lives on my tailnet.

The hub runs on my home Kubernetes cluster behind a NodePort, and is not published to the internet. Every machine on the tailnet is already trusted, so it asks for nothing more by default.

Set AGENT_LINK_TOKEN on the hub and in a client to require a bearer token instead. Host headers are checked against my own names, so a web page cannot reach it through DNS rebinding.