[FEATURE] Cowork: one synced session — chat parity when remote, full local execution at the desktop

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

Note vs #38470 (closed): that request asked for remote access to a Cowork project
WHILE the local machine is on and awake — effectively what Remote Control now provides,
which is likely why it was closed. This request is different in one decisive way: it
asks for the session to stay usable as a chat when the PC is OFF (cross-device
continuity via a synced transcript), and to attach full local execution when back at
the desktop — all in one session. #38470 explicitly scoped out PC-off continuity
("not about running the VM remotely"); this request is exactly that gap.

• - - - - -

I work on large local projects (Unity/Unreal, big codebases) that must run on my
machine, using local MCP servers, connected folders and a shell. I also need to read
and continue the SAME working session from web and mobile when I'm away — including
when my PC is off.

Today I can't have both in one session:

• Chat projects sync across devices and work with the PC off, but can't run the local

Cowork agent (local MCP, files, shell) at the desktop.

• Local Cowork gives full local execution at the desktop but is desktop-only: it

doesn't sync, so it's invisible from web/mobile.

• Remote Cowork syncs but can't use local MCP servers even when I'm at the desktop.
• Remote Control runs locally and can be steered remotely, but keeps nothing

server-side, so there's no continuity when the PC is off.

So I maintain two parallel sessions (a chat project for cross-device + a local Cowork
session for execution), splitting context and doubling maintenance, and get the core
benefit of neither.

Proposed Solution

Let a single synced (chat-project-style) session attach native local Cowork execution,
active only at the desktop:

• Remote (web/iOS/Android, PC off): behaves exactly like a chat project today — full

interaction (read, continue, ask, get answers, produce outputs), no local tools.

• Desktop (app running): the SAME session additionally runs the full local Cowork agent

— local MCP servers, connected folders, shell, autonomous mode, sub-agents — natively
on the machine.

• Away / PC off: the session gracefully degrades to chat behavior.

Concretely: persist a local Cowork session's transcript/context to the account (reuse
the existing chat storage path; opt-in per session), render it as a chat on remote
surfaces, and attach native local execution when opened on the desktop. No MCP-to-cloud
bridging required — local tools run locally, only the transcript syncs. This reuses the
Remote Control pairing model for the "PC on, steered from another device" case.

Alternative Solutions

• Remote Cowork: drops local MCP servers at the desktop; for MCP-dependent work it

reduces to a more expensive chat.

• Remote Control (Claude Code): great for live local execution steered from another

device, but keeps nothing server-side, so no PC-off continuity or readable history.

• Chat project + a separate local Cowork session (my current workaround): two parallel

sessions, split context, double maintenance.

• Community tools like CloudCLI / Claude Code UI (github.com/siteboon/claudecodeui)

already implement "run locally, view/steer remotely" — demand signal, but not
first-party.

Priority

High - Significant impact on productivity

Feature Category

Other

Use Case Example

1. On my desktop I open a session in my Unity project, linked to a local folder on D:.

Claude uses local MCP servers and reads/writes the project files directly, running
multi-step tasks autonomously.

1. I leave home; my PC is off. On my iPhone I open the SAME session, read what Claude

did, ask a follow-up, and have it draft a summary — exactly as a chat project would,
with no local access needed.

1. Back home, I open the same session on the desktop; it reconnects to full local

execution (MCP, files, shell) and continues where it left off.

One continuous session: chat parity when I'm away, full local Cowork at the machine.

Additional Context

• Half of this already exists: chat projects provide the remote/PC-off half; local

Cowork provides the desktop half. Remote Control proves "execute locally, steer
remotely" works (docs: code.claude.com/docs/en/remote-control — "nothing moves to the
cloud", "your filesystem, MCP servers, tools ... stay available").

• Data residency / GDPR: this makes the local-vs-cloud tradeoff a per-session user

choice — local mode keeps files and execution on the machine and syncs only small
transcript text.

• Cost: chat sessions are already stored server-side in full; syncing a local session's

transcript reuses that mechanism and can be opt-in, so it adds no new storage class.

• Full write-up (sources + an optional unified "session type" end-state model) attached

as PDF.

Cowork-Hybrid-Session-Proposal2.pdf