How to keep Claude Code in sync across machines

Claude Code keeps its context on the machine it runs on. Move to your laptop, a second desktop, or a teammate's setup, and the agent starts cold: it does not know the decisions, the interface shapes, or the work in progress from the other machine. You can keep that context in step across machines by sharing the small, durable parts (contracts, decisions, and intent) through a room every machine's agent reads, instead of trying to copy whole sessions around.

Why a second machine starts cold

A Claude Code session is local. Its memory of what you agreed, what an endpoint looks like, and what it is mid-way through building lives in that one terminal, on that one machine. There is no built-in channel for a session on another machine to read it. So the second machine re-discovers everything from the code, and re-derives decisions that were already made, often differently.

What you should not try to sync

The instinct is to sync the whole session or the whole repo state. Do not. Most of it is either already in git or too large and too transient to be worth moving. What actually needs to travel between machines is small:

• The shapes of the interfaces your agents have agreed on (contracts).
• The durable decisions: which library, which pattern, which approach and why.
• A one-line note of what each machine's agent is building right now (intent).

That is a tiny payload, and it is exactly the part that keeps two machines building the same system instead of two diverging ones. Your source keeps flowing through git as usual.

How to keep machines in step

Put that small shared state in one room that every machine's agent reads and writes. When the agent on your desktop declares a contract or records a decision, the agent on your laptop sees it on its next check, and is warned the moment a contract it depends on changes. This is the same cross-machine awareness that stops multiple agents on one project from colliding, extended across hardware.

Aethereum runs that room over MCP. It is the cross-machine, pre-commit layer: git shares finished, committed code, but by then the divergence already happened. Sharing the contract the moment it is designed is what keeps machines aligned before anyone pushes.

Setting it up on each machine

Run one command on each machine, pointed at the same room, then use Claude Code normally:

copy
npx aethereum init

The first machine creates a free room (no signup, no card). On the second machine, join the same room and both agents now share contracts, decisions, and intent. Switch from desktop to laptop and the thread is intact: the agent picks up the decisions and interface shapes the other machine already settled. For a team across several machines, see the teams setup; for one developer across two machines, the solo guide.