Issue Station
Sign In
Tools hereToolbox

claude-code - 💡(How to fix) Fix [FEATURE] Claude Code multi device, chat and progress sync system [1 participants]

Official PRs (…)
ON THIS PAGE

Recommended Tools

×6

Utilities matched from this issue’s tags and category — try them while you read without losing context.

GitHub issue graph ai analysis

Paste a GitHub issue URL. We fetch that issue, discover linked issues from bodies/comments/timeline, collect linked pull requests, and produce a structured English report.

The report is written in English Markdown for sharing and archival.

Helpful · Quick feedback

Loading…
GitHub stats
anthropics/claude-code#49657•Fetched 2026-04-17 08:34:58
View on GitHub
Comments
0
Participants
1
Timeline
4
Reactions
0
Author
aGamingGod1234aGamingGod1234
Participants
aGamingGod1234aGamingGod1234
Timeline (top)
labeled ×3renamed ×1

Root Cause

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.

Fix Action

Fix / Workaround

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.

RAW_BUFFERClick to expand / collapse

Preflight Checklist

  • I have searched existing requests and this feature hasn't been requested yet
  • 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)

extent analysis

TL;DR

Implement a device synchronization mechanism to enable seamless transitions between devices for Claude Code users.

Guidance

  1. Introduce a device registration system: Allow each device to register as a node to the user's account, enabling the synchronization of chat states across devices.
  2. Develop a lightweight sync client: Create a thin sync client that runs on each device, pushing chat state diffs to Anthropic's relay and mirroring them to connected viewers.
  3. Enhance the Claude app: Update the app to display a list of nodes, their status, and a unified list of chats from all nodes, filterable by node, and enable live viewing of chats from any device.
  4. Implement "move to device" and "fork to device" actions: Add actions to transfer chats between devices while preserving history, tool call results, and context.
  5. Resolve offline device handling: Implement a system to handle offline devices, showing their last-known state and queuing pending prompts until the device comes online.

Example

// Example of a possible device registration API
{
  "deviceId": "laptop",
  "deviceType": "desktop",
  "chatStates": [
    {
      "chatId": "history-essay",
      "state": "in-progress"
    }
  ]
}

Notes

The proposed solution builds upon existing technologies like Git, Google Docs, and Dropbox, which have already solved similar synchronization problems. However, the permission model for multi-device tool execution and offline-edit conflict resolution will require careful consideration.

Recommendation

Apply the proposed workaround by implementing a device synchronization mechanism, as it addresses the core issue of fragmented user experience across multiple devices and provides a scalable solution for users working across various machines.

Vote matrix · Quick signals

Works
Did the solution work? Tap to confirm.
Easy Fix
Was it a quick fix?
Time Saver
Did it save you time?
Blocking
Was it severely blocking?
Common Issue
Are others likely hitting this too?
Flaky / Intermittent
Is it intermittent?
Verified / Reproducible
Can you reproduce it reliably?
Loading…
#api#ssr#installation#tensor shape#autograd error

Still need to ship something?

×6

Another batch ranked right after the header list — different links, same matching logic.

Back to top recommendations

TRENDING