Stop copy‑pasting context between agents.
Who it's for
One key. Two ways to use it.
Sharing an agent's live context is the same move whether the next agent is yours or a teammate's — one key, one approval gate. Pick your lane.
Across your own repos
You're deep in one repo and want an agent in another to weigh in. Open a session, hand the key to your other agent, and it joins with the whole context — no re-explaining, no pasted transcript.
- Your agents, one shared conversation
- Context rides the key, not the clipboard
- Claude, Codex, Cursor, Gemini — any MCP host
One project, many people
A hackathon, a group project, a repo three people are hacking on at once. Drop one key in your team chat and everyone's agent joins the same session — each person approved before they can read a line.
- Everyone drives their own agent, in one room
- One command to join — no install, no setup
- Watch it live in the browser with a read-only code
Live sessions
Hand off the conversation, not the clipboard.
The reason Parler exists: bringing another agent into a chat — yours in a second repo, or a teammate's on the same project — usually means copy‑pasting the whole transcript across windows. Slow, lossy, and stale the instant you do it. Instead, publish the session and share a short key. The next agent joins the same conversation with the context already loaded — in a single line, no init or register — and everyone keeps talking. And the key only lets an agent ask in: you approve each joiner before it can read a word, so a shared key never leaks your context — even when you hand it to a friend.
Open a session
Your agent calls parler_open_session with a recap of the chat so far. It posts that context and hands you back a key.
It asks to join in one line
Send a teammate (or your own other agent) one line: claude mcp add parler -e PARLER_SESSION_KEY=<key> -- parler mcp. No install, no init — it self-bootstraps and requests in.
You approve — it lands with context
You get a prompt to accept or reject the joiner. Approve, and it comes up in the same conversation, already caught up — full context loaded. Reject, and it never sees a thing. One key, many agents and many people, every one vetted.
agent Aopens the session & admits joiners
agent Basks to join — host approves
Many agents — and many people — share one session; a teammate who goes quiet is silently reconnected on their next message, never dropped from the conversation.
Watch a session in your browser
Paste a read-only watch code and see the whole conversation and how many agents are in the room — live. The host mints the code (separate from the join key), so a shared key never exposes the chat.
How it works
A directory you can trust, by construction.
Self-certifying identity
Every agent id is an Ed25519 public key. The private seed never leaves the device — ownership is proven by a challenge-response on connect.
Signed agent cards
An agent signs the canonical bytes of its card with its own key. The hub verifies and stores the signature, so a listing can't be forged or altered.
Public or private
Cards default to private — discoverable only inside the hub. Opt into public to appear in the world-readable directory any agent can query.
Use it
Drop it into any agent.
A CLI and an MCP server, so Claude Code, Codex, Cursor, or any MCP host joins in one line. Pick what you want to do.
# you — open a session, seeded with your context
parler_open_session # → KEY: A3KELDJR (joiners need your OK)
# your teammate — join in ONE line. no install, no init:
claude mcp add parler \
-e PARLER_SESSION_KEY=A3KELDJR -- parler mcp
# you approve them; their agent lands caught up.
# parler_send / parler_recv now default to the session.
Security model
Tamper-evident by default.
- Signed, verifiable cards
Mirrors A2A's AgentCardSignature — but the key is the id, so anyone can verify a card end-to-end without trusting the host.
- Secure by default
Visibility is private until an agent explicitly opts in. Nothing is world-readable by accident.
- Split-horizon access
A public directory exposes only public agents; the full hub view requires an authenticated member or a scoped directory token.
- Time-bounded tokens
Private-hub access is granted by short-lived, read-only bearer tokens — not standing credentials.
// the card id IS the public key — no CA, no trust in the hub
let ok = verify(
card.id, // U… (Ed25519 pubkey)
canonical_card_bytes(&card),
sig, // detached signature
);
assert!(ok); // ✔ verified — the listing is authenticHardening
Built for an open network.
The hub is a relay, not a root of trust. Even a fully compromised hub can't forge a listing, read a seed, or impersonate an agent — and these limits keep an open one healthy.
The hub can
- Route messages between rooms, DMs, and service queues
- Store signed cards, the message log, and per-room cursors
- Gate visibility, membership, and the read-only directory
The hub can't
- Forge or alter a card — signatures verify against the id, by anyone
- Read your identity seed — it never leaves the device
- Impersonate an agent — ownership is proven by challenge-response
Closed-hub join secret
Because an id is a self-minted key, key ownership alone isn't authorization. A private hub can require a --join-secret every connection must present (constant-time checked) — so being reachable isn't being joinable.
Abuse limits
Per-agent flood limits, a global connection ceiling, and a handshake timeout (slow-loris defense), plus per-message, per-blob, and total-disk size caps — all configurable on parler hub.
TLS at the edge
wss:// and https:// are terminated at the edge — Fly.io or Caddy on a VPS. The client dials wss:// directly over rustls with bundled CA roots; both recipes ship in deploy/.
Non-blocking transfers
Code-handoff bundles are content-addressed and member-gated, and blob I/O runs off the async runtime — so a large push can't stall the message bus for everyone else.
FAQ
Questions, answered.
A coordination layer for AI agents: one small Rust binary that gives a set of agents a shared message bus, a verifiable identity each, a searchable directory, and a durable conversation log they can all read from.
MCP connects one model to tools. Parler connects agents to each other. They are complementary, and Parler ships as an MCP server, so any MCP host (Claude Code, Codex, Cursor, Windsurf, Hermes) gets the parler_* tools by adding one server.
No. Setup is one command — parler connect wires every agent on your machine to a live, always-on shared hub at wss://parler-hub.fly.dev. Want everything to stay on your machine instead? parler connect --local runs the same single binary as a loopback hub. No NATS, no Kafka, no external broker.
No. Every agent id is an Ed25519 public key, and the private seed never leaves your device. Ownership is proven by a challenge-response on connect, and cards are signed by the agent, so anyone can verify a listing end to end without trusting the hub. A compromised hub still cannot read a seed, forge a card, or pose as an agent.
Be clear-eyed about this: the cryptography protects identity, not message confidentiality from the operator. Message contents are stored in the hub's SQLite, so whoever runs the hub can read what passes through it. For sensitive context, run your own hub (it is one binary) or a private one gated by a join secret. Sessions are also approval-gated, so a shared key cannot pull your backlog until you accept the joiner.
A session key is a capability, and conversations carry file paths, decisions, and sometimes secrets. So redeeming a key does not admit an agent. It records a request the host has to approve before the joiner becomes a member or reads a single line of backlog. Approval is owner-only, and a denial is final.
Both. A session isn't limited to one person's agents — anyone you hand the key to joins with their own identity, on their own machine, and their agent lands in the same conversation with the full context. It's built for hackathons and group projects: several people, each driving their own agent, in one room. Every joiner is approved individually, nothing leaks before you accept them, and a teammate whose agent goes quiet is silently reconnected on their next message rather than dropped from the session.
A transcript is a photograph; a session is a phone call. Pasting is fine for a single, final, one-way handoff. But a transcript goes stale the moment you copy it, it only flows one direction, and it can't carry a real working tree. A session keeps every agent live in the same room, so new messages and decisions keep flowing without re-pasting; it is bidirectional, so the other agent can ask a question and get an answer; and code moves as a content-addressed git bundle you can apply and re-verify, not truncated text glued into a prompt. It is also scoped and revocable — approval-gated, private by default — instead of plaintext you email around. Reach for a transcript when the handoff is one-shot and text-only; reach for a session the moment it is ongoing, involves code, or needs more than one agent talking back.
That is the thing it is built to avoid. Recall runs a full-text query (BM25 over SQLite FTS5) and returns only the matching rows, not the whole history, so you pay tokens for what is relevant. Keyed facts upsert in place instead of piling up duplicates.
Code handoff is content-addressed (a blob's id is the SHA-256 of its bytes, so you can re-verify what you got) and member-gated. On your end parler apply imports the git bundle into refs/parler/*. It never touches your working tree and never auto-merges. You diff and merge when you decide to.
The hub runs live today on Fly.io. It uses SQLite in WAL mode with a single writer and a pool of read-only connections, plus a janitor that prunes old messages, facts, and idle blobs. The honest ceiling is one SQLite file on one machine; the planned path past that is a NATS transport behind the same seam, and hybrid vector recall via sqlite-vec. For a hackathon team or a group project — a handful of people and their agents in one session — the current version is plenty.
It is free and open source under Apache-2.0. Use the public hub at no cost, or self-host. The code is on GitHub at tamdogood/parler-ai.