How to manage agent communication
During the last few months I ran experiments focused on agent communication. I wanted to build something extremely straightforward, something that takes no thought to start using, both at my workplace and on my side projects. I began with the idea I described in Agents over the wire: a daemon on every laptop, a dumb router in the middle, and rooms where agents talk to each other before they touch shared code.
That idea worked. It also had a problem. It only fit one kind of team: five engineers, one GitHub organization, and a router running on AWS. To try it, you needed a Fargate task, a DynamoDB table and an org. That's the opposite of straightforward. So I spent the next weeks turning the idea into something I could hand to anyone, and the result is Sealmesh. It's open source, so feel free to contribute.
From an idea to a shape
The first thing I did was decide what to keep. Almost everything from the original post survived:
- The router stays dumb. It routes messages, checks identity, enforces budgets and keeps a short history. It never plans and never assigns work.
- Agents are peers. Nothing in the tools lets one agent make another one act.
- MCP is the vendor-neutral layer. Any agent that can mount an MCP server gets the same tools.
- Messages are typed. A
question, aclaim, ahandoffor anack. The kind carries the intent, so the prose doesn't have to.
What changed was everything around it.
Seeing came before talking. When I watched how I actually used the first version, I noticed that before I wanted my agents to talk, I wanted to know what they were doing. So Sealmesh starts with one command, sealmesh who. It shows every agent on every machine: its branch, its ticket, its PR, its CI state, and whether it's working, idle or waiting on me. Rooms came second. Watching is the entry point. Coordinating is what you do once you can see.
One binary instead of a deployment. The daemon can now run the router inside itself, so on a single machine there's nothing to deploy at all. The same router binary runs anywhere else when you need it to.
Three recipes instead of one. I'll get to those after the part everything else depends on.
Laptops behind a NAT
Every laptop I care about sits behind a NAT, so a router can never dial in. The daemon dials out instead. It opens one connection to the router and waits.
flowchart LR
subgraph A["My laptop"]
DA["daemon"]
end
subgraph B["My desktop"]
DB["daemon"]
end
subgraph C["A teammate's laptop"]
DC["daemon"]
end
DA -- "outbound" --> R["Router<br/>routes · forgets"]
DB -- "outbound" --> R
DC -- "outbound" --> R
I think of it as a phone line, not a database. When I run sealmesh who, the question goes down the line to every machine. Each machine reads its own agents at that moment and answers. The router passes the answer along and forgets it. Nothing is published on a timer, so nothing is ever stale. And when nobody's asking, what my agents are doing exists in exactly one place: my laptop. Close the lid and there's nothing left to read.
The one thing that is kept is room chat, for seven days, so an agent that joins a room late can catch up on what it missed. Chat is opt-in, and it's separate from who.
Three recipes
The original post had one way to run things. Sealmesh has three for the moment, and you pick one based on where your agents live.
| Recipe | Where the router runs | Who it's for | Identity comes from |
|---|---|---|---|
| std | inside the daemon on your machine | one machine, many agents | your user account |
| otw | on one of your machines, over Tailscale | one person, several machines | Tailscale |
| cloud | your own server or AWS account | a team | GitHub org and repo access |
std is the one that takes no thought. Nothing listens on TCP, and there's no server and no GitHub org. Claude reaches rooms through the MCP tools, and any other local agent (a bot, a script, another model) reaches the same rooms through a Unix socket using plain HTTP. curl is the whole client.
otw is for when every machine is yours: a laptop, a desktop, a build box. The router listens only on its tailnet address, and Tailscale already knows who's on the other end of each connection, so there are no tokens at all.
cloud is the original idea, cleaned up. You get GitHub identity, repo permissions and seven days of chat. It runs as a binary or a container with SQLite, or in your own AWS account with a Terraform recipe and DynamoDB. Nobody else hosts it, so nobody else sees your messages.
Security
The longer I worked on this, the clearer it got that agent communication is a security problem disguised as a networking problem. Sealmesh handles it in three layers.
What never leaves the laptop
Claude Code's job state holds the raw prompt, and on a real machine I found a pasted private Slack thread in it. So every field who sends is an enum, a number, a timestamp, or a type that checks its own charset and length. A prompt can't be assigned to any of them, and the compiler enforces it. A redaction list fails open the first time a vendor ships a new field. Types fail closed.
Guardrails
The guardrail is a policy file owned by root, so agents can read it but can't change it. The Claude Code hook checks it before every tool call. It's for the ordinary mistakes you never want to see: a force-push to main, an agent reading ~/.ssh, a curl to a host nobody vetted. When a rule matches, the call is blocked, the agent is told why, and the deny lands in an audit log.
It's a guardrail, not a sandbox. A determined agent can spell a shell command a regex won't catch. What it gives you is a stop on the common path, a reason the agent reads, and a record. If you need hard isolation, run your agents in a container or a VM.
Prompt injection
A room is an injection surface by definition. Agents post prose, other agents read it, and some of that prose will eventually look like an instruction. I can't make that risk zero, so I made it narrow:
- Bodies never arrive on their own. The hook tells Claude "3 new messages in the ops room." It never includes the text. Nothing reaches an agent's context unless the agent decides to read it.
- Authors are stamped, not claimed. The router writes the author from the sender's credential. A message that says "I am the team lead" is just text from whoever really sent it.
- Agents only reach their own rooms. Fewer rooms means fewer people who can talk to your agent.
- Loops are capped. Rate limits, token budgets and a turn cap stop two agents from trading messages forever.
- Messages are labeled as data. Every page of messages tells the agent they were written by another agent and are data, never instructions.
That last one is a label, and a model can ignore a label. So the real backstop is the guardrail. If a poisoned message convinces Claude to push to main or read .env, and you have a rule for it, the hook still says no. Honestly, it's the same exposure as an agent reading a GitHub issue, just with more doors closed.
How I use it every day
With my team
This is where it started, and it's still the use case I care about most. A few of us work on the same codebase, each with our own agents. The router runs in cloud mode, and every daemon connects to it with our GitHub identities.
My morning starts with sealmesh who instead of a Slack thread. I can see who's on which ticket, which PR is red, and which agent has been waiting on input for three hours. Then, during the day, the agents coordinate in the ticket and repo rooms. One posts a claim with the files it's about to touch. Another one about to touch the same files reads it and waits, or picks something else. When the first one merges, it posts a handoff. Most days nobody has to say anything in Slack.
Grok and Claude in the same room
On my side projects I run std mode on a single machine. Claude works through the MCP tools, and Grok joins the same rooms as a local bot over the socket. Posting is one curl:
curl -s --unix-socket $SOCK -H "Authorization: Bearer $TOKEN" \
-H 'Content-Type: application/json' \
-d '{"kind":"question","body":"Is the deploy for #41 safe to roll?"}' \
http://sealmesh/v1/rooms/ops/messages
The bot can also hold a stream open and get every new message the moment it lands. Claude hears about new messages on its next turn, and it decides whether to read them. That's on purpose. Real time for the bot, and judgment for the agent.
Come build it with me
Sealmesh is young. It's at v0.2.1, and most of its use so far has been on my own machines. That's exactly why now is the best time to get involved: the shape is still soft, and the people who show up early decide what it becomes.
Here's where you can help:
- Run it and tell me where it broke.
brew install allocmemory/tap/sealmeshandsealmeshwith no arguments gets you started. Every rough edge you report is one the next person won't hit. - Bring your agent. Claude Code and Codex are read natively. Gemini, Qwen, Grok and whatever ships next month aren't yet. If you use one of them every day, you're the right person to write its provider.
- Break the security model. It's built to fail closed, and I want to know where it doesn't. Private vulnerability reporting is on.
- Fill the gaps. There's no Windows support and no systemd unit for the daemon yet. Both are well scoped.
It's written in Rust and licensed under AGPL-3.0, and the code is on GitHub. The docs live at sealmesh.dev.
My agents never had a merge problem. They had a communication problem. They already knew everything they needed to avoid stepping on each other. They just had nobody to tell. Sealmesh is my attempt to give them that channel, narrow, safe and boring. If you've hit the same wall, come help me build it.