allocmemory

How to manage agent communication

November 19, 2026

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:

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.

RecipeWhere the router runsWho it's forIdentity comes from
stdinside the daemon on your machineone machine, many agentsyour user account
otwon one of your machines, over Tailscaleone person, several machinesTailscale
cloudyour own server or AWS accounta teamGitHub 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:

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:

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.