OpenAI Codex 0.146.0 Pulls Amazon Anthropic Workflows Into Its Plugin Race

OpenAI released Codex 0.146.0 with a notable competitive turn: it can recognize plugin marketplaces associated with both Amazon Bedrock and Anthropic’s Claude Code. That makes the release relevant to anyone tracking amazon anthropic developer workflows, despite no new partnership between those companies.

The update arrived on July 29, 2026, and covers much more than plugin compatibility. Codex can now name and pin sessions, preserve side conversations, fork thread histories, connect with remote execution hosts, and discover skills supplied by executors.

These changes reposition Codex as a workspace that can absorb tools and context from several agent environments. OpenAI is competing with Anthropic, Amazon, and other providers while reducing the friction involved in moving developer workflows between them.

The real contest is no longer limited to which model writes the best function. It concerns which agent can retain working context, reach remote infrastructure, inherit existing extensions, and remain manageable across long-running projects.

Codex 0.146.0 Expands the Agent Workspace

The central change is architectural: Codex now treats threads, plugins, skills, and execution hosts as connected parts of one working environment.

The official Codex 0.146.0 release lists six feature groups. Each addresses a different source of friction in agent-assisted development.

Users can assign names when starting sessions with /new or /clear. They can also pin important threads and move among side conversations without closing them.

That sounds like interface polish, but it tackles a persistent problem with coding agents. A developer rarely has only one question open while completing a substantial task.

One conversation might cover an implementation. Another might investigate a failing test, while a third examines an architectural alternative or reviews a security concern.

Losing those branches forces users to reconstruct decisions. Keeping them accessible turns the conversation list into a working project index instead of a disposable chat log.

The release also adds thread forking with paginated history. Pagination loads a long history in segments, preventing the interface from treating an entire conversation as one indivisible object.

A fork creates a new line of work from an existing thread. Codex 0.146.0 also supports temporary forks that stay out of regular thread listings.

That distinction matters during experimentation. A developer can test a risky migration, alternate patch, or different instruction set without crowding the permanent workspace.

Codex now connects its app server to remote Code Mode hosts through WebSocket. A WebSocket is a persistent, bidirectional connection that lets both endpoints exchange updates without repeated polling.

The feature separates the visible agent interface from the machine performing code execution. That can support remote development systems, managed environments, or specialized hosts with their own tools and policies.

Standalone web search also becomes available to compatible custom model providers. The provider must opt into the capability, so the release does not promise universal search across every model endpoint.

Finally, executors can supply skills and related resources. Codex can discover those skills and securely read their resources, including skills a user explicitly selects.

Together, these additions show where OpenAI is taking the product. Codex is becoming a coordination layer for conversations, reusable procedures, external tools, research, and remote execution.

That direction creates the release’s competitive tension. If the agent workspace can import useful components from other systems, switching no longer requires rebuilding every workflow from scratch.

Why Amazon Anthropic Compatibility Matters

The amazon anthropic angle is about interoperability, not a newly announced alliance between Amazon, Anthropic, and OpenAI.

Codex 0.146.0 adds support for Agent Plugins manifests, workspace plugin publishing, and additional marketplace discovery. The release specifically identifies Amazon Bedrock and Claude Code.

These names represent different layers. Amazon Bedrock is Amazon Web Services’ managed platform for accessing and operating foundation models. Claude Code is Anthropic’s coding-agent product.

Anthropic models can be available through Amazon Bedrock, but the Codex changes describe separate marketplace integrations. Readers should not interpret the release notes as evidence of a three-company commercial agreement.

Instead, OpenAI is recognizing that developers already maintain extensions in several environments. Organizations may use one model provider, another company’s cloud infrastructure, and a third agent interface across different projects.

The Amazon marketplace change directs Codex toward an API-backed plugin marketplace for Amazon Bedrock. This gives Codex a defined route for discovering extensions in that environment.

A separate Claude marketplace change lets Codex infer the plugin marketplace bundled with Claude Code. The practical goal is discovery without demanding that users manually reconstruct every source.

Manifest support is another important piece. A manifest is structured metadata that tells the host what a plugin contains, how it should be identified, and what supporting components belong to it.

The Agent Plugins update allows Codex to understand that packaging format. Compatibility at the manifest level is more meaningful than simply accepting a directory of scripts.

It gives the host a predictable representation of the plugin. That can help with discovery, presentation, attribution, validation, and later policy decisions.

Workspace publishing moves the flow in the other direction. Codex can expose the ability to publish plugins associated with a workspace, turning extension use into a potentially collaborative process.

A team could maintain a repository-specific plugin containing commands, skills, integration definitions, or supporting assets. Publishing can make that package available without copying its contents through informal channels.

This puts pressure on closed extension systems. A marketplace becomes less defensible when competing hosts can interpret its packages or connect to its catalog.

However, compatibility does not mean identical behavior. A plugin designed around Claude Code assumptions might reference tools, permissions, or lifecycle events that Codex handles differently.

Amazon Bedrock environments can also carry organization-specific authentication and network rules. Discovery is only the first step toward useful execution.

The strategic value remains clear. OpenAI can compete for the primary developer interface while acknowledging that customer infrastructure will remain mixed.

That is a more credible enterprise position than demanding a single-provider stack. Large organizations rarely replace every cloud, model, agent, and internal tool simultaneously.

For developers, the update reduces the cost of testing Codex alongside an existing setup. The ability to find familiar extensions makes evaluation less dependent on recreating months of workflow investment.

Plugins Turn Portability Into the Main Contest

OpenAI and Anthropic are now competing over the agent workspace while making parts of their extension environments more portable.

Model performance still matters, but model access has become easier to combine with surrounding infrastructure. The harder problem is preserving the operational system built around a model.

That system includes prompts, commands, skills, tools, approval rules, project conventions, external services, and accumulated conversation history. It also includes the knowledge required to invoke each component correctly.

Plugins package some of that system. Skills package repeatable instructions and associated resources. Threads preserve the path that led from a goal to a decision.

Codex 0.146.0 advances all three at once. That combination matters more than any isolated interface change.

Consider a team that uses Claude Code with an internal deployment plugin. The plugin may encode how to inspect a service, request a staging deployment, run health checks, and collect logs.

If Codex can discover the package, the team gains a starting point for migration or cross-agent testing. Engineers still need to validate behavior, but they do not begin with an empty workspace.

The same logic applies to Amazon Bedrock. A company might operate models through Bedrock because its identity, audit, and network controls already live inside AWS.

Codex support for that marketplace does not remove those controls. It gives the Codex host a way to find the extensions that participate in that managed environment.

OpenAI’s approach also challenges a simple product boundary. A coding agent is no longer just the model plus a terminal.

It is increasingly a host that must manage state, tools, remote machines, policies, and reusable knowledge. The host becomes valuable when those pieces remain coherent during a long task.

This explains why session naming and pinning belong in the same release as plugin marketplaces. Both features help transform scattered interactions into a maintained workspace.

Thread forking strengthens that workspace. Developers can preserve a stable implementation path while testing a different dependency, architecture, or repair strategy in a branch.

Temporary forks add a useful form of disposability. Not every experiment deserves permanent placement beside active project threads.

The resulting workflow resembles version control at the reasoning layer. It does not replace Git, since conversation forks do not represent authoritative source changes.

Instead, it keeps investigative context attached to alternate approaches. A developer can compare why two paths diverged before deciding which code changes should survive.

This is also relevant to knowledge management. Agent workflows generate decisions that can disappear inside long transcripts unless teams preserve and organize them.

A searchable engineering knowledge base can complement thread organization by retaining durable technical records outside one agent’s interface.

The pressure on Anthropic is therefore subtle. OpenAI is not simply copying a visible Claude Code feature.

It is attempting to make Claude Code’s extension investments less exclusive to Anthropic’s host. If that compatibility works reliably, developers gain more leverage when selecting an agent.

Amazon faces a different pressure. Bedrock benefits from being the managed control plane through which companies access models and related services.

A host that can connect with Bedrock’s plugin marketplace can participate in those workflows without becoming an AWS-native interface. That gives buyers another way to separate infrastructure choices from agent-interface choices.

The winner in this contest will not necessarily own every component. It will make mixed components feel coherent while preserving security boundaries and predictable behavior.

Remote Hosts and Skills Change How Work Moves

Codex 0.146.0 connects portable extensions with portable execution, allowing the interface, knowledge, and runtime to live in different places.

The remote Code Mode connection is essential to that design. The app server can communicate with a remote host through WebSocket instead of assuming all execution happens beside the user interface.

This separation supports several practical scenarios. A laptop can control work running on a more capable development machine.

A regulated team can keep source code inside a managed environment while allowing an approved interface to coordinate tasks. A project can also use a host prepared with specialized compilers, services, or test infrastructure.

The release does not establish that every remote environment will work automatically. Host configuration, authentication, network routing, and policy enforcement still determine what Codex can reach.

OpenAI paired the WebSocket feature with extensive proxy fixes. Configured proxies now apply across authentication, plugin downloads, MCP authorization, remote execution, redirects, WebSockets, and LM Studio connections.

A proxy routes network traffic through an intermediary that can enforce access, inspection, or organizational policy. Partial proxy support can make an agent appear functional until one hidden connection bypasses the approved route.

That failure pattern is especially disruptive in managed environments. Authentication might work while plugin installation fails, or ordinary requests might succeed while a WebSocket cannot connect.

Codex 0.146.0 aims to make routing behavior more consistent across those paths. The claim comes from the release notes, and production results will depend on each organization’s network design.

The update also refreshes MCP connections and Apps tools when authentication or configuration changes. MCP, or Model Context Protocol, is a standard interface for connecting agents with external tools and data.

Codex can replace closed MCP connections without restarting connections that remain healthy. This reduces the need to tear down an entire session after one integration changes.

Executor-provided skills add a knowledge layer to remote work. An executor is the environment responsible for carrying out tools or code operations on the agent’s behalf.

That environment can now advertise skills to Codex. A skill is a reusable procedure with instructions and, when needed, supporting resources.

For example, a remote host might expose a release-validation skill alongside its test configuration and deployment checklist. Codex can discover that capability when working inside the host.

Secure resource reading matters because the skill may reference information beyond its short description. Codex must retrieve the needed material without treating every available resource as unrestricted context.

Explicit selection gives users another control point. A developer can choose a relevant skill instead of expecting the system to inject every procedure into every conversation.

This design also helps with context limits. Agent performance can decline when unrelated instructions compete for attention, even if every individual resource is useful somewhere.

Codex 0.146.0 includes fixes intended to retain more skills under tight context budgets. It also warns when a skill catalog must be truncated.

That warning is important because silent omission creates false confidence. An agent might appear to know an organization’s procedures while a critical skill never reached its available catalog.

The broader mechanism resembles a distributed workbench. The interface manages the thread, the executor provides the runtime, plugins connect capabilities, and skills supply repeatable operating knowledge.

Such a system can help teams maintain AI workflows that span several tools. It also increases the number of boundaries that administrators must inspect.

Compatibility Still Has a Trust Problem

Codex can discover more external components, but discovery does not establish safety, compatibility, or organizational approval.

Plugins can contain more than descriptive metadata. Depending on the host and package, they can introduce commands, scripts, tools, integrations, skills, or references to remote resources.

Each addition expands what the agent might request or execute. A package that behaves safely in one host can encounter different permissions and approval semantics in another.

Manifest compatibility cannot resolve every difference. A common package description does not guarantee a common runtime contract.

Developers should expect edge cases around environment variables, file paths, tool names, authentication, network access, and interactive approvals. Windows, macOS, Linux, containers, and remote hosts can expose different behavior.

The release includes several protections and reliability changes. It preserves approval settings across interruptions, replay, imports, and forks.

It also attributes command execution to trusted plugin scripts and preserves plugin attribution across approval flows. Attribution helps a reviewer understand whether a proposed action came from the user, the agent, or an installed extension.

That context improves review, but it does not remove the need for review. A trusted source can still contain a mistake, an outdated assumption, or a command inappropriate for the current repository.

Marketplace discovery adds supply-chain considerations. A catalog can change, a package can update, and a repository reference can point to code maintained outside the buyer’s organization.

Teams should verify package identity, source, revision, requested capabilities, and update behavior. They should also test imported plugins inside a constrained environment before authorizing sensitive operations.

Workspace publishing introduces governance questions. An employee might publish a useful extension without realizing that its assets include internal paths, instructions, or organization-specific details.

The workspace publishing change exposes a capability, not a complete governance program. Organizations still need rules covering who can publish and where packages may appear.

Remote execution raises similar questions. A persistent connection can improve responsiveness, but it must obey the same authentication and routing policies as other network operations.

Proxy consistency is therefore more than a bug fix. It is part of the security model for organizations that depend on controlled outbound connections.

Temporary thread forks create another uncertainty. Their absence from ordinary listings makes experimentation cleaner, but users need confidence that retention and audit behavior match their expectations.

The release notes say temporary forks do not appear in thread listings. That statement alone does not define every storage, telemetry, or administrative retention condition.

Search support for custom model providers also requires careful interpretation. Codex enables compatible providers to opt into standalone web search.

It does not guarantee that every provider returns equivalent sources, applies the same policies, or offers the same visibility into search behavior. Teams should test source quality and data handling per provider.

Skill discovery creates a related risk. A large catalog can make the agent appear broadly capable while important resources remain unavailable, outdated, or truncated.

Codex now warns about catalog truncation, which makes the limitation more visible. Users should still confirm that a named procedure was actually selected and read before relying on its output.

These concerns do not negate the release’s value. They define the conditions under which portability becomes dependable.

OpenAI’s challenge is to make imported workflows predictable without erasing the differences among their original environments. Anthropic and Amazon face the same problem when accepting third-party extensions or external runtimes.

The competitive advantage will belong to the host that makes boundaries understandable. Users need clear attribution, narrow permissions, visible failures, reproducible configuration, and recoverable state.

A broad marketplace without those controls becomes a source of uncertainty. A smaller catalog with transparent execution can be more useful for serious development work.

What the Amazon Anthropic Contest Looks Like Next

The next phase will test whether Codex’s compatibility features produce real workflow portability or only broader discovery menus.

The first signal is imported plugin behavior. Developers should watch whether Claude Code and Amazon Bedrock marketplace packages operate inside Codex with limited modification.

Successful discovery is not enough. A useful compatibility layer must preserve expected commands, resources, authentication paths, and approval behavior.

Frequent host-specific failures would weaken OpenAI’s portability argument. Stable execution across representative plugins would strengthen it and encourage more teams to evaluate multiple agents.

The second signal is workspace publishing adoption. Codex now exposes the capability to publish plugins associated with a workspace.

The important question is whether teams use it to maintain shared, repository-specific agent packages. Visible adoption would turn plugins from personal customization into managed development infrastructure.

OpenAI will also need to show how administrators control destinations, updates, permissions, and package provenance. Enterprise buyers will judge publishing by governance as much as convenience.

The third signal is reliability across remote hosts. WebSocket transport, consistent proxy handling, and live MCP refreshes form one operational chain.

Users should watch for connection stability during authentication changes, network interruptions, server refreshes, and long-running tasks. Those conditions reveal whether remote Code Mode is ready for routine work.

Anthropic’s response also matters, but not simply as a feature checklist. Claude Code can defend its position by making its own host the best environment for Claude-oriented extensions.

It can also deepen package portability and compete on trust, usability, or execution quality. Restricting extensions too aggressively would risk frustrating developers who expect tools to follow their projects.

Amazon has a different incentive. Bedrock benefits when its managed environment remains useful across many model and agent choices.

A marketplace that works with outside hosts can reinforce AWS as infrastructure beneath the agent layer. Amazon does not need one coding interface to dominate if Bedrock remains central to enterprise execution.

OpenAI’s move therefore creates a three-sided dynamic. Codex wants to own the working interface, Anthropic wants Claude Code to remain the preferred agent host, and Amazon wants Bedrock to anchor managed access.

Developers benefit when those layers remain separable. They can choose a model, host, cloud, and extension system according to the needs of each project.

They also inherit more integration responsibility. Every additional combination requires testing, policy review, and a clear understanding of where code and context travel.

The amazon anthropic search phrase captures genuine market overlap, but it can obscure the actual story. Amazon and Anthropic are not presented as one product inside Codex 0.146.0.

OpenAI is supporting distinct extension sources associated with Amazon Bedrock and Claude Code. That difference matters when teams plan authentication, governance, and compatibility testing.

Codex 0.146.0 is therefore less about one headline feature than a coordinated shift. Threads become easier to maintain, branches become easier to test, plugins become easier to discover, and execution can move to remote hosts.

The unanswered question is whether all those parts remain dependable when combined. A plugin discovered from another marketplace must still survive the target host’s tools, policies, network, and approval system.

Teams evaluating the release should begin with one bounded workflow. Import a representative plugin, fork a test thread, connect an approved remote host, and document every permission the path requires.

Then compare the result with the original environment. Did the package retain its meaning, or did host-specific assumptions require extensive repair?

That comparison will reveal more than a model benchmark. It will show whether coding agents are becoming portable workspaces or simply larger collections of proprietary integrations.

For OpenAI, success means developers can bring existing investments into Codex without surrendering control. For Anthropic, the test is whether Claude Code remains preferable when its extension format travels.

For Amazon, the opportunity is to keep Bedrock relevant beneath either interface. The next several Codex releases should show whether interoperability becomes routine or remains an early compatibility promise.