Codex has come a long way. Its first public release in 2021 captivated the community—a model that transformed text into Python seemed like genuine magic. However, the product itself never moved beyond beta testing and gradually faded into obscurity after the emergence of GitHub Copilot, which leveraged the same underlying technology.

By 2025–2026, Codex returned, but in an entirely different form. It's no longer just a code generation model; it's a full-fledged cloud agent capable of autonomously performing development tasks in an isolated environment.

Understanding the distinction between the “old” and “new” Codex is crucial, as they address fundamentally different problems.

From model to agent: what's changed

The initial Codex (August 2021) was a language model based on GPT-3, fine-tuned on public code from GitHub. It could:

• complete functions based on textual descriptions
• generate boilerplate code
• answer simple “code-on-demand” requests

In practice, this integrated excellently into IDEs via Copilot, but it couldn't work independently. The model couldn't run code, verify results, or fix errors—it simply output text.

The new Codex, announced in May 2025 and rolled out in ChatGPT in 2026, is an agent of a different class. Under the hood is the codex-1 model, a fine-tuned version of o3, optimized for engineering tasks. However, the primary change isn't in the model itself, but in its execution architecture:

• The agent gains access to a real cloud environment (sandbox).
• It can clone a repository, read files, run tests, and fix errors.
• Tasks are performed asynchronously—you assign a task and return to your code while the agent works.

This is the difference between “suggesting” and “doing.”

How it works in practice

Codex is available in the ChatGPT sidebar for Pro, Plus, Team, and Enterprise subscribers. Connecting to a GitHub repository is the first mandatory step. From there, you can assign three types of tasks.

Parallel tasks. You can run multiple agents concurrently, each operating in a separate sandbox based on your repository. One agent might fix a bug in the payment module, while another writes unit tests for a new API. Nothing gets blocked.

Long-term tasks. An agent can spend 20–30 minutes refactoring a large codebase. You don't have to wait by the screen—the result arrives as a ready-made pull request with a description of the changes.

Iterative tasks. If tests fail, Codex analyzes the logs, corrects the code, and reruns the tests—without your intervention at each step.

All work remains within the sandbox. The agent does not have access to production environments, private keys outside the repository, or external APIs without explicit permission. This is crucial for security, especially in a team environment.

For which tasks is Codex genuinely useful?

Experience shows that the agent is most effective in several specific scenarios:

• Technical debt. Large refactorings, framework migrations, dependency updates with breaking changes. Tasks that developers postpone for months, Codex completes in hours.
• Test coverage. Writing unit tests for existing code is tedious but important work. Codex handles this well, especially if the repository already contains tests as examples of style.
• Bug fixes from reports. If a report includes reproduction steps or a failing test, the agent is highly likely to find and fix the problem independently.
• Documentation. Annotating public APIs, generating READMEs for modules, JSDoc, and docstrings—tasks where accuracy is more critical than creativity.

Where Codex is currently weaker:

• Architectural decisions with business context—the agent doesn't know why a specific data structure was chosen.
• Tasks with vague requirements—the less clear the technical specification, the less predictable the outcome.
• Multi-stage scenarios with dependencies between teams or external services.

AiiN's conclusion

Codex in 2026 isn't just “improved autocomplete.” It's OpenAI's attempt to shift development from a reactive mode (human writes, model suggests) to a proactive one (human assigns task, agent executes).

For AI builders, this implies several practical considerations. First, task decomposition now matters more than prompt engineering—a clearly formulated technical specification yields a much better result than a conversational query. Second, Codex performs best in repositories with good documentation and tests—the agent uses these as context for its own decisions. Third, you still need to review the agent's pull requests—it's not an unsupervised autopilot, but a junior developer who doesn't ask unnecessary questions.

The transition from a helper model to an executive agent represents a paradigm shift. Codex in 2026 demonstrates what this looks like in a real product, not just a research paper.