Your Apps Don't Need an API Anymore. Codex Just Proved It.

Transcript

OpenAI revamped Codex completely, and I am blown away by how useful that new app is. On April 16th, OpenAI turned Codex into a desktop agent that operates every single app on your Mac, clicking, typing, running in the background while you work. It’s faster and more reliable than Claude’s version of computer use, and it’s by a much bigger margin than I expected. That matters because most enterprise software doesn’t have modern APIs, and Codex doesn’t need them. I’m going to walk you through what Codex is now, How it got this good, what OpenAI is really building, and where both labs are going. And of course, what you should do about it.

The reason to pay attention goes deeper than the capability gap. In a recent interview with Ashlee Vance, Greg Brockman said models have gone from being the product to being part of the product. I think he’s correct. The brain is effectively built. The work now from the hyperscalers is on the body. Both labs have decided the body is priority one, but they’re building very different approaches, and Codex’s April release shows that split really cleanly.

Let me start with what Codex is now. OpenAI launched the original Codex command line in April 2025. It was a command line tool for developers. You typed prompts, it wrote code. That was essentially the whole product. A year later, Codex has become a full desktop application that can see your screen, click and type across the Mac, generate images, browse the web in its own built-in browser, remember what you’ve been working on, schedule itself to wake up on long-running tasks, and run multiple agents in parallel without hijacking what you’re doing.

The transformation has happened in stages, but you can see the direction. February 2nd, the macOS desktop app launched. March 4th, Windows support, March 5th. GPT-5.4 folded Codex’s coding capability into the general-purpose model line. And March 19th, OpenAI confirmed the super app consolidation plan. April 16th, the release that made Codex what it is now was all about computer use, in-app browser, image generation, memory, and 90+ new plugins in one app.

The heart of that transformation is computer use. Codex can operate any macOS application by just seeing your screen and just clicking and typing like a person. It does this in the background, which means multiple agents can run in parallel while you work on something else. That’s not a feature update. That’s actually Codex shifting the category. Codex is no longer really a coding tool.

It’s a desktop agent that can do anything a person can do through a graphical interface. And yes, it still codes too. Does it actually work? Yes. And in 2 specific ways that matter. I’ve been running Codex and Claude side by side on the same workflows for the last week or so.

And what I see is this. Codex is fast. It moves through a workflow at something close to the speed of a person who already knows that software. Claude’s version is slower, like the cursor hesitates, the agent rethinks and sometimes retries. Tasks that finish in 2 minutes on Codex can take 5 or 6 on Claude. And Claude is limited in where it can go.

Claude prefers Chrome. Codex can touch anything on the desktop. So the gap isn’t subtle. Codex is also reliable. The failure mode of computer use products for the last year plus has been really specific. The agent gets partway through the task, hits an unexpected modal dialog or some other issue, fumbles, and you have to take over and restart.

And then why do it at all? Codex’s implementation, generally speaking, doesn’t fumble. It backs up when it needs to, it finishes, and it does so quickly. That’s what moves the capability from impressive for demos to I could actually use this. Sam said something in a recent Ashlee Vance interview that lines up with what I’ve been seeing. Asked about Codex versus Claude today, his read was, our product is ahead in many ways.

Of course he said that. But on computer use specifically, I do agree with him. Some of that gap comes from the model. GPT-5.4 is the first general-purpose model OpenAI has shipped with native computer use capabilities baked in. It benchmarks in the mid-70s on OSWorld, which puts it above the human baseline for graphical user interface control. That’s right, better than humans.

But the model isn’t the whole story. Alexander Embiricos, who works on the Codex team at OpenAI, called the background computer use implementation basically deep OS-level wizardry. I feel it when I use it. The specific architectural choice he was pointing at is that background agents don’t hijack your cursor or steal focus from the app you’re working in. You can keep typing in one window while an agent is clicking around in another. That’s what makes parallel agents actually usable instead of theoretical.

3 Codex agents on 3 unrelated tasks. You can walk away. You can come back 20 minutes later. The 3 tasks are just done. And that’s changed how I schedule my day. It’s not just me.

Since the release, early users on X have been posting their first real workflows with Codex, and the range of what’s working is wider than I would have expected. Stuff like mass clearing Slack, right? Reading and triaging hundreds of unread bot messages and daily digest so the inbox starts clean. Or building a Spotify playlist by driving the desktop app from a verbal description. Or walking through a front-end app to catch visual regressions while the developer keeps shipping the next feature. Or reproducing a browser bug, screenshotting the reproduction, pasting the images straight into a pull request description.

Or running end-to-end tests on the app you just built and then self-fixing the issues it finds. Or driving a legacy internal dashboard that never had an API, exactly the software category automation has given up on for years. One person wired up a daily recap that pulls Git commits, issue tracker updates, and calendar events, writes the meeting minutes to Notion, and then drops prioritized to-dos into Apple Reminders. Another one has Codex play daily login routines in the background so they don’t have to. Another detects when the user is slouching on their webcam and pops open a stretching video. None of those are demos.

They’re actually workflows people ran and then decided to keep running. And that’s the tell. Computer use stops being a novelty when you reach for it the second time. And that’s really the line Codex crossed. A desktop agent that can drive any Mac app, runs in the background, and actually finishes the work is the dream. Which brings us to the next piece.

What is OpenAI really building with this launch? And why does it look so different from what Anthropic is doing? Anthropic pivoted out of the coding box first. In January, they shipped Cowork inside the existing Claude desktop app. Cowork is Claude Code for people who don’t write code. You point the agent at a folder on your Mac, describe what you want done, and it does multi-step knowledge work For you.

From there, it was compound moves, right? Adding plugins, scheduled tasks, computer use and research preview on Mac, and then on Windows, Dispatch that lets you assign tasks from your phone. And by April, the Claude desktop app holds 3 modes on one surface, right? It has chat for discussion, Cowork for knowledge work, and code for software, plus a plugin layer for specialized capabilities like Claude Design. Both labs made the same high-level move. Both got out of the coding box, both built desktop apps, but they did not move in the same direction.

Anthropic pivoted toward knowledge work. Towards synthesis, research, writing, analysis, the kind of work where you define an outcome and the agent does the intellectual labor. OpenAI pivoted towards something broader. Sam Altman admitted in the Vance interview that OpenAI started the year behind Anthropic on real-world coding data. He gave Anthropic real credit for being earlier and said OpenAI only appreciated the gap in hindsight. But when OpenAI made their move, they moved wider.

In the same interview, Brockman described OpenAI’s strategic vectors, the agentic platform, computer work specifically, and personal AGI that does things for you in the real world. And he drew a line between knowledge work and computer work. Computer work is broader. It’s anything that happens on a computer, whether or not it requires deep knowledge. Ops work, creative work, research, automation. Knowledge work sits inside that surface, but the surface is actually bigger.

That aperture difference maps directly to the mechanism each lab chose. If the model is the brain and the work is the body, what is the body made of is the question here. For Anthropic, it’s structured interfaces. File operations in Cowork, MCP servers, connectors, the 3,000+ integrations already in the Claude ecosystem, and Conway, the always-on agent environment that leaked in early April with its own sidebar UI, its own extension format, webhook triggers, browser control, et cetera. All of that is excellent architecture. It really is.

But it also depends on the ecosystem cooperating. Every MCP server has to be built by someone. Every connector has to be maintained. Every webhook has to be configured. How far the body can reach depends entirely on how fast the world ships agent-ready interfaces. OpenAI is building a different kind of body.

OpenAI’s body is computer use. The agent drives the same graphical interface that you drive, and that changes the math completely because the body’s reach is now bounded by how much software has a graphical interface, which is effectively all of it. Legacy enterprise software works, internal tools work, SaaS that will never build an MCP server works, the vendor portal your ops team tolerates works, the app your company built in 2019 and never touched again works. OpenAI doesn’t need the software industry to build for agents. The body just uses whatever’s already there. The 2 products look similar on a feature matrix, but the bodies underneath, the way the agents are hooked into harnesses, it’s not the same.

And you can see this in how the 2 apps are shaped. Anthropic’s Claude app is built like a tool that assumes you know the work you’re in. Every mode has a scoped permission model. And when you open Cowork, it asks you to point at a folder before it does anything. That friction is the product choice. It communicates what’s about to happen so you can be deliberate.

The whole app is explicit in the way the rest of Anthropic’s strategy is. Explicit scopes, explicit permissions, explicit interfaces. OpenAI’s Codex app is the opposite. It’s built like a tool that assumes you don’t want to think about modes. You describe the outcome, the agent decides whether to open files, whether to drive a graphical user interface, run a plugin, browse the web, or write code. Computer use is the escape hatch when nothing else works.

Plugins are opinionated bundles invoked without explicit selection. Memory keeps context flowing between tasks, and the app is implicit in the same way the rest of Codex is. The agent figures out what to do because you shouldn’t have to tell it which interface to use. That’s what OpenAI is actually building. A body that doesn’t need the world to cooperate, a product that doesn’t ask you to think in modes, a roadmap where the model is the input and the body is the whole product. Which leaves the question, how did Codex get here?

Codex’s computer use didn’t come from nowhere. It came from a team OpenAI bought 6 months before the April release. In October 2025, OpenAI acquired a 12-person company called Software Applications Incorporated. The company was the team behind Sky, an unreleased macOS-native AI interface that was doing essentially what Codex’s computer use does now. All 12 members joined OpenAI. One of the co-founders, Ari Weinstein, is now a designer at OpenAI, and when Codex shipped, he publicly credited his team by name for the cursor motion work.

The specific detail that makes background computer use feel like a cowork instead of malware. What makes this team One of one. Weinstein and his co-founder Conrad Kramer previously built Workflow, the iOS automation app Apple acquired in 2017 and turned into Shortcuts. Shortcuts is now the system-level automation layer across iOS, iPadOS, and macOS. Sky’s 3rd co-founder, Kim Beverett, spent 10 years at Apple as a senior program manager working on Safari, WebKit, Privacy, Messages, Mail, Phone, FaceTime, and SharePlay. That’s a decade-plus build of exactly the skill set that makes Codex’s computer use work the way it does.

Deep macOS integration, accessibility and screen recording permission handling, motion paths that don’t feel robotic, the kind of OS-level work that takes years of Apple experience to do well. The line from Workflow to Shortcuts to Sky to Codex, it only exists in one place with this team. OpenAI paid for it, and the payoff is in the April 16th release. The deep OS-level wizardry Embiricos described, that’s not a metaphor. It’s a specific team’s specific accumulated knowledge now applied to a product where it matters commercially. The same pattern shows up elsewhere.

Anthropic’s Vercept acquisition earlier this year, the team that shipped Claude’s Windows desktop control within 4 weeks of joining, it’s a parallel move on their side. Then there’s io, Jony Ive’s hardware startup OpenAI bought for several billion dollars, which is the larger version of the same thing. The labs are essentially spending on narrow, hard to replicate human expertise, not for the intellectual property, often not for the product, for the team. That’s a consistent pattern. Models are starting to converge. Capabilities that used to take 2 years can now be replicated in 6 months or less.

What isn’t being commoditized is a specific team with a specific history. Those teams are a very scarce resource in the Valley right now. If you’re watching the lab-to-lab competition, the acquisition pattern is telling you as much about where advantage will live as benchmark scores might. So we know what Codex is. We know what OpenAI is really building, and we know how Codex got this good. The last big question is this.

Where are both labs going from here? Both labs are converging on the same destination: an agent that’s persistent, ambient, event-driven, and works across all of your surfaces, and that does things on your behalf without you prompting it every time. The 2 clearest signals of how each lab plans to get there are Chronicle and Conway. Chronicle is OpenAI’s latest step. They shipped it on April 20th, 4 days after the main release, as a research preview for ChatGPT Pro users on macOS. Chronicle captures your screen periodically and processes the images on OpenAI servers and writes local markdown memory files that Codex pulls into future sessions as context.

Thibault, who heads Codex, called it early and token hungry, but said it had changed how he and many people at OpenAI work. Altman described it as telepathy-like. What’s Chronicle actually doing here? The shallow read is that it’s an ambient memory feature. The deeper read is that it’s the training signal for computer use. If your agent is going to drive the same graphical interface you drive, it sure benefits enormously Chronicle is the layer that makes driving your software smarter over time.

So your workflows, your app preferences, your muscle memory patterns, they all become context the agent inherits. The privacy trade-off is that the screen captures are sent to OpenAI servers. They have unencrypted local memories, and they’re not available for that reason in the EU, UK, or Switzerland. And that’s a cost OpenAI accepted because the feature works better with it and because the data makes the agent better at driving your software over time. So let’s talk about Claude Code. Conway is a different kind of signal.

On April 1st, Anthropic accidentally published the Claude Code source code, roughly 500,000 lines of TypeScript, when a packaging error pushed it to a public registry. Buried inside that was Conway, an always-on event-driven agent environment with its own sidebar UI, 3 panels called Search, Chat, and System, webhook-triggered invocation, a proprietary extension format, browser control via Claude in Chrome, and deep connector integration. I’ve written about this at length separately, so I’ll keep it short here. Conway assumes the world is going to build for agents with structured triggers, explicit extensions, event-driven execution.

It’s designed to plug into agent-native interfaces that other companies will build over the coming year or 2. Does that assumption hold? Anthropic wins this bet if MCP adoption accelerates, if enterprise software ships clean integrations, if the standards mature quickly enough for Conway to have a rich substrate to act on. It’s a good bet in many ways. MCP is already spreading very fast. It’s become a de facto standard.

Anthropic is the company pushing it the hardest. The developer ecosystem around Claude Code has tremendous momentum. But it requires the ecosystem to move, and enterprise software ecosystems tend to move slowly. The long tail of internal tools is not getting agent interfaces on a timeline that matters. OpenAI does not need that. The agent drives whatever software you use yourself.

No vendor has to cooperate. No integration has to get built. Anthropic needs the whole software industry to show up and build, and OpenAI does not. So my read is the second scenario is more likely on the timescale that matters. But it’s a hypothesis. If enterprise software moves faster than I think, that picture could change in Claude’s favor.

One more piece worth laying out because it tells you how serious OpenAI is about this specific direction. In the Vance interview, Brockman and Altman described 3 strategic vectors: the agentic platform itself, computer work specifically, and personal AGI that does things for you in the real world. That’s what they say their whole roadmap is, those 3 things. The clearest signal of how serious they are is in what they cut. Sora got shut down, a drug discovery effort got pulled, not because the work wasn’t interesting or important, but because the use cases didn’t ladder up to those 3 vectors. That’s an unusually disciplined cut for a company that’s been accused of sprawl for a while, and it tells you leadership is willing to kill popular products to stay focused.

One more nugget here. Compute is explicitly a profit center now, not just a constraint. OpenAI is monetizing the scarcity, which means the super app consolidation plan— ChatGPT is a conversation hub, Codex is an agent, Atlas is a browser, That’s not just a product bet. It’s a bet on routing users into a platform where compute gets billed at margins OpenAI chooses. And that changes the financial shape of what they’re building. So that’s where both labs are going.

2 paths, 2 bets, and 2 roadmaps that are really quite different. Which leaves the last question. What do you do with all this if you’re using these tools or making decisions about them? Computer use is the one capability where the gap between Codex and Claude is wide enough to change what you actually use. If your work involves driving software that doesn’t have good APIs, and for most operators, a lot of it does. Codex is a product that’s ready today.

Claude will probably get there. The research preview is improving visibly, and I know that they like to close these competitive gaps. But today, Codex wins on this specific capability by a wide enough margin to matter. If you’re tackling dashboards, if you’re tackling front-end visual testing, if you’re dealing with Slack and email at the same time, with bug reproduction, with cross-app workflows that you’d otherwise be copying and pasting between tools, anything where the bottleneck is the friction of the interface rather than the reasoning, Codex feels like a good fit. Now, on scoped and bounded work, Claude is often still tighter and more efficient.

Cowork’s point at a folder and describe the outcome ergonomics are cleaner than Codex’s one agent figures it out for tasks where you want that explicit control over what the agent touches. Claude Code remains rightly loved for its developer-friendly ergonomics and its recent focus on deploying multi-agent workflows for coding. Codex retains an advantage in refactoring very complex codebases and going after long-running tasks. Although that gap has narrowed with the release of Opus 4.7. Those parameters are kind of set and they’re not changing super quickly. The difference to me still boils down to the value for computer use and the differing design philosophy of Codex versus Claude.

On cross-tool triage, on long-running parallel agents, on ambient work that doesn’t fit into a single mode, Codex is the default now. Chronicle actually accelerates that gap for anyone on Pro who’s willing to turn it on. Parallel background agents work reliably enough that queuing 3 or 4 tasks in Codex before stepping out has become a real workflow instead of a party trick. So use both. Which one should you lean on? It depends on where your work lives.

If it lives in knowledge work that’s going to get proper agent integrations over the next year or so, or has them already, Claude’s architecture will get cleaner and more reliable. If it lives in computer work more broadly, the long tail, the legacy tools, the internal systems nobody maintains, Codex is the one that reaches that long tail. So what do you watch for over the next few months to see which way all of this trends? 2 things. First, Conway. If Anthropic announces it publicly, event-driven agents become a real category alongside ambient context agents, and the 2 paths framing starts to really crystallize.

If Anthropic delays it, or maybe even kills it, it tells you they’ve lost confidence in the ecosystem cooperates bet on a timescale that matters, and more of the category converges on computer use plus ambient context by default. Second, watch for MCP adoption velocity. Anthropic’s bet on the ecosystem only pays off if MCP spreads faster than it currently does. If a major wave of enterprise vendors ships on MCP servers in the second half of the year, and Salesforce was a good hint in that direction, Anthropic’s architecture looks better and better and better. If they don’t, or if they ship thin wrappers that don’t work as well as the actual UIs, driving the UI directly stays the better path.

What’s the one thing to take away from all of this? Look, I’ll keep it simple. 6 months ago, any piece of software that did not have an API was effectively outside the automation conversation. You could not get an agent into it. You had to wait for the vendor to ship hooks, or you had to build the integration yourself. That’s just not the state of things anymore.

Codex’s computer use means that if the software has a screen, an agent can effectively drive it. That widens what’s automatable by a much, much bigger margin than most people are really budgeting for. For anyone thinking about automating operations, the surface of what’s possible is so much larger today than it was at the end of last year or even a month ago. And the reason it’s possible The reason Codex can actually drive your software well enough to deploy, that’s not the model per se. The model’s the brain. Codex is the harness around it.

It’s the body. And OpenAI built that body specifically by buying a team with a very clear, specific history of expertise. Keep an eye on that acquisition pattern. It’s going to tell you as much about who wins the next phase of this as any benchmark chart is going to give you. Now, if you want to lay this all out and get into the details of how to use Codex day to day to drive your workflows, If you want to dive deeper on the Conway leak details, on the full comparison with Claude, I wrote that all up on Substack. Link is in the description.

Hit subscribe if you want these the moment they drop, and I’ll see you in the next one.