The past two weeks have been eventful. OpenAI launched Codex on May 16. A few days later, Microsoft announced a coding agent for GitHub Copilot at its Build conference, and Google opened access to its own agent, Jules, during I/O. Then on May 22 Anthropic released the Claude 4 models and took Claude Code out of preview. All the major players now offer an agent, at the same time.
Codex stands out for one reason: it is not designed to be supervised while it works.
What has OpenAI launched under the name Codex?
The name is being reused, which has caused some confusion. In 2021, Codex was the OpenAI model behind the first GitHub Copilot. The new Codex is a different product: a software engineering agent that runs in the cloud, inside ChatGPT.
The user connects a GitHub repository, describes a task, and the agent carries it out independently. Each task runs in its own sandbox, a small isolated computer loaded with the project's code. The agent reads, edits, runs commands and tests, and when it is finished it returns the changes, a summary of what it did, and the logs, so the user can see exactly what it ran. If the result is satisfactory, the user opens a pull request. Several tasks can be launched at once while the user works on something else.
One detail deserves attention. While a task runs, the sandbox is disconnected from the internet. The agent cannot download arbitrary packages or send the code elsewhere in the middle of a job. This is a sensible default, and we would like to see it on every tool that runs code autonomously.
According to OpenAI, it runs on codex-1, a version of its o3 model tuned for software engineering. For now, it is available to Pro, Enterprise and Team subscribers, with access for Plus users announced for the near future. In April, OpenAI also released Codex CLI, an open-source terminal agent that works much more like Claude Code. OpenAI's own description is available in the Codex announcement.
What is the difference between supervised agents and background agents?
In our view, this is the real distinction, more significant than which company makes which tool.
A supervised agent works in front of the user, as Claude Code does in the terminal or Cursor does in agent mode. It asks before running commands, the user sees each step and can steer as it goes. This takes more of the user's time, because it requires attention, but it also makes it much harder for the agent to drift off course.
A background agent takes the task and works independently. The user returns to a finished piece of work and a report. Their attention is free for other things, which is the main appeal. However, the user did not see how the result was reached, and is reviewing the result rather than the process.
Neither approach is better. Each suits a different kind of work.
Which tasks suit a background agent?
Well-defined tasks with a clear end point. Adding a French translation file with the same keys as the English one. Updating a library and fixing whatever breaks. Writing tests for a function. Fixing a bug described in an issue, with steps to reproduce it. These tasks have clear boundaries and can be verified.
Which tasks do not?
Any task where the real work is determining what is wanted. "Improve the homepage." "Make checkout better." A background agent will produce something plausible, and it will likely be the wrong thing, because the underlying question was never answered. These tasks require a person thinking them through, with an agent assisting under supervision, if at all.
How can you tell whether an agent's work is correct?
Tests provide the answer. An agent's summary is written by the agent itself. It will report that it fixed the bug, and it generally believes it has.
A test, by contrast, runs and either passes or fails. This is why these tools perform much better on projects that already have tests: the agent can check its own work against something objective, and so can the user. On a project with no tests, which describes most small business websites we have worked on, verification relies on clicking through the site and hoping nothing is broken.
If you plan to let agents work on your code, we recommend giving them something to be checked against. Even a short list of manual checks helps: the contact form sends; the French page displays in French; the booking calendar shows next month. Someone goes through the list after every change.
Writing that list takes about an hour. It is among the least expensive forms of protection available for a website, with or without agents.
Who is responsible for code written by an agent?
The business that ships it remains responsible. The agent can work overnight, but its work still needs to be checked in the morning.
This raises a real concern. Background agents make it very easy to produce more code than anyone reads. Five tasks produce five pull requests, all passing, all plausible, and all merged one after another. When something then breaks, no one knows which of the five caused it, or why.
Responsibility does not transfer to the tool. If a customer's data is exposed, "the agent wrote that part" is not an acceptable answer to customers, to insurers, or under privacy rules.
How should a business set up coding agents?
We recommend using both kinds: background agents for routine tasks with clear boundaries, and supervised agents for any work where the objective is still being defined. Our expectation is that the tools will converge over the next year, and that "background or supervised" will become a setting chosen for each task rather than a product chosen once.
For a business owner considering whether to let agents work on their own systems, this distinction is the first point to clarify. Which tasks have clear boundaries? Who reviews the output? What is tested? Discussing these questions with an AI consulting professional before starting costs less than untangling five merged pull requests afterwards.