Feature request: Codex workspace continuity across devices

Potential duplicates detected. Please review them and close your issue if it is a duplicate.

• #34756

Powered by Codex Action

Great to see related work around cross-device task continuity (#34756). After testing Codex Remote between a MacBook Pro and Mac mini, the core session continuity already works well: repository access and Codex session context can follow the user.

The remaining gap I noticed is full workspace continuity, not just task continuation.

A future Codex workspace could restore the interactive environment around a task:

• open files
• editor/workspace layout
• diff views
• terminal sessions where possible
• recent commands and test results
• active workspace context

The goal would not be to sync the filesystem itself. Code and execution should remain local to the host machine. The missing layer is restoring the user's working context when moving between trusted devices.

This feels closer to Apple Handoff for AI coding workflows: move the workspace context, not the entire machine.

I hit a concrete variant of this continuity gap while using Codex Desktop to coordinate work between two trusted, user-owned Linux servers over SSH.

Reproduction

1. A long-running third-party coding-agent conversation existed on Server A, backed by a host-local SQLite conversation database and WAL.
2. The project and a launcher were moved to Server B, where the launcher started successfully but selected a different Server B-local conversation.
3. Process/tmux checks looked healthy, but the visible agent UI was actually at first-run onboarding rather than the prior working conversation.
4. The user explicitly requested and authorized moving the source conversation state to the other user-owned server.
5. Codex's cross-device safety boundary categorically refused to transfer the raw conversation database/SQLite/WAL, even though both endpoints were trusted and fully owned by the same user.
6. The only available workaround was a generated Markdown handoff. That preserved much of the technical context but was not exact conversation continuity and intentionally redacted some account-identifying content.

Why this is a product gap

The current behavior presents a false choice:

• copy private state manually outside Codex, without a supported integrity/safety workflow; or
• lose exact conversation continuity and accept a lossy handoff.

It also appears to apply Codex's own local-session safety boundary broadly to user-owned third-party application data. There is no supported, owner-authorized migration mode that distinguishes authentication secrets from the conversation data the user explicitly wants to move.

Requested behavior

Please provide a supported migration/handoff workflow for trusted user-owned hosts. Ideally it would:

• distinguish Codex authentication/OAuth/browser state from user-owned conversation content and third-party agent databases;
• require explicit source and destination host confirmation plus an elevated warning;
• quiesce the source process and use SQLite's supported backup/snapshot mechanism instead of copying a live DB/WAL pair;
• encrypt transport, checksum the artifact, preserve a source rollback copy, and validate the restored DB on the target;
• require target-local reauthentication rather than migrating credentials;
• allow exact conversation import/resume when the user explicitly opts in;
• clearly report what will be omitted before generating a lossy handoff, rather than presenting the handoff as equivalent continuity.

If raw migration must remain unsupported, an official encrypted conversation export/import format that excludes credentials but preserves the full user-visible transcript, tool state needed for resume, attachments by reference, project mapping, and task checkpoints would still solve most of this case.

Environment: Codex Desktop on Windows coordinating two Linux hosts over SSH; both servers and all data were owned by the same user. No credentials, raw database contents, conversation identifiers, or private transcript data are included in this report.

## Problem Codex Remote already enables developers to connect to Codex running on another trusted machine and continue working with the same repository and session context. After testing a multi-device workflow (MacBook Pro connecting to Mac mini), the core remote session experience works well. The remaining gap is preserving the complete interactive workspace state when moving between devices. Today the developer may still need to manually reconstruct parts of their working environment. Example: A developer is working on a Mac mini: TapInn repository open active Codex conversation files open in the workspace editor layout diff view terminal sessions recent test output current task context Later they continue from a MacBook Pro. The Codex session and repository are available, but the complete workspace context is not necessarily restored. ## Proposed feature: Codex Workspace Continuity Allow Codex projects/workspaces to persist and restore interactive workspace state across trusted devices. A workspace should remember: active repository/project active Codex conversation current task state opened files editor/workspace layout last viewed diff terminal/session state where possible recent commands and test results workspace notes/context Example: `` Mac mini TapInn Workspace | sync | MacBook Pro Resume TapInn Workspace ` ## Suggested approach Do not sync the filesystem itself. Keep source code and build artifacts local to the execution host. Sync workspace metadata and context: ` Codex Workspace | ├── Repository reference ├── Conversation state ├── Task context ├── UI/workspace state ├── Recent artifacts └── Device metadata `` Keep local: repository files node_modules/build output secrets machine-specific configuration ## User experience A developer should be able to: 1. Start work on one machine. 2. Leave that machine running. 3. Open another trusted device. 4. Select "Resume workspace". 5. Continue with the same working context without rebuilding the environment manually. ## Why this matters AI coding workflows are becoming multi-device by nature: desktop workstation laptop home machine * cloud workers Codex already handles remote execution and session continuity. The next step is making the entire workspace portable while keeping execution local. This would be similar to Apple Handoff, but designed for AI coding sessions: move the working context, not the entire machine.

I have exactly this workflow.

I use a MacBook Air while traveling and a Mac mini at my office, both signed into the same ChatGPT Pro account.

My actual code lives on a remote server, but the local Codex workspace and conversation context remain tied to the Mac where they were created.

Every time I switch computers I lose the accumulated Codex reasoning and have to rebuild context before I can continue working.

Workspace continuity across trusted devices would make a tremendous difference for professional developers who routinely switch between desktop and laptop environments.

Thank you for considering this enhancement.

I like the “workspace continuity” framing here.

I’ve been working on a similar idea with CtxHop. It started as cross-device Codex session handoff, and it can optionally transfer workspace state/files together with the session when moving to another machine.

It doesn’t restore the full editor UI yet, but it covers part of this handoff problem today:

https://github.com/CCCCY-ci/ctxhop