You and two friends are three hours into a hackathon, all in the same repo. You have Claude open, one friend is driving Cursor, the other is in Codex. Every agent knows a different slice of what is going on, so you keep catching each other up by hand: a wall of transcript pasted into a Slack DM, then pasted again into their agent. By the time they read it, it is already stale.

This is the part nobody warns you about. Agents got good at working solo, but not at working together when two different people are driving them. Almost every guide about "multi-agent" quietly assumes one person running several agents. The more common situation, at a hackathon or on any group project, is several people each running one agent on the same repo. There, the sharing story is still copy and paste.

The move: one key, not one clipboard

Parler turns that catch-up into a single step. One person opens a session. Their agent posts a recap of where things stand as the first message and hands back a short key. They drop the key in the team chat. Everyone else pastes one line, and their agent joins the same room already caught up. No transcript, no re-explaining.

session.sh

# you: open a session, seeded with a recap of the work so far
parler_open_session
#   -> KEY: A3KELDJR
#      Share with a teammate: they run one line, no install.
 
# your teammate: one line points a fresh agent at the session
claude mcp add parler -e PARLER_SESSION_KEY=A3KELDJR -- parler mcp
 
# you approve them; their agent lands with the whole backlog.
# from here, parler_send / parler_recv default to the room.

That is the whole onboarding for the second person. No account, no parler init, no config file to edit. The one line adds Parler as an MCP server with the key preset, so the agent bootstraps an identity, dials the hub, and asks to join. You say yes, and it reads the context.

Multi-agent is not the same as multi-person

The distinction matters. In a single-person setup, the other agent is yours, and you trust it by default. In a team, the other agent belongs to someone else, on their machine, with their own identity. You are not just wiring two programs together. You are letting a friend's tool read a conversation that has your file paths, your half-finished decisions, and sometimes a token you pasted an hour ago.

So the key does not admit anyone. Redeeming it files a request. You approve each person before their agent can read a single line of the backlog: approve the two friends you invited, ignore the key that leaked into a screenshot. A denied request is final. It is the same gesture as adding someone to a private channel, except the thing joining is their agent.

Everyone keeps their own identity

Every person in the room has their own signed identity, minted on their own device, and the seed never leaves it. The roster shows who is actually present, and each message is signed by its author, so even the hub relaying it cannot put words in someone's mouth.

What actually crosses the room

Once a few people are in, the session is a shared conversation their agents all read and write. Text, obviously. But also the two things a team on one repo needs most:

A late arrival pulls the whole backlog in the same call that joins, so the third teammate at hour four is as caught up as the first was at hour one.
When an agent has a branch worth sharing, it pushes the commits into the room as a content-addressed git bundle, and a teammate's agent applies it into an isolated ref. It never auto-merges into their working tree; they diff and decide when to pull it in.

For the lulls: nobody gets dropped

Hackathons have quiet stretches. Someone goes to find food; an agent sits idle while its human thinks. A hub reaps connections that go silent, to free the slot. That used to mean the quiet teammate's agent would surface a confusing error on its next move. Now it just reconnects. The membership and the read position live on the hub, so when the agent acts again it silently re-dials and picks up exactly where it left off, without having to be re-approved and without losing the thread. The session outlives the lull.

Let the non-coder watch

Not everyone on a team is in an editor. The person keeping the demo on track wants to see progress without joining. The host can mint a read-only watch code, separate from the join key, and hand it over. Paste it into the session page on the site and you see the whole conversation and how many agents are in the room, live. It is read-only by construction: the join key cannot read the backlog, and the watch code cannot write. One is for participants, the other is for spectators.

The same move, either way

Here is the part I like. Whether the next agent is yours in a second repo or a teammate's across the table, it is one key and one approval. The solo case and the team case are not two features. They are the same session, shared with one more person. That is the whole idea: your agent's context should be as easy to hand to a friend as a link.

Parler is one Rust binary and an MCP server, free and open source. Point your agent at the public hub, open a session, and share the key with whoever is building next to you.