How to Use Codex in VS Code

Most developers searching for how to use Codex in VS Code hit a wall fast: the name means 3 different things depending on the year you’re reading about it.

The original OpenAI Codex API was deprecated in March 2023. What’s available now is a full autonomous coding agent that reads your files, runs terminal commands, and delegates tasks to cloud sandboxes while you keep working.

This guide covers the current product. You’ll learn how to install the extension, configure it correctly, and use it for code generation, debugging, documentation, and multi-file refactoring.

What Is Codex in VS Code?

Codex in VS Code is OpenAI’s autonomous coding agent, installed as an IDE extension that reads your files, runs terminal commands, edits code, and delegates longer tasks to a cloud sandbox. It is not an autocomplete tool.

The name has a confusing history. The original OpenAI Codex was a GPT-3-based model released in 2021 that powered the early versions of GitHub Copilot. OpenAI deprecated that API in March 2023 (OpenAI, 2023). What the current VS Code extension connects to is a completely different product that launched in May 2025.

The 2025 Codex is powered by GPT-5-family models and operates as an asynchronous agent, not a suggestion engine. It can run tasks for up to 25 hours in isolated cloud sandboxes, manage multiple workstreams in parallel, and open pull requests on GitHub when a job is done.

How Codex Differs from the GitHub Copilot Extension

These 2 tools serve different jobs in a developer’s workflow. Confusing them leads to frustration on both sides.

Copilot is always on, delivering ghost-text completions as you type. Codex is something you delegate to. Use Copilot for real-time editing flow and Codex for the tasks you’d otherwise push to the backlog.

What Happened to the Standalone OpenAI Codex API

Deprecated March 2023. OpenAI directed developers toward the Chat Completions API using GPT-3.5 Turbo and GPT-4-class models instead.

GitHub’s “Copilot X” announcement in March 2023 confirmed that Copilot had moved to GPT-4-class models, formally ending its dependence on the original Codex model. The name “Codex” then sat dormant until OpenAI reused it in May 2025 for a fundamentally different product: a cloud-based software engineering agent built on reasoning-optimized models from the GPT-5 family.

The 2021 model and the 2025 agent share a name. They share nothing else technically.

What Are the Requirements to Use Codex in VS Code?

Codex requires a paid ChatGPT subscription and the official OpenAI extension installed in VS Code. No separate Codex subscription exists. The extension itself is free; access gates on your ChatGPT plan.

According to OpenAI’s official documentation, Codex is included across ChatGPT Plus, Pro, Business, Edu, and Enterprise plans. Usage limits and credit pools vary by tier.

Account and Subscription Requirements

Minimum plan: ChatGPT Plus at $20/month gives access to local tasks, Codex Cloud delegation, and GitHub code review.

• ChatGPT Free: limited trial access only
• ChatGPT Plus ($20/month): 30-150 GPT-5.3-Codex messages per 5-hour rolling window
• ChatGPT Pro ($200/month): higher rate limits, priority access
• Business/Enterprise: shared credit pools, RBAC controls, compliance API access

API key access also works for the extension and the Codex CLI, but you lose cloud features including background task delegation and GitHub code review. Worth knowing before you go the API key route.

VS Code and Extension Requirements

Extension ID: openai.chatgpt, publisher: OpenAI. As of mid-2026, the extension has 9.8 million installs on the Visual Studio Code Marketplace (VS Code Marketplace, 2026).

Supported operating systems: macOS, Windows, and Linux. On Windows, Codex runs natively with the Windows Sandbox or through WSL2 for a Linux-native environment. The extension also works with VS Code forks including Cursor and Windsurf.

For JetBrains IDEs (Rider, IntelliJ, PyCharm, WebStorm), a separate JetBrains plugin is available through the JetBrains Marketplace.

How to Install and Activate GitHub Copilot in VS Code

Installation takes under 2 minutes. The process is the same whether you use a ChatGPT subscription or an API key to authenticate.

The Codex extension reached 9.8 million installs on the VS Code Marketplace (VS Code Marketplace, 2026). Among developers who gain access to AI coding tools, 81.4% install the IDE extension the same day (Tenet, 2025).

Installing the Extension

Open the Extensions panel in VS Code (Ctrl+Shift+X / Cmd+Shift+X). Search for “Codex” and select the extension published by OpenAI.

Alternatively, run this in the VS Code Command Palette:

 ext install openai.chatgpt 

After installation, the Codex icon appears in the activity bar. In VS Code, it defaults to the right sidebar. If you prefer it on the left, drag it back to the primary activity bar.

Signing In and Authorizing Access

Click “Sign in with ChatGPT” in the Codex panel. Your browser opens and prompts you to log into your OpenAI account.

After authentication, the browser redirects you back to VS Code and the Codex panel activates. No manual API key setup is needed with a ChatGPT subscription. If you sign in with an API key instead, cloud delegation features including background task execution are unavailable.

One thing to check: the extension updates automatically, but verify you’re on the latest version if Codex behaves unexpectedly. Stale extension versions occasionally surface after major OpenAI model updates.

How Does Inline Code Completion Work with Codex in VS Code?

Here’s a critical clarification most tutorials skip: Codex in VS Code does not provide inline ghost-text completions. That’s GitHub Copilot’s job. Codex operates through its sidebar panel and runs as an agent, not as an autocomplete layer.

If you’re looking for the ghost-text completion experience (Tab-to-accept suggestions as you type), you need GitHub Copilot, not the Codex extension. The 2 tools do different things.

What Codex Does Instead of Inline Completion

Codex reads your open files automatically as context, then applies code edits based on your prompt in Agent mode. The distinction matters for workflow planning.

Chat mode: Conversational responses, answers questions, explains code, plans before making changes. No edits applied automatically.

Agent mode (default): Reads files, makes edits, runs terminal commands inside your working directory. Needs your approval to access the network or work outside the project folder.

Agent (Full Access) mode: Same as Agent mode but with network access and no approval prompts. Use cautiously, especially on projects with sensitive data or production connections.

Using @file References for Precise Context

Codex automatically picks up your open files as context. For files outside your current view, tag them directly in your prompt.

` Use @example.tsx as a reference to add a new page named "Resources" to the app that contains a list of resources defined in @resources.ts `

Shorter, more targeted prompts consistently produce better output when you tag files this way. The model doesn’t have to guess what you’re referencing.

How to Use Copilot Chat to Run Codex-Powered Conversations in VS Code

This section covers the Copilot Chat panel in VS Code, which is a separate product from the Codex extension. Copilot Chat (GitHub.copilot-chat extension) uses GPT-4o, Claude, or Gemini depending on what you select. It’s not the same as the Codex sidebar agent.

That said, understanding both tools and when to switch between them is part of using the VS Code AI ecosystem effectively. GitHub research with over 2,000 developers found a 55% increase in task completion speed when using AI coding assistance (GitHub, 2024).

Slash Commands and What They Do

Copilot Chat uses slash commands to trigger specific workflows. Each one scopes the model’s behavior to a defined task.

Copilot Chat’s inline chat mode (Ctrl+I / Cmd+I inside the editor) lets you run these commands directly on a selection without opening the sidebar panel. Useful when you want surgical edits without breaking your scroll position.

Using Agents to Scope Context (@workspace, @terminal)

@workspace tells Copilot Chat to index your entire project, not just open files. The model can then answer questions about files you haven’t opened and suggest changes consistent with your existing patterns.

@terminal includes your terminal output in the chat context. Paste an error, add @terminal, and Copilot Chat can trace the failure through your open files to suggest a targeted fix.

@vscode scopes questions to VS Code settings, extensions, and configuration. Helpful when you’re asking about editor behavior rather than your code.

How to Use Copilot Inline Chat for Targeted Code Edits

Inline chat (Ctrl+I / Cmd+I) opens a prompt field directly inside the editor, over your code. It’s distinct from the sidebar Copilot Chat panel. The difference is scope: inline chat operates on whatever you’ve selected, nothing else.

Developers who use Copilot complete pull requests 4 times faster on average, with median PR time dropping from 9.6 days to 2.4 days (Opsera via Tenet, 2025).

When to Use Inline Chat vs. the Sidebar Panel

Inline chat is faster for changes you can describe in one prompt without multi-turn context. The sidebar panel is better when you need to ask follow-up questions or build on previous context in the same session.

• Renaming a function and updating its callers: inline chat on the selection
• Generating a new module from scratch: sidebar panel with @workspace context
• Fixing a specific bug in 3 lines: inline chat with the error message pasted in
• Refactoring a class across multiple files: sidebar panel or Codex agent

One habit that saves time: always select the code you want changed before triggering Ctrl+I. Without a selection, Copilot Chat works from cursor position and tends to generate new code rather than modify existing code.

Accepting, Discarding, and Regenerating Inline Suggestions

Accept: Click “Accept” or press Enter on the diff overlay. The change applies to your file immediately.

Discard: Press Escape or click “Discard.” No change is made. Regenerate by triggering Ctrl+I again with a revised prompt.

Worth noting: inline chat changes can be undone with Ctrl+Z / Cmd+Z like any manual edit. Copilot applies them as regular edits in the file’s undo history, so there’s no special rollback needed.

How to Generate Code from Comments Using Codex in VS Code

This is one of the original use cases for AI code generation and it still works well in 2025, though it operates differently depending on which tool you’re using.

GitHub Copilot still supports comment-to-code generation through its inline completion engine. Codex (the OpenAI agent) handles comment-driven generation through its Agent mode, reading your comments as task context rather than as triggers for ghost-text suggestions.

Comment-Driven Generation with GitHub Copilot

Write a descriptive comment above where you want code to appear, pause typing, and let Copilot’s ghost-text suggestion appear. Accept with Tab.

 // function that validates an email address using regex // returns true if valid, false otherwise 

Specificity changes the output quality significantly. A vague comment like // handle auth produces generic code. A comment that names the library, the expected input types, and the edge cases to handle produces something much closer to production-ready.

Copilot now generates roughly 46% of the average developer’s code, rising to 61% in Java projects (GitHub, 2025). That number reflects how much of a typical session is comment-triggered or context-triggered completion, not manual typing.

Comment-Driven Generation with the Codex Agent

In Codex’s Agent mode, you describe the task in the sidebar prompt rather than writing a comment in the file directly. But you can tell Codex to use existing comments as its spec.

Try this workflow: write TODO comments throughout a file describing what each function should do, then open the Codex panel and prompt:

 Implement all TODO comments in the open file. Follow the existing naming conventions and error-handling patterns. 

Codex reads the file, finds every TODO comment, and implements them in sequence. It then runs any existing tests to check its work before reporting back. That multi-step reasoning is what separates agent-based generation from single-shot autocomplete.

Using Docstring-Style Comments as Generation Prompts

JSDoc, TSDoc, and Python docstring formats work especially well as generation triggers. The structured format gives the model stronger signal about expected inputs, outputs, and behavior.

Python example:

 def calculatediscount(price: float, usertype: str) -> float: """ Calculate discount based on user type.

Args: price: Original price in USD usertype: ‘standard’, ‘premium’, or ‘enterprise’

Returns: Discounted price. Enterprise gets 30%, premium 15%, standard 0%.

Raises: ValueError: If usertype is not recognized. 

Copilot generates the function body from that docstring with high accuracy. The explicit Args/Returns/Raises structure reduces hallucinated behavior compared to free-form comments.

How to Use Codex for Code Explanation and Documentation

Codex reads and explains unfamiliar code as a core part of its workflow, not a side feature. Open the relevant files in VS Code, open the Codex sidebar, and ask directly.

About 4 million developers actively use Codex each week as of April 2026 (OpenAI, 2026), partly because onboarding into unfamiliar codebases is one of the most time-consuming parts of any engineering role.

Understanding Unfamiliar Codebases with Codex

Open the files you want explained and prompt Codex in Chat mode. No slash command needed.

Good prompts are specific about scope:

• Explain how the authentication middleware in @auth.ts validates JWT tokens

• Trace the data flow from the API call in @client.py to the database write

• What does this function do and when would it throw?

Codex reads the file context, discovers call sites, and explains logic, dependencies, and edge cases in one pass. For developers new to a codebase, GitHub research from 2024 found a 25% speed increase in navigation when using AI assistance (GitHub, 2024).

Generating Documentation with Codex

Select the function or module. Open Codex. Prompt it to write the docs.

A practical prompt for Python:

 Write a Google-style docstring for the selected function. Include Args, Returns, Raises, and a usage example. 

For TypeScript or JavaScript, JSDoc format works well:

 Add JSDoc to this function. Include @param types, @returns, and a one-line description of the function's purpose. 

Codex follows naming conventions and patterns already in your files. If your project uses a specific doc format, tag a file that already has examples and reference it in the prompt.

One Limitation Worth Knowing

Codex explains what the code says, not what it does at runtime. It cannot observe actual execution, live data, or production behavior.

A function with a subtle state dependency or a race condition may get an accurate structural explanation but miss the runtime behavior that causes the bug. For those cases, combine Codex’s explanation with your own test runs and terminal output.

How to Use Codex for Debugging and Test Generation in VS Code

Debugging and test generation are 2 of the highest-leverage use cases for Codex. Both benefit from its ability to run commands, read error output, and iterate without prompting you at each step.

Veracode’s 2025 analysis found that 45% of AI-generated code contained known security vulnerabilities per OWASP Top 10 (Veracode, 2025). That statistic makes human review after Codex’s debugging runs non-optional, not optional.

Debugging with the Codex Agent

Paste the error or stack trace into the Codex panel and open the relevant files. Then prompt directly:

 Find the bug causing this error. After proposing the fix, tell me how to verify it in the UI. 

Codex re-runs the reproduction steps after applying the fix. Ask it to run your lint and test suite to confirm nothing broke:

 After the fix, run lint and the smallest relevant test suite. Report the commands and results. 

One thing Codex handles better than most: it explicitly reports test failures rather than silently applying changes that don’t work. That makes it safer than fire-and-forget code generation.

Unit Test Generation

Select the function you want tested. Add it to the Codex context using the “Add to Codex Thread” command from the Command Palette. Then prompt:

 Write unit tests for this function. Follow conventions used in existing tests. Cover edge cases and error paths. 

Review generated tests before committing them. Codex misses edge cases involving complex state, external API behavior, and time-sensitive logic. Running generated tests against a mocked environment before merging is a solid practice.

The Security Review Gap

Codex does not audit for security by default. You have to ask.

A useful follow-up prompt after any code generation or debugging session:

 Review the changes you made for OWASP Top 10 issues, particularly injection risks and improper error handling. Report any concerns. 

The Cloud Security Alliance and Endor Labs found that 62% of AI-generated code contains design flaws or known vulnerabilities (CSA/Endor Labs, 2025). Treating security review as a separate explicit step rather than assuming Codex handles it by default reduces that exposure significantly.

How to Configure Codex Behavior in VS Code Settings

Codex shares a single configuration file between the VS Code extension and the CLI: ~/.codex/config.toml. Settings you configure there apply everywhere Codex runs.

Most developers stick with the defaults for the first few sessions. The 2 settings that change workflow most quickly are approval mode and default model.

Key config.toml Settings

Model and reasoning effort:

 [defaults] model = "gpt-5.3-codex" reasoningeffort = "medium" 

Medium reasoning is the right default for most tasks. Use high for complex refactors where an extra minute of reasoning prevents several correction loops. Use low or switch to GPT-5.4-mini for routine questions to extend your message budget 2.5-3x.

Approval mode:

 [defaults] approvalmode = "agent" 

The permission approval loop is the most widely reported friction point in the VS Code extension, per developer community reports (eesel AI, 2026). If Codex re-asks approval for near-identical commands, setting approval_mode = “auto” fixes this at the cost of less granular control.

AGENTS.md: Persistent Instructions for Your Project

AGENTS.md is a plain text file in your repository that Codex reads before starting any task. It works like a briefing document for the agent.

A useful structure:

AGENTS.md

Repository conventions

• Run npm run lint before opening a pull request.

• Document public utilities in docs/ when you change behavior.

• Prefer pnpm for installing dependencies.

Testing

• Always run npm test after modifying any file in /src.

• Use Jest mocks for external API calls.

You can add nested AGENTS.md files in subdirectories for team-specific rules. A services/payments/AGENTS.md can override the root-level file for that module without affecting the rest of the project (OpenAI Developers, 2025).

Data Privacy Settings

Go to Codex Settings in the sidebar, then follow the link to Data Controls on the ChatGPT website. That is where you opt out of model training on your code.

By default, OpenAI does not use Business or Enterprise user inputs to train models. Individual Plus and Pro users can opt out manually. For regulated industries or projects with sensitive IP, confirm the opt-out setting before running Codex against production repositories.

How to Use Codex with Multiple Files and Workspace Context

Codex’s strength over simpler AI tools is multi-file, multi-step reasoning. Understanding how it sees your project makes the difference between vague results and precise execution.

The Codex CLI has accumulated 88,000+ GitHub stars since its open-source release, partly because workspace-level task delegation was not available in any other tool at that scale (GitHub, 2025).

How Codex Reads Project Context

The VS Code extension automatically includes open files as context. Files you haven’t opened need explicit tagging.

@file references: Tag any file in a prompt with @filename.ts. Codex adds it to the active context for that turn.

Agent mode scanning: In Agent mode, Codex can browse your directory structure, read additional files, and trace imports without you naming each one. It reports which files it accessed in the task log.

AGENTS.md: Loaded automatically at session start. Provides project-wide guidance without consuming your per-turn message budget.

Delegating Multi-File Tasks via Codex Cloud

Click the cloud icon beneath the Codex prompt input. Select your cloud environment and click “Run in the cloud.” Codex clones your GitHub repository into an isolated sandbox, executes the task, and returns a diff.

You can close VS Code while it runs. The task continues. When it finishes, you review the diff from the IDE panel and apply or discard changes locally.

Practical tasks well-suited for cloud delegation in a multi-file project:

• Refactoring a shared utility used across 12 files
• Updating deprecated API calls project-wide after a library upgrade
• Generating documentation for every public function in a module
• Writing integration tests that span multiple services

One practical note: when Codex applies Agent mode changes locally, edits land in your working directory without a staged diff view. Commit or stash before running large multi-file tasks so you can run git reset if the output needs to be discarded (eesel AI, 2026).

What Are the Limitations of Using Codex in VS Code?

Codex is genuinely capable for well-scoped, testable tasks. The problems show up at the edges, and knowing where they are saves significant debugging time.

Veracode’s 2025 research tested more than 100 LLMs and found that AI-generated code contains 2.74x more vulnerabilities than human-written code, with a 45% failure rate on secure coding benchmarks (Veracode, 2025). That is the clearest argument for treating Codex output as a draft, not a deliverable.

Hallucinated APIs and Non-Existent Packages

Codex sometimes invents package names, method signatures, or internal functions that do not exist. Commercial models like GPT-4 hallucinate packages at roughly 5%; some open-source models exceed 20% (multiple 2025 studies via Kusari, 2026).

The risk is not just a broken import. Attackers monitor hallucinated package names and register them on npm or PyPI with malicious code. Run a code review and dependency audit on every new package Codex suggests before running npm install or pip install.

Context Window and Codebase Limits

Codex-1 supports a maximum context length of 192,000 tokens (OpenAI, 2025). Large codebases exceed this. Codex cannot read your entire repository in a single context window.

What this means in practice: tasks that require understanding 50+ files simultaneously may produce output that’s locally coherent but globally inconsistent. Codex may suggest changes in one module that conflict with patterns elsewhere in the codebase it didn’t read.

The fix is scoping: break large tasks into bounded subtasks with clear file boundaries. Give Codex the files it actually needs rather than relying on it to discover them.

No Runtime Awareness

Codex cannot execute your code and observe its output during the explanation or generation phase. It reasons from static analysis and training patterns, not from actual runtime behavior.

Bugs involving race conditions, session state, database side effects, or environment-specific behavior are often ones Codex will miss or explain incorrectly. For those categories, Codex is useful for generating the test scaffolding, but a human needs to run the tests and read the actual output.

Outdated Training Data for Fast-Moving Libraries

Libraries with breaking changes post-training cutoff are a consistent source of incorrect suggestions. React, Next.js, FastAPI, and other actively developed frameworks change APIs faster than training cycles refresh.

A reliable counter-measure: ask Codex to check the library’s changelog before generating code for a dependency you know has changed recently. With Agent (Full Access) mode and web search enabled, Codex can fetch live documentation mid-task. Without it, you’re relying on training data that may be a version behind.

FAQ on How To Use Codex In VS Code

Is Codex the same as GitHub Copilot in VS Code?

No. GitHub Copilot delivers real-time inline completions as you type. Codex is an asynchronous agent you delegate tasks to. It reads files, runs commands, and returns completed code. Most developers use both tools for different jobs in the same project.

Do I need a paid plan to use Codex in VS Code?

A free ChatGPT account gives limited trial access. ChatGPT Plus at $20/month unlocks full local task execution, cloud delegation, and GitHub code review. Pro, Business, and Enterprise plans offer higher rate limits and shared credit pools.

How do I install the Codex extension in VS Code?

Open the Extensions panel and search for “Codex,” or run ext install openai.chatgpt in the Command Palette. Select the extension published by OpenAI. Sign in with your ChatGPT account when the sidebar panel activates.

What is Agent mode in the Codex VS Code extension?

Agent mode is the default. Codex reads files, applies edits, and runs terminal commands inside your working directory automatically. It still needs your approval before accessing the network or working outside the project folder.

Can Codex replace GitHub Copilot’s ghost-text autocomplete?

No. The Codex extension does not provide ghost-text inline completions. That feature belongs to GitHub Copilot. Codex operates through its sidebar panel as a task-based agent, not a suggestion engine triggered while you type.

What is AGENTS.md and how does it affect Codex?

AGENTS.md is a plain text file in your repository that Codex reads before starting any task. It lets you define coding conventions, test commands, and project-specific rules so Codex follows your team’s standards without repeated prompting.

How does Codex Cloud delegation work from VS Code?

Click the cloud icon in the Codex panel, select your environment, and send the task. Codex clones your GitHub repository into an isolated sandbox and runs the task in the background. You review the completed diff without leaving VS Code.

Is Codex-generated code safe to use in production?

Treat it as a draft, not a deliverable. Veracode’s 2025 research found AI-generated code contains 2.74x more vulnerabilities than human-written code. Always run a security review and dependency audit before merging Codex output into production branches.

Does Codex work with VS Code forks like Cursor or Windsurf?

Yes. The official extension (ID: openai.chatgpt) works with Cursor, Windsurf, and other VS Code-compatible editors on macOS, Windows, and Linux. In Cursor, you may need to manually move the Codex icon to the right sidebar.

What is the context window limit for Codex in VS Code?

Codex-1 supports a maximum context length of 192,000 tokens per OpenAI’s documentation. Large codebases can exceed this. Scope tasks to bounded file sets and use @file references to give Codex exactly the context it needs.

Conclusion

This conclusion is for an article presenting how to use Codex in VS Code as a full coding agent, not the deprecated 2021 API model most documentation still describes.

The workflow shift is real. Inline code completion stays with GitHub Copilot. Codex handles the bigger jobs: multi-file refactoring, background cloud tasks, automated test generation, and codebase explanation at scale.

Configure your AGENTS.md, scope your tasks clearly, and always review output before merging. AI-generated code carries security risk by default.

Used well, Codex reduces the work that sits in your backlog. Review every diff, run your test suite, and treat it as a capable teammate, not an infallible one.

• Author
• Recent Posts

Bogdan Sandu

Bogdan Sandu is a front-end developer at TMS Outsource with 8+ years of experience in web technologies. He writes about developer tools, software platforms, and web workflows based on daily hands-on use.

Latest posts by Bogdan Sandu (see all)

• How to Use Codex in VS Code - August 12, 2026
• 10 Best Paid Search Agencies for Driving Business Growth for Software Companies - August 11, 2026
• How to Set Up Parental Controls on Google Play - August 10, 2026