Skip to content

← Blog

OpenAI CodexGitHub Copilot12/23/2025 · Updated: 8/2/2026

OpenAI Codex vs. GitHub Copilot

How does OpenAI Codex perform in day-to-day development, and where are its strengths and weaknesses compared with GitHub Copilot?

Further reading (August 2026): For how the agents have evolved since, see my hands-on comparison Claude Code vs. Codex vs. Cursor, where three agents build the same website from the same documentation.

I wrote this post using Visual Studio Code v1.107.0 on macOS with the following extensions:

What Role Does Tooling Play?

Short answer: a decisive one. We’re still early in AI-driven development, and some tools simply work poorly or not at all. The consequence is that the AI-driven-development approach gets dismissed as “doesn’t work.” In my view, poor tooling choices can lead to poor (or missing) strategic decisions about whether and how to adopt AI-driven development.

Good tools, on the other hand, produce the typical “wow effect” and an almost surreal productivity boost. These measurable effects are critical when you talk to decision-makers outside the technical “IT bubble.” That’s the motivation for this post.

By the way, there are now alternatives to pure AI plugins like Codex or Copilot—IDEs specifically optimized for AI-driven development. I cover one example in my post AI-Driven Development with Amazon Kiro. Another interesting option is Google Antigravity, especially because of its Agent Manager and native browser integration.

OpenAI Codex

OpenAI Codex has been around in different forms for a while, but it hadn’t really been on my radar. I only revisited it after the IDE extension release at the end of August 2025. Codex, similar to GitHub Copilot, is an AI agent capable of developing software. It exists both as a standalone product (without IDE integration) and as an extension for Visual Studio Code. In this post I focus on the IDE variant. To use Codex, you need an OpenAI account and a subscription (I have a Plus plan).

Codex supports the classic chat mode and two agent modes (“normal” and “full-access”). In “normal” mode the agent edits files in the workspace autonomously without further prompts. It can also use the IDE’s tools, e.g., search files or execute terminal commands. Before running commands the agent asks for confirmation. If I enable “full-access,” those confirmations go away.

I can also choose whether requests are processed locally or in the cloud. The latter means the agent runs in its own cloud environment and handles the requests there. This cloud environment is set up once in your OpenAI account; for example, you can connect a GitHub repository. I didn’t use the cloud variant for this post and ran all tests locally.

Another parameter controls how much “reasoning effort” the agent should invest: Low, Medium, High, and Extra High. The higher the setting, the more time the agent takes and ideally the better the result. This is where the first clear difference to GitHub Copilot appears: while I can also choose OpenAI models there, I still don’t get the full package. This becomes obvious, for example, because you cannot steer the reasoning. With Codex, I soon started asking questions that I would otherwise have moved to the separate ChatGPT app. Basically anything beyond pure coding: conceptual architecture, design discussions, or just translating a text.

On the other hand, Codex only lets you pick OpenAI models. That’s a notable difference to GitHub Copilot, which offers models from different vendors. I still find Anthropic models like Claude Opus 4.5 best suited for front-end development, especially for application layout. In my daily work I therefore switch between Copilot and Codex depending on the task at hand.

Visual Studio Code Integration

Codex is well integrated into Visual Studio Code, but there are still differences to the truly excellent integration of GitHub Copilot. Copilot can, for example, use additionally configured MCP servers for agents (e.g., to access Confluence). I couldn’t get that to work in Codex on the first try. I also find Copilot’s communication with me more transparent, for example when it executes terminal commands.

Actual development together with Codex is very smooth and pleasant. Even complex requests are executed cleanly. Codex uses VS Code’s internal tools, such as file search and executing shell commands, when needed. Unlike Copilot, Codex can also access files outside the workspace. That proved very useful in my tests. For example, you can instruct Codex to port a specific feature (in my case i18n) from one project to another. You provide the file path to the other project in the prompt, Codex reads it, analyzes it, and transfers the relevant parts into the current workspace. Very cool!

Context Selection

Both plugins can automatically choose the context, i.e., which files are considered. Alternatively, you can manually specify which files should be included. I generally recommend selecting the initial context manually, e.g., via a bootstrap prompt. That prompt references the most important files in the workspace that every AI agent needs to know before starting the actual work. This includes architecture overviews, coding standards, CI/CD pipelines, etc. You can also add general instructions for how certain tasks should be carried out. A concrete bootstrap prompt example shows how this can look in practice.

Both Codex and Copilot can also use images such as screenshots as context. This is especially useful for front-end tasks, e.g., when implementing a design created in Figma. In my tests this worked well with both plugins.

Context Size

The maximum context size is a decisive factor in how well collaboration with the AI agent works. The larger the context, the more information is available to the agent to process requests correctly. In an AI-driven development scenario, that typically includes source-code files, but also requirements, architecture overviews, code-quality guidelines, and implementation plans.

The good news is: both GitHub Copilot and Codex offer sufficiently large contexts. Copilot automatically frees up space when the context is about to overflow by summarizing the previous conversation. You do lose some details, but in practice it works very well.

Codex shows the current context “fill rate”. However, the context is so generously sized that, at least in my case, I haven’t run into issues so far.

Pricing

GitHub Copilot’s pricing model is very transparent. Depending on your plan, you get a certain request budget. How heavily your sessions draw on that budget depends on the model you use. Once you exhaust the budget included in your plan, you can easily purchase additional requests and you’re productive again. That’s how it should be, kudos for this professional approach.

With Codex, the pricing is unfortunately a bit less flexible. There are limits for allowed requests similar to GitHub Copilot, again depending on the plan. The current budget usage is shown in the Codex extension, and it also displays the “waiting time” until the next budget reset. It becomes problematic once you hit the limit: your only options are to wait for the next reset or upgrade to the next plan level. A flexible top-up of additional requests is not available.

Conclusion

With Codex, OpenAI has made up significant ground in the fast-growing AI-driven-development market. While GitHub Copilot used to be almost unavoidable for professional users, we’ve got a strong alternative now. It would be helpful, however, if OpenAI made the pricing model more flexible, for example by offering additional request packages.