Codex 0.130.0 adds `codex remote-control` and migration support for Code and Cowork

• The Codex 0.130.0 release post says the headline change is codex remote-control, a simpler command for starting a headless app-server, and the linked 0.130.0 release notes also add thread paging, plugin detail improvements, and Bedrock auth via aws login.
• Hamel Husain's repost of the migration update shows the Codex app's migration tool now importing from both Code and Cowork, while OpenAI's import teaser shows the import surface pulling over tools, projects, and recent chat sessions.
• According to reach_vb's /goal demo, /goal keeps Codex working toward a durable objective until it hits an end state, and the official Follow Goals docs frame it around clear targets, validation loops, and multi-hour runs.
• OpenAI's Chrome extension launch and OpenAI's tool-routing thread positioned Codex as a multi-surface agent that can switch between plugins and Chrome, which is exactly how reach_vb's expense report example combined Drive, Sheets, Gmail, and a Chrome form.
• Hands-on reports from steipete's 17 hour 59 minute run and steipete's crabbox bug workflow suggest the release is less about one new command than about making long, delegated sessions easier to start, resume, and isolate.

The official bits are already pretty concrete: you can read the 0.130.0 changelog, the Follow Goals guide, and Microsoft's own April VS Code release roundup because cross-device agent sessions and remote continuity are suddenly showing up everywhere. The weirdly useful reveal is that OpenAI's teaser image is not just about fewer rate limits, it shows a migration flow for tools, projects, and 30 days of chats. Then reach_vb's reimbursement workflow lands the punchline: the same product that ships /goal and remote control is already being used to file expenses with plugins plus Chrome.

The biggest concrete change in 0.130.0 is the new codex remote-control entrypoint. The release notes say it starts a headless, remotely controllable app-server, which is a cleaner surface than the earlier preview chatter around settings toggles and SSH-flavored remote access in testingcatalog's early screenshot and its correction in testingcatalog's correction post.

The rest of the release clusters around long sessions: the same 0.130.0 release notes mention paging large threads, keeping app-server diffs accurate across apply-patch, and fixes for remote compaction behavior. That reads like plumbing for sessions that stay alive long enough to need their own maintenance.

The app-side migration story advanced at the same time. Hamel Husain's repost says the migration tool now supports both Code and Cowork, and OpenAI's teaser image shows exactly what OpenAI thinks is worth carrying over:

• Tools and setup, including settings, instructions, plugins, and skills.
• Projects, imported into existing project workspaces.
• Chat sessions from the last 30 days.

That is a broader import boundary than simple prompt history. It treats Codex less like a blank chat box and more like a stateful workbench with reusable environment setup.

OpenAI's Follow Goals guide defines /goal as a mode for a durable objective with a clear target and validation loop, where Codex can keep working for multiple hours without more input. The tweet evidence mostly matches that framing, but with practitioner shorthand instead of doc language.

A few patterns surfaced repeatedly:

• reach_vb's demo describes /goal as “don't stop until this works” mode for refactors, migrations, retry loops, and long experiments.
• jasonzhou1993's notes says the feature works better when the target is explicit, stop conditions are defined, and an interview step aligns expectations first.
• mattlam_'s 7 hour run and steipete's nearly 18 hour run show that “long-running” is literal, not marketing copy.
• skirano's skill loop post pushes the pattern one step further, using /goal to iteratively build, test, grade, and improve a skill until it hits a threshold.

The common thread is not autonomy in the abstract. It is persistence plus a success condition.

OpenAI shipped the Chrome plugin one day earlier, and that context matters because the company explicitly said Codex chooses between plugins and Chrome step by step. In OpenAI's tool-routing thread, plugins handle jobs they can satisfy directly, Chrome gets used for logged-in sites, and the system combines both when needed.

That routing model already shows up in user examples:

• reach_vb's expense report example used Drive and Sheets for state tracking, Gmail for invoice collection, and Chrome for the final reimbursement form.
• cedric_chee's tax filing screenshots show Codex working through the Australian Taxation Office simulator, then recovering after a browser-control kernel reset and continuing the task.
• dkundel's multiplayer game demo combines Chrome with subagents to test a browser game from multiple viewpoints at once.

The official Chrome launch post also says the extension runs in background tabs on macOS and Windows, without taking over the user's active browser, which is a material shift from earlier computer-use style control in embirico's contrast post.

One of the more revealing workflow posts had nothing to do with migration or browser automation. steipete's crabbox workflow describes using Codex to recreate a bug in an ephemeral crabbox, verify the issue, patch it, and verify the fix again, with ten sessions running in parallel so local machine state never pollutes the result.

The screenshot matters because it is unusually specific: it logs the bug repro box ID, the fix verification box ID, omitted volatile files, parseable JSON output, targeted test commands, and git diff --check. That is delegated debugging with audit trail, not just “agent fixed my bug” vibes.

It also lines up with the broader tooling direction in the VS Code release roundup, where Microsoft highlighted /remote for resuming chats on another machine, local logs for debugging past agent sessions, and notifications for background commands. Different products, same gravitational pull toward longer-lived agent runs that need isolation, continuity, and postmortems.