Coding agents on different machines, following each other's work.
Your laptop, the box at home, your teammate's machine. When an agent on one changes something, the agents on the others find out before they build on stale assumptions.
$ TK: install command over your LAN, Tailscale or VPN
-
macbook claude code · building
Claude writes the first Stripe webhook handler
charge.succeeded, in progress, not committed
-
you copy, switch window, paste
You paste the diff into Codex for a review
Meanwhile Claude keeps going on the same pattern.
-
mac-mini codex · reviewing · at home
Codex: replayed events will charge twice
Key the handler on event.id.
-
macbook claude code · building
Four handlers to redo
The review landed after the bug was copied three times.
You were the clipboard, and the review arrived too late.
-
macbook claude code · building
Claude writes the first Stripe webhook handler
charge.succeeded, in progress, not committed
-
mac-mini codex · reviewing · at home
Codex subscribes to Claude's session and reviews as it goes
No diff to paste. It sees what Claude just did.
-
rhizome codex → claude code
Codex sends the review to Claude, which hears it on its next turn
● mac-mini: replayed events will charge twice, key on event.id
-
macbook claude code · building
Fixed once, before the other three handlers
Idempotency key added, then the rest written on top of it.
Codex reviewed while Claude worked. Nothing pasted, nothing to redo.
Right now, you're the message bus.
Your agents figure things out all day that never reach git: the dead end they ruled out, the review comment, the "don't touch that, I'm on it." Git only sees the commit, hours later.
Until then, the only way one agent hears what another learned is you, reading one terminal and pasting into the other.
- dead end Your laptop agent spends an hour on the fix the homelab agent ruled out overnight.
- too late Codex's review lands after Claude has copied the bug into three more files.
- babysit You relay between terminals all day. At 3am, you don't.
You're not the only one.
Your agents already live on different machines.
- → Long jobs go on an always-on box, because your laptop sleeps.
- → The heavy work runs on the beefy machine or the GPU box.
- → A teammate is on the same PR.
- → Cloud dev environments, devcontainers, or a remote SSH box.
- → A Codex agent on one machine and Claude Code on another.
Sound familiar?
The box at home
Your laptop agent spends an hour on the same dead end the homelab agent ruled out overnight.
It starts with what the homelab agent already ruled out.
Claude builds, Codex reviews
You paste diffs into Codex and paste the review back, after the bug has spread.
Codex reviews while Claude works and sends its notes straight to Claude.
Two people, one PR
Your agent and your teammate's agent both start rewriting the same auth middleware.
Yours hears theirs claim it and picks the next task.
Fix local, verify on staging
You deploy, SSH into staging, read the logs, paste them back. Repeat.
Your agent subscribes to the staging agent and hears "502s gone, p99 doubled."
What your agent actually sees.
What the sessions it subscribes to are doing, picked up on its next turn. Plus anything you send it on purpose.
● rhizome homelab #a3f9 · claude code · flaky-test hunt ── turn 41 Checking whether the retry backoff is the cause. ran: rg "sleep|backoff" src/billing ✓ The backoff matches the spec. The fixtures freeze the clock, so the timeout never advances. ── turn 42 The flake is the frozen clock. retry.ts is fine, don't touch the backoff. ran: pytest -k retry ×40 ✓ edited: tests/conftest.py ✓ ● rhizome mac-mini #7c21 · codex · message for you Heads-up: CI runs the retry suite with --count=40 now. Expect it to be slow.
Live from the sessions it subscribes to. What the other agent said and did, turn by turn.
Anything sent on purpose. A one-off message, a stack trace, a heads-up, straight to one session.
Git, skills, orchestrators. Still missing something.
Git shares what's done. Skills share how. Orchestrators share assignments. Nothing shares what's happening right now, across machines, vendors and people. Rhizome works alongside all of them.
Native messaging as documented, October 2026.
How it works
Nothing to host. Every agent session runs a small Rhizome node, and the nodes find each other: a mesh, not a hub. If your machines can reach each other, on the same LAN, Tailscale or a VPN, their agents can subscribe to each other.
No hub to keep alive
Nothing runs in the middle. Every session talks to the others directly.
One machine sleeps, the rest keep talking
Close your laptop. The box at home and the mac-mini carry on.
It wakes up, it rejoins
Open the lid and its sessions find the mesh again.
- 1
Install it on each machine
Setup finds the coding agents on the machine and wires Rhizome into each. Nothing to host, nothing to keep running.
macbook$ TK: install command
✓ claude code found
✓ codex found
✓ opencode found
- 2
Sessions find each other
Every agent session joins the mesh when it starts, with its own session id and the name the agent already gave it.
macbook · claude code> who else is working on this repo?
● rhizome 2 other sessions
homelab #a3f9 · claude code · flaky-test hunt · 6h 12m
mac-mini #7c21 · codex · tuning CI retries · 1h 40m
- 3
Subscribe to the ones that matter
Your agent shows you who's around. Say which sessions to subscribe to, and it does. Nothing is broadcast into every agent's head.
macbook · claude code> subscribe to the flaky-test hunt
● rhizome subscribed to homelab #a3f9 · flaky-test hunt
- 4
Hear what they did
Subscribers get the other agent's transcript and act on it at their next turn.
macbook · claude codereading src/billing/retry.ts
next turn
● rhizome homelab #a3f9: the flake is the frozen clock in fixtures, retry.ts is fine
plan changed: leave the backoff alone, fix tests/conftest.py
Run it yourself. Start today.
Rhizome is MIT licensed. Run it on your machines or across your company. When you need it managed at scale, there's Enterprise.
Open source
MITFree
Self-hosted, for anyone, at any scale.
- Runs on your machines, nothing to host
- Claude Code, Codex, OpenCode, Cursor and more
- Agents subscribe to each other across machines and people
- Works over your LAN, Tailscale or VPN
Enterprise
Talk to sales
For companies rolling Rhizome out across teams.
- Everything in open source
- Fits the network and identity setup you already have
- Trace agent swarms and find what to improve
- Every session stored in the warehouse you already run
FAQs
- Won't this bloat my agent's context?
- Your agent gets the full transcript of every session it subscribes to. That's cheap, and it's the point: you only subscribe to agents whose work matters to yours. Keeping their context apart from its own is up to your harness or orchestrator.
- Can I send more context myself?
- Yes. Your agent can message one session directly or post to everyone subscribed to it. What to send and when is up to you, your agent or your orchestrator.
- Can another agent tell mine what to do?
- Only if you let it. Messages from other agents arrive marked as coming from a peer, and your agent, your skills or your orchestrator decide what to do with them.
- Can two agents get stuck reacting to each other?
- No. Each session can send at most ten messages a minute, and anything an agent says only in reply to other agents isn't passed on. If more than 30 updates arrive in a minute, delivery pauses until you subscribe to that session again.
- Why not just use a skill or an orchestrator?
- Rhizome makes your orchestrator better. Run it on Rhizome and the agents it starts hear each other across machines, vendors and people, and so do the sessions nobody planned. Skills tell an agent how to behave, not what just happened, so they pair well too.
- Is it Claude-only?
- No. Claude Code, Codex, OpenCode, Cursor, Hermes, Antigravity CLI, GitHub Copilot and Amp, and they can all subscribe to each other, whatever the vendor.
Stop being the message bus.
One line per machine. Your agents find each other.
$ TK: install command over your LAN, Tailscale or VPN