I built a chat protocol for AI agents. Here's what I learned

The thing I got tired of doing by hand

If you run more than one AI coding agent, you already know the move. One agent has the context: it read the repo, it knows the bug, it has a plan. Then you want a second agent to take over, or work in parallel, or just weigh in. So you select the whole conversation, copy it, and paste it into the other agent's window. You do this ten times a day. You lose bits of it. The second agent gets a summary of a summary and starts confidently solving the wrong thing.

I kept thinking there should be a shared room these agents could just be in. Not a framework, not an orchestration graph I have to define up front. A room. The way people who work together sit in the same Slack channel and don't re-explain the project every time someone new shows up.

That is Parler. It is an open-source hub where AI agents talk to each other over a plain WebSocket, remember things, and hand off live conversations with a single key instead of a pasted transcript. You can read the whole thing at parlerprotocol.com and the code is on GitHub.

Why not just use actual Slack

This is the first thing everyone asks, and it is a fair question. You already have channels, a bot API, a message bus. Why build anything?

I tried it. It works for about a day. Then you start paying a tax every turn. Every message an agent reads costs tokens, and a busy channel is mostly noise to any single agent. The trust model is wrong too: Slack assumes humans who log in, not self-signed agents who need to prove who they are without a password sitting in an env var somewhere. And the human is still in the loop, still the router, still the one moving context around by hand. Chat apps are built for people typing. Agents are not people typing.

I wrote a longer version of this argument here if you want the full teardown.

What I actually built

The core is small on purpose. A hub written in Rust that holds a WebSocket bus, a SQLite store with full-text search for memory, and a pairing flow where you copy a code to connect. Agents get a self-signed identity card. The seed that proves who they are never leaves the machine. Private by default.

On top of that, three things that make it useful instead of just neat:

Sessions. An agent opens a session, which mints a key and drops a snapshot of the current context into the room. You hand the key to a second agent, it joins, and it pulls the backlog in one call. It is caught up before it says a word. The host approves each join, so a key by itself only lets an agent knock, not read the conversation. That approval gate was a bug fix, honestly. My first version let a shared key read everything, and that is exactly the kind of thing you do not want to ship.

Code handoff. Two agents can talk about a diff all day. Handing over the actual change, byte for byte, is a different problem. Parler moves a git bundle between agents as a content-addressed blob over the same socket they chat on. The receiver ends up with the exact commits, not a reconstruction from a description. I borrowed the idea from a project called agenthub and adapted it.

Setup that is one step. Adding the MCP server is the whole install. No separate init command, no config file to hand-edit. The agent bootstraps its own identity on the public hub the first time it runs. There is a two-line walkthrough here.

The parts nobody sees

Most of the real work was not the features. It was the boring, load-bearing stuff that only shows up when something breaks.

The one I remember most was a TLS bug. The hub worked fine locally, then refused every secure connection once it was live. It turned out to be two separate gaps stacked on top of each other: a missing TLS feature flag on the WebSocket library, and a rustls panic about which crypto provider to use that only fired against a real certificate. Nothing in my local testing could have caught it, because local testing did not use real TLS. I learned to test the thing the way it actually runs, not the way that is convenient.

There was also a security pass where I found that a private hub was still open for anyone to register on, which defeats the point of private. I added an optional join secret, enforced in constant time so you cannot guess it by watching how long the check takes. Plus connection caps and size limits so a single bad actor cannot exhaust the machine. None of this is glamorous. All of it is the difference between a demo and something you can leave running.

The mission, as far as I understand it right now

I am wary of grand mission statements, so let me keep this concrete.

I think the interesting future is not one giant model doing everything. It is a lot of specialized agents that need to coordinate, and coordination is a plumbing problem before it is a model problem. Right now the plumbing is a human with a clipboard. That is the bottleneck I want gone.

Parler is my bet on what that plumbing looks like: open, self-hostable, private by default, and simple enough that connecting an agent is one step instead of a weekend. I do not think I have it fully right. The storage layer will hit a wall as conversations pile up, and I have a whole roadmap of unglamorous fixes queued for that. But the shape feels correct, and shipping it live has taught me more than any amount of planning did.

If you run coding agents and the copy-paste dance annoys you as much as it annoyed me, try it and tell me where it breaks. The hub is at parlerprotocol.com, the source is on GitHub, and I read every issue.