How do I share context between Claude Code and Codex?

Without Rhizome, you copy and paste, or have one agent write markdown into the repo and tell the other to read it. With Rhizome, both get it as an MCP server. Codex can subscribe to Claude Code's session, or the other way around, and sees what it said and did at the start of its next turn.

Does Rhizome replace my handoff notes?

No. Keep writing down the decisions worth keeping. Rhizome covers what happens between notes: the work in flight that nobody has summarized yet.

Does it work across machines and teammates?

Yes. Install it on each machine. Sessions find each other over your LAN, Tailscale or a VPN, and your agent can subscribe to a teammate's session on the same PR.

Won't streaming sessions bloat my agent's context?

Only the sessions you subscribe to reach your agent, marked as Rhizome messages. How much to keep is up to your harness.

Does it work with orchestrators?

Yes. An orchestrator can use Rhizome to subscribe the agents it starts to each other, so its workers hear each other across machines and vendors.

Secrets get redacted using open source libraries. Add your own rules for anything else.

Which agents does Rhizome work with?

Claude Code, Codex, OpenCode, Cursor, Hermes, Antigravity CLI, GitHub Copilot and Amp. They can all subscribe to each other, whatever the vendor.

How coding agents share context today

Updated October 26, 2026 · markdown

Most developers move context between coding agents by hand. They copy and paste between terminals, or they save a markdown summary of each session into git, written by hand or by a skill or agent that runs on every session.

Git, notes files, skills and orchestrators each carry part of the picture: what's finished, what was decided, how to do things, and who's doing what. None of them carry what another agent is doing right now.

Rhizome fills that gap. Agents subscribe to each other's sessions and see what they said and did at the start of their next turn, across harnesses, machines and teammates. It works alongside everything else on this page.

The usual setup: markdown in git

Ask a team how their agents share context and you'll usually hear one of two versions of the same thing.

By hand

At the end of a session, you ask the agent to write down what it did, what it decided and what's left, in a file like HANDOFF.md, NOTES.md or docs/decisions/. You commit it. The next session, or a teammate's agent, is told to read it first.

Automated

A skill, hook or background agent runs on every session. It summarizes the key decisions and learnings into markdown and commits it to the repo, so nobody has to remember.

What works

Durable: it survives restarts, reboots and new sessions.
Reviewable and versioned like any other file in git.
Works with any agent that can read a file.

Where it breaks

It's only as fresh as the last summary. Anything learned since hasn't been written down yet.
A summary decides what matters before anyone knows. The dead end that turns out to matter is often the one that got cut.
It arrives after the fact. When two agents work at the same time, the notes land after the overlap.
Another agent has to know the file exists and read it at the right moment.
Automated summaries pile up: more files to keep tidy, more merge conflicts, more stale notes to read.

Keep doing this for decisions worth keeping. Rhizome covers what happens between the summaries.

Every approach, compared

Approach	Good at	Where it falls short	Use it for
Copy-paste	Works today, zero setup.	You're the bottleneck. It's late, lossy, and it doesn't happen at 3am.	One-off questions.
Git commits and PRs	Finished work, with history and review.	Only sees what's committed. Dead ends, work in progress and "I'm on it" never get there.	Anything finished.
Markdown handoffs	Simple, durable and reviewable.	Someone has to write it and someone has to read it. It goes stale.	Decisions worth keeping.
Session summaries	Nobody has to remember to write it.	Lossy and after the fact. Lots of files, and still stale between runs.	A searchable record of past sessions.
Skills	Teaching an agent how.	Written in advance. They can't know what happened ten minutes ago.	Repeatable procedures.
Orchestrators	Big jobs planned upfront.	Top-down, usually one machine and one person. Workers don't hear each other, and sessions it didn't start are left out.	Large, well-defined jobs.
Native messaging	Quick notes between your own sessions.	Only Claude Code has it: one to one, under one login. Not Codex, not a teammate.	Quick notes between your own Claude Code sessions.
rhizome	What's happening right now.	Agents see what the sessions they subscribe to said and did at the start of their next turn, across harnesses, machines and teammates.	Anything in flight.

Native messaging as documented, October 2026.

Each approach in more detail

Copy-paste

You read one terminal and paste into another: diffs, stack traces, review comments.

Good at: Works today, zero setup.

Falls short: You're the bottleneck. It's late, lossy, and it doesn't happen at 3am.

Git commits and PRs

Agents commit, push and open pull requests. Other agents pull.

Good at: Finished work, with history and review.

Falls short: Only sees what's committed. Dead ends, work in progress and "I'm on it" never get there.

Markdown handoffs

Notes files like HANDOFF.md or NOTES.md, written by hand at the end of a session and committed.

Good at: Simple, durable and reviewable.

Falls short: Someone has to write it and someone has to read it. It goes stale.

Session summaries

A skill, hook or agent that writes a markdown summary of every session into git.

Good at: Nobody has to remember to write it.

Falls short: Lossy and after the fact. Lots of files, and still stale between runs.

Skills

Reusable instructions that teach an agent how to do something.

Good at: Teaching an agent how.

Falls short: Written in advance. They can't know what happened ten minutes ago.

Orchestrators

A coordinator that plans a big job and hands pieces to worker agents.

Good at: Big jobs planned upfront.

Falls short: Top-down, usually one machine and one person. Workers don't hear each other, and sessions it didn't start are left out.

Native messaging

Messaging built into one agent, between its own sessions.

Good at: Quick notes between your own sessions.

Falls short: Only Claude Code has it: one to one, under one login. Not Codex, not a teammate.

Rhizome

An MCP server in each of your agents. Agents subscribe to each other's sessions.

Good at: What's happening right now.

Use them together

These aren't either-or. Each one carries a different kind of context.

Git what's done
Markdown handoffs and summaries what was decided
Skills how to do it
Orchestrators who does what
Rhizome what's happening right now

How Rhizome works

1 Install it on each machine. It finds your coding agents and adds Rhizome to each as an MCP server. There's nothing to host.
2 Ask your agent who else is working, and subscribe to the sessions that matter to yours.
3 At the start of its next turn, your agent sees what those sessions said and did, marked as Rhizome messages. It can message back.

$ curl -fsSL https://tryrhizome.dev/install.sh | bash

Using an agent? Point it at tryrhizome.dev/install.md.

FAQ

How do I share context between Claude Code and Codex?: Without Rhizome, you copy and paste, or have one agent write markdown into the repo and tell the other to read it. With Rhizome, both get it as an MCP server. Codex can subscribe to Claude Code's session, or the other way around, and sees what it said and did at the start of its next turn.
Does Rhizome replace my handoff notes?: No. Keep writing down the decisions worth keeping. Rhizome covers what happens between notes: the work in flight that nobody has summarized yet.
Does it work across machines and teammates?: Yes. Install it on each machine. Sessions find each other over your LAN, Tailscale or a VPN, and your agent can subscribe to a teammate's session on the same PR.
Won't streaming sessions bloat my agent's context?: Only the sessions you subscribe to reach your agent, marked as Rhizome messages. How much to keep is up to your harness.
Does it work with orchestrators?: Yes. An orchestrator can use Rhizome to subscribe the agents it starts to each other, so its workers hear each other across machines and vendors.
What about secrets?: Secrets get redacted using open source libraries. Add your own rules for anything else.
Which agents does Rhizome work with?: Claude Code, Codex, OpenCode, Cursor, Hermes, Antigravity CLI, GitHub Copilot and Amp. They can all subscribe to each other, whatever the vendor.