[FEATURE] Claude Code multi device, chat and progress sync system

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Claude Code is tied to a specific terminal process on a specific machine. For users who work across multiple devices (desktop, laptop, phone, home server, cloud envs), there's no unified way to see what's running where, pick up work on a different device, or send a prompt to the right machine.

I run three Windows machines (desktop, laptop, mini PC gateway hub) plus a phone, and I move between them constantly through a typical day. Right now my Claude Code experience is fragmented: each device is its own island, each session is locked to the terminal it was started in, and moving context between them means lossy copy-paste or heavyweight manual setup.

Remote Control is a partial bridge but it's per-session, manually started, one-viewer-at-a-time, requires a terminal staying open, and doesn't scale to "I have three machines all running Claude Code and I want one surface to work with all of them". It feels like a workaround, not the product.

The core missing abstraction is device as a first-class identity. I think about "my mini PC" and "my laptop", not about "session 48293". Everything in Claude Code's current model is session-first, which doesn't match how users actually use multiple machines.

Proposed Solution

The chat is the shared object. The device is the executor. Sync the object.

Each device registers to the account as a node. Chats live on the device where they were created because that's where the filesystem, MCP servers, and execution context live. A lightweight sync client on each device pushes chat state diffs to Anthropic's relay, which mirrors them out to any connected viewer.

The Claude app (mobile, web, desktop) shows:

• A list of my nodes, each with a status indicator (green online, greyed offline)
• Also shows cloud envs, allowing for greater integration and flexibility
• All chats from all nodes in one unified list, filterable by node
• Any chat viewable live from any device, regardless of host
• Prompts sent from any viewer route through the relay to the host device, execute there, results sync back to all viewers
• Offline devices show last-known state; pending prompts queue until the device wakes

Add a "move to device" / "fork to device" action on every chat.

This would let me transfer an in-progress conversation to a different node while preserving full history, tool call results, and context. Each fork creates a new chat on the target device with shared ancestry, original stays put. Handoff migrates the chat and archives the original. This enables genuine workflow transitions, (plan on mini PC, execute on desktop; draft on laptop, finish on desktop) without lossy copy-paste.

No persistent heavy agent needed. Devices run a thin sync client that only invokes the Claude Code execution engine when a prompt arrives. Low battery impact, low complexity. Well-understood engineering pattern (Git, Google Docs, Notion, Dropbox all work this way).

Alternative Solutions

Remote Control. This is the closest existing option. It works for single-session bridging but doesn't scale to multi-device, multi-session reality. Manual start, one viewer per session, terminal must stay open. Fine as a bridge, not as the architecture.

Priority

High - Significant impact on productivity

Feature Category

Interactive mode (TUI)

Use Case Example

Typical day, current state:

Morning on laptop before school. Start a Claude Code session working on a History essay reference doc. Commute to school, want to keep working on my phone. Have to: leave laptop open, remember to have started Remote Control, find the session, work through a limited interface. If I forgot to start Remote Control before leaving, I'm locked out until I get home.

At school during free periods, I want to check on a long-running infra task I left running on the mini PC (it's building out the WhatsApp MCP bridge or running a message archive sync). Currently: no visibility at all unless I proactively SSH in. I don't know if it finished, errored, or is waiting on input.

After school, back on desktop for heavier work. Want to continue the History essay I started on laptop. Currently: open a new chat, paste in context, hope Claude figures out where we left off. Lose all the tool call history.

Same day with this feature:

Morning on laptop. Start a chat, it auto-registers to "Laptop" node. Commute to school, open Claude app on phone, tap "Laptop" node, pick the History chat, continue from phone. Laptop is asleep but the chat state is synced, my prompts queue and will execute when laptop wakes. Or I hit "move to Mini PC" and continue there since Mini PC is always on.

During free period at school, open app, see green dot on "Mini PC", tap in, see the infra task status live. Send a follow-up prompt from my phone, Mini PC executes, result syncs back in real time.

After school on desktop, open app, tap the History chat from Laptop node, hit "fork to Desktop" because the essay files are here. New chat spawns on Desktop seeded with full history and tool calls. Continue work with zero context loss.

This is 3-4 device transitions in one day. Every one of them currently involves friction that the proposed design eliminates.

Additional Context

Why Anthropic is uniquely positioned to build this. Third parties can't use Claude as the execution brain at the depth needed, and Anthropic doesn't (for good reasons) let Claude be freely proxied through arbitrary gateways the way open-weight models are. So the architectural win is stuck on the wrong model, and only Anthropic can unstick it.

Brand fit. This matches Anthropic's existing pattern: take the messy powerful thing the community hacked together (SSH + tmux + Tailscale meshes) and ship the polished version. Claude Desktop polished the API. Claude Code polished agent scripts. Device mesh is the next step.

Technical notes. The sync-the-object architecture is well-understood (Git, Dropbox, Google Docs, Notion). The only genuinely new pieces are the permission model for multi-device tool execution and offline-edit conflict resolution, both solvable with known patterns. Doesn't require a persistent heavy agent per device, just a thin sync client that invokes Claude Code on incoming prompts.

Related existing tools for reference.

• OpenClaw (architecture right, wrong model)
• Happy Coder (single-device pairing done well)
• GitHub Codespaces / VS Code remote tunnels (cloud-first cross-device, different trade-offs)
• Remote Control itself (the relay infra already exists, just needs generalisation from session-ID to device-ID + chat-ID)