Codex 0.140 Imports Claude Code Setup, Because Agent Workspaces Are the New Lock-In

OpenAI’s most interesting Codex update this week is not a better benchmark score, a shinier model switcher, or another “agentic” demo with a suspiciously clean repository. It is a migration button.

Codex CLI 0.140.0, published June 15, adds /import for “selectively importing setup, project configuration, and recent chats from Claude Code.” That sounds like convenience. It is actually a declaration of where the coding-agent market is headed: the durable asset is no longer just the model. It is the workspace.

For teams already using Claude Code, that workspace is not trivial. It can contain project instructions, local conventions, MCP server wiring, skills, plugin assumptions, remembered conversations, model preferences, permission expectations, and a long tail of defaults that encode how the team actually works. OpenAI is now treating that state as migration surface area. In other words: Codex does not merely want to compete for the next prompt. It wants to make switching less annoying after your team has already customized the cockpit.

The import command is small. The product move is not.

The official changelog for Codex CLI 0.140.0 lists the feature plainly: /import can selectively import setup, project configuration, and recent chats from Claude Code. The supporting pull requests tell the more useful story. PR #27071 exposes the flow through an explicit slash command rather than interrupting eligible terminal startups. PR #27070 adds a two-step import picker with focus state, selection state, item counts, a customize view, and a review action. PR #27703 then restores source-specific wording because, for now, the path supports one source: Claude Code.

That last detail is the tell. The architecture may say “external agent,” but the copy had to admit the current target. This is a Claude Code import feature wearing a future portability jacket.

The deliberate invocation matters. Agent configuration is too sensitive for a startup wizard that quietly says “we found some old state, want to bring it over?” A coding agent’s local setup can point at internal tools, cloud accounts, private repos, MCP servers, test environments, and credentials-adjacent workflows. The right default is explicit, selective, and reviewable. Codex appears to be moving in that direction: invoke /import, inspect what was detected, choose what to bring across, then refresh configuration after import. That is the shape teams should demand from every agent migration path.

The wrong shape is “copy everything and hope.” The industry has already learned this lesson with dotfiles, browser profiles, IDE extensions, shell history, and CI secrets. Developer environment state is productive because it is specific. It is risky for the same reason.

Workspace portability is the new switching-cost fight.

Most public comparisons of Codex and Claude Code still read like model shopping: which agent is faster, which one handles bigger refactors, which one produces fewer cursed diffs, which one burns fewer tokens. Those questions matter, but they are no longer sufficient. Once a team has spent weeks building project-specific instructions, plugging in tools, setting permission boundaries, and letting the agent accumulate useful conversational context, the switching cost moves up a layer.

The comparison stops being “which model wins this task?” and becomes “which runtime can carry my working environment forward without turning migration into a weekend incident?”

That is why /import belongs in the same strategic bucket as plugin systems, MCP support, permissions, usage dashboards, session deletion, and credential storage. These are not random CLI conveniences. They are signs that coding agents are becoming operating environments. The terminal prompt is just the UI.

Codex 0.140.0 reinforces that reading elsewhere in the release. It adds /usage, /usage daily, /usage weekly, and /usage cumulative views for account token activity. It adds permanent session deletion through codex delete, /delete, and app-server thread/delete, with confirmation safeguards and subagent cleanup. It expands Amazon Bedrock support with managed API-key authentication. It adds encrypted local storage for CLI auth and MCP OAuth credentials. It improves MCP reliability by retrying transient streamable HTTP startup failures, reporting unusable OAuth credentials as logged out, and preserving explicitly disabled servers across runtime overlays.

That is not just a release train. That is a control plane being filled in.

The control plane is where serious adoption either happens or dies. Teams do not standardize on a coding agent because it produced one impressive patch in a demo repo. They standardize when the tool can survive real-world constraints: cost visibility, recoverable state, predictable deletion, credential hygiene, tool reliability, provider-specific auth, and migration paths that do not require rebuilding tribal knowledge by hand.

Do not import blind.

Practitioners should treat this feature less like “sync my settings” and more like a development-environment migration. The first run should happen in a disposable repository or a low-risk workspace. After importing, diff the resulting configuration. Check which project instructions moved. Inspect whether any MCP servers came across, whether disabled servers stayed disabled, and whether tool assumptions changed. Review recent chats before carrying them into a new agent runtime; those conversations may contain private context, credentials-adjacent snippets, internal architecture, or decisions that made sense only in the source environment.

Then run a parity task. Pick a real issue with known constraints. Run it in Claude Code with the existing setup. Run it in Codex after import. Compare not only patch quality, but also tool calls, permission prompts, token usage, latency, retry behavior, and failure modes. A migrated workspace that produces a good diff while quietly changing cost or access patterns is not equivalent. It is just polished drift.

The /usage addition makes that comparison more practical. If Codex can now show daily, weekly, and cumulative token activity, teams can start measuring workflow economics instead of relying on vibes. That matters because agent cost is becoming architecture input. A refactor agent that saves two engineer-hours but unpredictably burns through a team budget is not automatically a win. Conversely, a slightly slower agent with better cost visibility may be the one platform teams can actually approve.

The Bedrock and MCP changes also deserve attention in migration testing. Enterprise agent deployments increasingly route through cloud-provider auth, internal MCP servers, and policy overlays. PR #27443 notes that Bedrock API-key auth is scoped to the amazon-bedrock provider and should not be treated as an OpenAI bearer token. That sounds obvious until a migration path blurs provider boundaries. Auth scope needs to remain boring. Boring auth is good auth.

The market implication: agents are becoming sticky in different places.

Claude Code’s advantage has often been framed as depth: strong long-horizon coding behavior, a mature terminal workflow, subagents, memory, permissions, and an ecosystem that builders have been actively bending around their projects. Codex is attacking from the other side: strong integration with OpenAI’s developer platform, an increasingly capable CLI/runtime, multi-agent work, usage views, deletion semantics, plugin and MCP surfaces, and now a bridge from Claude Code state.

The interesting part is not that one vendor is copying another’s homework. That is normal platform competition. The interesting part is where the copying happens. If the battleground were only model quality, OpenAI would just talk about better coding performance. Importing Claude Code setup says the battleground includes local state, workflow memory, and the “last mile” configuration that makes an agent usable inside a particular team.

This is good for builders if it becomes a norm rather than a one-way move. Agent state should be portable, inspectable, and permission-aware. Teams should be able to leave a vendor without re-creating every instruction file, tool integration, and workflow convention from scratch. But portability also needs guardrails: no silent credential movement, no surprise MCP enablement, no chat-history leakage, no provider-auth confusion, and no import process that makes policy look cleaner than it is.

OpenAI’s first Claude Code import path is therefore worth watching less as a convenience feature and more as a pressure test. If it works well, competitors will have to answer. If it works poorly, teams will learn why agent environments need export formats, audit logs, dry runs, and policy checks before migration becomes common.

The editorial read: Codex 0.140.0 is OpenAI admitting that coding agents are no longer stateless tools you can swap like autocomplete engines. They are workspaces with gravity. The vendor that makes that gravity portable earns trust. The vendor that traps it earns lock-in. The smartest teams will use the new migration path, but they will inspect every imported assumption before calling it safe.

Sources: OpenAI Codex CLI 0.140.0 release, OpenAI Codex changelog, PR #27070, PR #27071, PR #27703