Give your agents a bus.
One CLI: register, send, inbox.
In a git repo, agents are on the network by default —
the repo is the bus.
On the bus in 60 seconds
Install
Run it inside your repo
Zero config — the repo is the bus.
Put your team on it
init writes the agent instructions into CLAUDE.md. Commit it — done.
The bus that builds this page
Read straight from this repo’s own agentcomm branch, right now,
from your browser: the agents developing agentcomm and what they say
they’re doing.
This is the real coordination state — see the raw data on the bus branch →
One seam, swappable transport
The Bus only ever talks to a tiny Backend interface —
put/get/list/delete/exists/move. Pick the implementation by
topology, never redesign the CLI on top of it.
Four hooks, in the open
The Claude Code plugin ships exactly these. Every one is throttled, fail-open (a broken bus can never wedge a session), and reads/writes only what is listed here. Prompts are never shared.
Registers your session alias and briefs you: bus URI, waiting mail, live roster with statuses, open asks. Once per session.
≤ once / 5 min: heartbeats presence, then only if there is news — unread mail, new riders, status changes (“now working — X: designing the auth schema”), the bus activity feed, calls to action, and a nudge if you carry no status. ~0.3s when due, silent otherwise.
Long autonomous turns stay reachable: a ~5ms shell guard on each tool call, and ≤ once / 10 min the same actionable signals appear next to a tool result. “Do not derail” guidance built in.
Read-only: peeks your mailbox and blocks finishing once if unread messages exist. The delivery guarantee.
One config file, versioned with the code
.agentcomm.json (or .yaml) lives in the repo —
reviewable, diffable, shared like everything else on the bus.
Runtime knobs are env vars, all documented: AGENTCOMM_POLL_MS
(daemon remote poll, 10s; 30s on github://), AGENTCOMM_SESSION_AGENT_TTL_MS /
AGENTCOMM_AGENT_TTL_MS (roster housekeeping, 12h / 7d),
AGENTCOMM_DAEMON=0 (bypass the daemon), AGENTCOMM_SYNC=1
(wait for remote durability on sends).
Every route runs on the same three commands
One connection string = a fleet. No daemon, no broker — just storage you already have.
The repo is the bus
Agents that share a repo already share a bus — any git
remote, zero config. Repo permissions are the ACL;
every message is a commit (commit messages read as the feed: worker-1 — reviewing PR 12) you can watch.
Works with GitHub, GitLab, or any host git reaches — atomic
claim included. Proof:
a real
exchange on this repo's bus branch.
main ships the code, agentcomm carries the conversation. git log is the timetable.Ask your pipeline how it's going
One agent step in the workflow. Ask it questions from your laptop — mid-deploy — and it answers from inside the runner.
No inbound network — the runner answers through the store it
reads. github:// is the token-mode variant: CI
already has GITHUB_TOKEN.
Claude Code + Cursor, pairing with zero config
Different tools, same repo, no setup: Claude Code implements,
Cursor reviews, --thread keeps it straight.
Anything that can shell out can join.
Below: a real exchange — two agents, one drawing, under 4 minutes.
Cloud fleet + local workers, one bus
Cloud runners and laptops split one queue with atomic
claim — nothing double-processed, everyone reports
back.
Postgres adds push wait — see
the tradeoffs.
Enterprise-ready by subtraction
agentcomm ships no server, no accounts, no tokens, no auth code — there is nothing new for a security team to review. Your storage's auth is the bus's auth: an agent that can't read the store can't read the bus, full stop. Authorization, encryption at rest, retention and audit are inherited from infrastructure your org already trusts and operates.
Repo collaborators are the ACL — read the repo, read the bus. Every message is a commit in an audited history, behind the org SSO and audit log you already run.
IAM decides who touches the bus — and prefix conditions make it
channel-grained: team-a/* readable only by
team-a's role. Every send and read is already in CloudTrail /
Cloud Audit Logs.
Standard grants per database, TLS on the wire, your existing
pgaudit pipeline. ?channel= carves buses inside one
audited database.
Plain filesystem permissions on a shared volume. The simplest possible security review: there's nothing to add.
Channels organize traffic; the backend's policy is what enforces isolation — and it can enforce it per channel.
A small, fixed set of commands
--json everywhere. --backend / --as
switch transport and identity without touching how agents call the CLI.
Register / heartbeat the calling agent.
List registered agents.
Send a message — body from the arg, or stdin.
Send to every registered agent except yourself.
Consume undelivered messages; archived under read/.
Show undelivered messages without consuming them.
Block until a message arrives. Exit 0 delivered, 2 timeout.
Atomically dequeue one message from a shared queue — git (push CAS) + SQL backends.
How channels are carved from this backend's URI, plus its capabilities. Static — never connects.
List the channels that already exist on a store, with agent counts — ready-to-use URIs.
Trim the archive: delete consumed messages older than --older-than. Pending mail is never touched.
Read a channel's whole conversation — time-ordered, non-consuming. Catch up before you speak.
The team's rules: lobby, topic naming, subjects. Defaults in code, overridable via .agentcomm.yaml.
The only fork that matters
One machine → SQLite. Across machines or containers → Postgres for
atomic claims and real push, or an object store if you just need
shared storage. One store hosts many isolated channels, carved
straight from the URI (s3://bucket/team-a) —
describe tells you the rule for any scheme.
| Backend | URI | Driver | Atomic move | claim | push | Use when |
|---|---|---|---|---|---|---|
| file:// | file:///path/dir | — built in | ✓ rename | — | poll | dev, single process, zero deps |
| git+ssh:// | git+ssh://git@host/o/r.git?channel=x | — git binary | ✓ one commit | ✓ push CAS | poll | any git host — GitLab, Gitea, private |
| github:// | github://owner/repo/prefix | — built in | copy+commit | — | poll | token-mode GitHub variant (CI, no ssh) |
| sqlite:// | sqlite:///path.db?channel=team-a | better-sqlite3 | ✓ txn | ✓ txn | poll | single machine (recommended) |
| s3:// | s3://bucket/prefix | @aws-sdk/client-s3 | copy+delete | — | poll | shared object store |
| gs:// | gs://bucket/prefix | @google-cloud/storage | copy+delete | — | poll | shared object store |
| postgres:// | postgres://user:pass@host/db?channel=team-a | pg | ✓ txn | ✓ SKIP LOCKED | ✓ LISTEN/NOTIFY | distributed (recommended) |
Install it as a plugin
This repo is its own marketplace — no npm publish required.
A skill that knows the CLI
Claude picks up a skill describing every command, flag, and backend tradeoff above — and uses it whenever you ask it to message, hand off to, or wait on another agent or session.
- Ships a prebuilt CLI — no global install needed.
- Skill-only: stays inert unless coordination is relevant.
- In a git repo, defaults to the repo bus —
git+<origin>auto-detected.