OpenAI Rebuilds Codex Into a Desktop Agent: Computer Use, 90+ Plugins, Memory and Multi-Day Automations

OpenAI released the biggest Codex update since the assistant's relaunch on April 16, 2026, turning what was still essentially a command-line and IDE coding companion into a full-fledged desktop agent that can drive a Mac, browse the web, schedule its own work, and plug into more than 90 external tools. The company's framing in its "Codex for (almost) everything" post is ambitious: with more than 3 million developers using Codex every week, OpenAI wants the next version to be less of an editor plugin and more of a colleague that happens to live inside your computer.

For hosting, DevOps, and web agency teams, the shift is significant. Codex now reaches far beyond generating code into actually operating the tools where production work happens: JIRA boards, CircleCI pipelines, GitLab issue queues, Render deployments, Neon databases, Microsoft 365 documents, and browser-based dashboards. It can also remember how you like to work between sessions, and pick back up on a long task days later without you needing to brief it again.

Here is what actually changed — and what the update means for anyone who has to ship software, keep servers running, or just spend their day hopping between too many tabs.

From Coding Assistant to Desktop Worker

The headline feature is what OpenAI calls background computer use. Instead of being confined to a terminal or an IDE sidebar, Codex can now see your screen, move its own cursor, click buttons, and type into any application on your Mac. Multiple Codex agents can run in parallel in the background while you continue working in other apps, which is a small engineering detail with large practical consequences: you do not have to hand over your machine to let it do something.

In practice this blurs the line between the model as a source of code and the model as an operator of tools. Need to convert a design file that lives in Figma, drop the exported assets into a Next.js project, then open a pull request on GitHub? Codex can now do all three steps in one continuous flow rather than handing you a script and letting you orchestrate the UI clicks yourself. If a tool does not have an API — or has one that is slow, undocumented, or gated — the agent simply treats the application like a human would and uses it through the UI.

Computer use is currently macOS-only. OpenAI says support is rolling out to users who are signed in with their ChatGPT account in the Codex desktop app, and that availability for users in the European Union and the United Kingdom is coming soon.

The practical ceiling on what this can do is still set by the agent's model quality, not the automation layer. Codex will still occasionally misclick, misread a modal, or blow past a confirmation dialog. OpenAI's safety framing leans on visible, auditable actions: you can watch the cursor move and stop it mid-task. For anything touching production, that is still the recommended pattern.

The In-App Browser and Image Generation

Codex's desktop app now ships with its own built-in browser. Anyone who has tried to describe a front-end bug to an AI assistant via screenshot will appreciate what this enables: you can browse to a live page, highlight or comment on a specific element inside the browser, and those comments become precise instructions that Codex uses as context. Instead of saying "the padding on the hero section looks off on mobile," the model sees your annotated screenshot plus the exact DOM it lives in.

This combines with another new capability: direct image generation using OpenAI's updated image model, gpt-image-1.5. Codex can generate product mockups, frontend component concepts, illustrations for games, or iteration passes on existing screenshots inside the same workflow that produces the code. For an agency team assembling a pitch deck, or a product engineer exploring visual variants of a landing page, that compresses what used to be a Figma-to-Photoshop-to-Slack round trip into a single conversation.

The workflow shape that emerges is closer to a creative pair programmer than anything Codex has offered before. You can ask for a hero section mockup, have Codex generate three variants, iterate visually on the one you prefer, then ask it to produce the actual React component with the chosen style baked in. Each of those steps was previously its own isolated tool; now they all sit in one place.

More Than 90 New Plugins

The release also expands Codex's plugin ecosystem substantially. OpenAI is shipping more than 90 new plugins that combine skills, application integrations, and servers that speak the Model Context Protocol (MCP) — a standardized way for AI agents to call external tools that has been increasingly adopted across the industry.

Some of the integrations that will be most useful to developer and ops teams include:

• Atlassian Rovo for JIRA and Confluence workflows
• CircleCI for CI/CD pipeline control
• CodeRabbit for automated code review
• GitLab Issues for repositories outside the GitHub ecosystem
• Microsoft Suite for Word, Excel, Teams, and SharePoint
• Neon by Databricks for serverless Postgres operations
• Remotion for programmatic video rendering
• Render for cloud deployment
• Superpowers for an expanded skill library

What this unlocks is agent-driven flows that span across tools rather than being trapped inside one. A single task like "triage this incoming JIRA ticket, pick up the highest-priority bug, open a branch, fix it, push, let CodeRabbit review it, and deploy the PR preview to Render" was until now an orchestration problem you had to solve with glue scripts and GitHub Actions. With the new Codex, it is a plugin chain: Rovo to Codex edits, to Git push, to CodeRabbit, to Render. Each step is a named plugin call the agent can compose on its own.

The plugin model also matters because it is open. Any MCP-compatible server can be dropped in, which means internal tools at your company — a homegrown deploy script, a provisioning API, a custom monitoring dashboard — can become first-class participants in the same agent workflows as the commercial integrations.

Memory and Multi-Day Agents

Two features buried further down the release notes may end up being the most important long term.

The first is a preview of Codex memory. Until now, every Codex session was essentially amnesiac: the model would forget your conventions, your preferences, the context you spent ten minutes explaining yesterday, and start from scratch the next time you opened the app. The memory preview lets Codex retain useful context across sessions — things like how you name branches, which testing framework you use, which linting rules you ignore, which providers you deploy to, and which past mistakes it should not make again. OpenAI frames this as a level of quality previously only possible through extensive custom instructions, which is a polite way of saying that most developers never bother to write a good system prompt, and memory closes that gap automatically.

The second is extended automations. Codex can now schedule future work for itself, pause, and wake up to continue long-running tasks that may span days or weeks. The shape of this is less chat session and more ambient worker you can assign things to. You can hand it a migration that runs in stages, a long-form research task, or a multi-step integration, and expect it to come back with progress rather than sitting idle until you prompt it.

Together, these change the mental model of the assistant. Instead of being a transient tool you invoke when you want to write code, Codex becomes a process that lives alongside your work — remembers what you asked it last week, owns its own scheduled tasks, and keeps building up context the way a new hire does over their first month.

What This Means for Hosting and DevOps Teams

If you run or support websites for a living, the integrations are where this release stops being an abstract announcement and starts looking like something to pilot.

The most immediately useful flows involve provider-specific plugins: Render for deployments, Neon for database operations, and Cloudflare (via its sandbox-execution support in the companion Agents SDK update) for edge configurations. A realistic first-week experiment is to wire Codex into a single staging environment and let it handle the drudge work that otherwise consumes engineer time: applying dependency updates, running migrations, rotating secrets, investigating cache-busting issues, or responding to uptime alerts. None of these tasks requires unusual cleverness, but they collectively devour attention, and they are exactly the kind of thing an ambient agent is well suited to.

The CI/CD side is similarly practical. With the CircleCI and GitHub Actions plugins, Codex can not only author pipeline configurations but drive them: inspect a failing build, pull the logs, propose a fix, open the pull request, and re-run the pipeline after merge. For agencies managing dozens of small client sites, that alone can shift the economics of maintenance work.

For teams running managed WordPress, PrestaShop, or Magento fleets, the ability to drive a browser directly is worth attention. Admin-panel tasks that no vendor exposes through an API — plugin audits, user cleanup, theme checks, or bulk configuration changes across several installs — become automatable without needing custom scrapers.

There are genuine risks to manage. Any agent that can click, type, and deploy is an agent that can also make expensive mistakes. Credential scoping matters more than ever: you want an agent that operates in staging to have staging credentials only, not an all-powerful token that happens to be sitting in your shell history. OpenAI's broader Agents SDK update emphasizes credential isolation from sandbox environments, which is good design, but the responsibility for scoping still falls on you. The same applies to the new plugins: Render, Neon, and the rest all accept API tokens, and those tokens should be narrow, rotated, and logged.

A reasonable adoption curve for most hosting teams looks like this: start with Codex doing read-only investigations (log analysis, build failure triage, documentation generation); promote it to low-stakes write operations in a dedicated staging environment; and only connect it to production tools once you have a few months of observed behavior and a clear audit trail of what the agent has been doing.

Availability, Platforms, and Pricing

The desktop app updates are rolling out to Codex users signed in with ChatGPT accounts. Computer use is available first on macOS; Windows and Linux support are not detailed in the announcement, and EU and UK availability is promised soon. Plugins, memory preview, and extended automations appear to be tied to the same Codex desktop client rather than to a separate tier.

On the pricing side, OpenAI's Pro tier remains the entry point for the bulk of these features at roughly 100 dollars per month, with a higher tier at 200 dollars per month for extended sessions continuing through May. Enterprise agreements are expected to follow. As with any preview-heavy release, some functionality — memory, extended automations, and a subset of the plugins — may be gated by waitlist or account flags even inside paid tiers in the early weeks.

For anyone who already uses Codex with a ChatGPT account, the update is a desktop-app upgrade away. For teams who have been waiting for a reason to pilot a coding agent inside real operational work rather than just a sandbox, this release is probably it.

The Direction of Travel

The bigger story behind this update is that OpenAI is no longer pretending Codex is just a coding assistant. Between computer use, persistent memory, scheduled multi-day tasks, and more than 90 integrations into the tools where software actually gets built and run, Codex is being positioned as the foundation for a broader agent platform — what some commentators have already started calling the groundwork for OpenAI's super app.

Whether that framing is hype or not, the operational truth is that the gap between AI that suggests code and AI that does the whole job just narrowed again. For hosting, DevOps, and agency teams, the practical question is no longer whether agents can touch your production systems — it is how quickly you can build the processes, permissions, and monitoring to let them do so safely. Codex for (almost) everything is the clearest signal yet that 2026 is the year to answer that question.