Seamless Integration
Bring Codex into the editor you already use. Whether you live in VS Code, JetBrains, Neovim, or Eclipse, our plugins deliver code generation, review, and intelligent chat without breaking your flow.
Describe what you need in a comment and Codex writes the implementation inline. Press Tab to accept or Esc to dismiss — no panel, no dialog, no interruption.
As you type, Codex scans for bugs, security issues, and style violations. Annotations appear in the gutter — click to see the explanation and suggested fix.
Your Codex session spans editors. Switch from VS Code to Neovim mid-task — the plugin picks up your context, active project, and conversation history.
Set your preferences once — indentation, language defaults, review strictness — and every plugin reads the same config. No per-editor settings drift.
The IDE plugin puts Codex where you already think — inside your editor, not in a separate window.
Every developer has an editor they trust. Some have used the same keybindings for a decade. Codex respects that. The IDE plugins are designed to feel native — they use each editor's extension API correctly, respect theme colors, and follow platform interaction conventions. In VS Code, the sidebar panel looks like any other VS Code view. In JetBrains, the tool window docks like every other JetBrains tool window. In Neovim, Codex communicates through floating windows and the quickfix list. The result is that Codex becomes part of your muscle memory within the first hour of use. You do not learn a new interface — you gain new capabilities inside the interface you already command.
The plugin architecture also means Codex can access editor-level context that a standalone tool cannot. It knows which file you are looking at, where your cursor is, what you just typed, and what is visible in adjacent tabs. It reads your project's language server diagnostics to avoid suggesting code that would introduce new warnings. It watches your Git status to understand which files changed since the last commit. All of this context feeds into the AI model, producing suggestions that are not just syntactically correct but situationally appropriate. A developer editing a React component gets React-idiomatic suggestions. Switch to a Dockerfile and Codex adjusts immediately.
Not every feature works identically across editors — platform APIs impose different constraints. Here is exactly what each plugin delivers.
| Feature | VS Code | JetBrains | Neovim | Eclipse |
|---|---|---|---|---|
| Inline code completion | Full | Full | Full | Full |
| Multi-line generation | Full | Full | Full | Full |
| Sidebar chat panel | Full | Full | Floating window | Full |
| Real-time code review | Full | Full | Diagnostic only | Full |
| Gutter annotations | Full | Full | Sign column | Partial |
| Project-wide refactor | Full | Full | CLI bridge | Full |
| Test generation | Full | Full | Full | Partial |
| Git diff integration | Full | Full | Fugitive bridge | Full |
| Debugger integration | Full | Full | N/A | Full |
| Remote development (SSH) | Full | Full | Full | N/A |
| Custom keybindings | Full | Full | Full | Full |
| Offline queue | Full | Full | Full | Full |
The feature matrix reveals that VS Code and JetBrains receive the deepest integration because their extension APIs expose the richest surface area. Neovim trades visual polish for terminal-native speed — floating windows and sign-column annotations replace sidebar panels, and the Fugitive bridge replaces native Git integration. Eclipse support covers core workflows fully, with partial support for gutter annotations and test generation where the Eclipse Platform API imposes tighter limits. The Codex team prioritizes feature parity across editors; gaps in the matrix typically close within one or two release cycles after the underlying editor API matures.
VS Code gets the flagship plugin. Install it from the marketplace, authenticate once, and Codex appears in your sidebar, status bar, and inline suggestions.
Open the Extensions view with Ctrl+Shift+X, search for "Codex," and click Install. The extension activates automatically on the next editor restart. You will see a Codex icon in the activity bar — click it to open the sidebar panel. The panel has three tabs: Chat, where you can ask questions and request code generation in natural language; Review, which shows diagnostic annotations for the current file; and History, which logs recent generations and review results. The status bar indicator shows whether Codex is connected, indexing, or idle. Click it to toggle features or open settings. The extension pulls your API key from the VS Code secret storage — if you already authenticated the CLI on the same machine, the extension reads the same credential and does not ask again. Configuration lives in .vscode/settings.json under the codex key; team-shared settings can be committed to the repository so every developer gets the same Codex behavior.
One plugin serves the entire JetBrains family. Install it once and Codex works across IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, and CLion.
Open Settings > Plugins, switch to the Marketplace tab, search for "Codex," and install. The plugin adds a Codex tool window (dock it wherever you prefer) and a right-click context menu for file and selection actions. JetBrains users get one capability that other editors lack: deep integration with the IDE's own code analysis engine. When Codex suggests a refactor, it checks the suggestion against IntelliJ's inspections before presenting it — the result is that Codex never suggests something IntelliJ would immediately flag as a warning. The plugin also integrates with JetBrains' built-in database tools: if you have a data source configured, Codex can generate queries, migrations, and ORM model code that references your actual schema. For team use, the plugin settings can be exported as part of the .idea/ directory and shared through version control, though secrets like API keys remain in the IDE's password store and are never committed.
The Neovim plugin is minimalist by design — it adds floating windows for chat, sign-column markers for review, and Lua-configurable keymaps for every action.
Install via your plugin manager. For lazy.nvim, add { 'codex/codex.nvim', config = true } to your plugin spec. For packer.nvim, use use 'codex/codex.nvim'. The plugin requires Neovim 0.9 or later with LuaJIT. After installation, set your API key with :lua require('codex').setup({ api_key = 'YOUR_KEY' }) or store it in the CODEX_TOKEN environment variable. The default keymaps use <leader>c as a prefix: <leader>cg generates code for the current selection, <leader>cr reviews the current buffer, <leader>cc opens the chat window, and <leader>cf fixes the diagnostic under the cursor. Every keymap is configurable through the setup function. The plugin respects your colorscheme — floating windows use the NormalFloat highlight group, and sign-column markers use DiagnosticSignWarn and DiagnosticSignError. For users of telescope.nvim, Codex registers as a picker source so you can browse generation history with the same fuzzy-finder interface you use for files and buffers.
Eclipse users install the Codex plugin from the Eclipse Marketplace and get inline completions, a chat view, and project-wide analysis.
Navigate to Help > Eclipse Marketplace, search for "Codex," and click Install. Restart Eclipse when prompted. The plugin adds a Codex perspective accessible from Window > Perspective > Open Perspective. The perspective contains the Chat view, the Review report, and the Generation history. Right-click any file or selection in the Project Explorer or editor and choose "Codex — Generate" or "Codex — Review" from the context menu. The plugin hooks into Eclipse's incremental project builder, so Codex can run a full-project review whenever you perform a clean build — useful for catching issues across an entire codebase before CI runs. Eclipse support is particularly popular in enterprise Java shops where the IDE is mandated by organizational policy; the plugin brings modern AI assistance into those environments without requiring editor migration. Configuration is stored in the workspace .metadata directory and can be exported via File > Export > Preferences for sharing across team workspaces.
Codex plugin configuration is designed to be version-controlled. Your team can commit a shared config that every developer picks up automatically.
Each plugin reads configuration from a hierarchy: user-level settings (local, never committed), project-level settings (committed to the repo), and defaults (built into the plugin). Project-level settings override defaults; user-level settings override project-level settings. This means a team lead can define the preferred language, code review strictness, and generation style in a .codex/config.toml file at the repository root, commit it, and every developer who opens the project inherits those settings. Individual developers can override specific values — for example, a developer who prefers a different indentation width — without affecting the team. The plugin shows a small indicator when a setting differs between project and user levels, so developers are aware of the divergence. For organizations that enforce policy through infrastructure, the plugin also respects environment variables prefixed with CODEX_, which take precedence over all file-based configuration. This allows CI pipelines and managed workstations to enforce minimum review thresholds or disable certain features globally.
Raúl C. Dominguez, DevOps Lead at Altitude Data in Phoenix, shared his perspective on the multi-editor workflow: "My team spans VS Code users on Mac, JetBrains users on Linux, and one die-hard Neovim user who built his own config from scratch. Codex gave all three groups a consistent experience without asking anyone to switch editors. I wrote a single .codex/config.toml, committed it to the monorepo, and every developer got the same code review rules and the same generation style. That kind of uniformity across heterogeneous toolchains is rare, and it saved us roughly eight hours a week in code review churn."
Plugin conflicts are the most common support issue. The fix is usually straightforward — disable competing inline completion providers and restart.
If the Codex plugin does not appear after installation, check that your editor version meets the minimum requirement: VS Code 1.82+, JetBrains 2024.1+, Neovim 0.9+, Eclipse 2024-06+. If inline completions do not appear, verify that the plugin is authenticated (the status bar or tool window will show a red indicator if not) and that no other completion provider is overriding the suggestion list. Known conflicts include other AI coding assistants and aggressive language-server auto-completion. The Codex plugin detects common conflicts and shows a notification with a "Resolve" button that opens the relevant settings page. For JetBrains users, if the tool window does not appear, check View > Tool Windows > Codex — it may have been closed and not reopened automatically. For Neovim, run :checkhealth codex to see a diagnostic report that identifies missing dependencies, incorrect API keys, or Lua configuration errors. The NIST cybersecurity projects page offers reference guidance on managing third-party IDE plugin security that may inform your organization's plugin policy.
Codex provides plugins for VS Code, the entire JetBrains family (IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, CLion), Neovim 0.9+, and Eclipse 2024-06+.
VS Code and JetBrains receive the deepest integration because their extension APIs support inline completions, sidebar panels, gutter annotations, and debugger hooks. Neovim follows a terminal-native philosophy with floating windows, sign-column markers, and Lua-configurable keymaps. Eclipse covers the core workflows — inline completions, chat, and project review — with partial support for advanced features constrained by the Eclipse Platform API. The team regularly evaluates new editors for plugin development based on user demand; editor request threads on the Codex community forum are the best way to signal interest in a platform not yet supported. All plugins share the same backend, so feature improvements to the core engine benefit every editor simultaneously.
The plugins need an active connection for code generation and review, but they cache your project index locally and queue requests when offline for automatic execution on reconnect.
The offline queue holds up to fifty pending requests per project. When connectivity returns — whether it is a train emerging from a tunnel or a VPN reconnecting — the plugin drains the queue in order. You see a notification with the count of completed requests and can review results in the History tab. The local index cache means the plugin still provides basic functionality without a connection: file-aware context menus, configuration editing, and cached documentation lookups all work offline. If your workflow frequently involves disconnected periods, consider installing the Codex CLI alongside the plugin — the CLI's offline queue is not subject to editor process lifetime, so it persists across editor restarts and system reboots.
The plugin and CLI share the same .codex/ directory, index database, and configuration file. Switch freely — state synchronizes automatically.
Codex stores all project-level state in a hidden .codex/ directory at the repository root. This directory contains the semantic index, the configuration file, the generation history, and the review cache. Both the IDE plugins and the CLI read from and write to this same directory. Running codex generate in the terminal updates the index; the IDE plugin picks up the change within seconds. Reviewing a file in the IDE adds annotations to the cache; running codex review --report in the terminal surfaces those same annotations. There is no import, export, or synchronization step. This design means you can use the tool that fits the task — terminal for quick one-off generations, IDE for deep refactoring sessions — without losing context.
Every plugin exposes granular settings to toggle inline completions, sidebar chat, code review annotations, and status bar indicators independently, plus custom keybindings for every command.
Open the plugin settings in your editor. In VS Code, they are under Settings > Extensions > Codex. In JetBrains, Preferences > Tools > Codex. In Neovim, the setup function accepts a configuration table. Each feature has an on/off toggle and, where applicable, a severity or verbosity slider. You can disable inline completions while keeping the chat panel active, or turn off real-time review but keep the manual review command available. Keybindings are fully customizable — every Codex action is exposed as a command that you can bind to any key combination. The plugin also provides a "Zen Mode" toggle (default keybinding: Ctrl+Alt+Z) that temporarily suppresses all Codex UI elements except explicit command invocations, useful during focused debugging or code reading sessions.
Codex plugins coexist with most extensions, but we recommend disabling competing inline completion providers to prevent suggestion conflicts and editor performance degradation.
The plugin performs a compatibility scan on startup. It checks for known AI coding assistants that register as completion providers and, if any are found, displays a notification listing them. You can choose to disable the conflicting features in Codex, disable them in the other extension, or ignore the warning and run both. Running multiple inline completion providers is not recommended — the editor extension host must reconcile multiple suggestion sources, which can cause flickering, dropped suggestions, and increased latency. Codex's real-time review annotations, sidebar chat, and context menu commands do not conflict with other extensions and can safely run alongside any tool. If you report a compatibility issue with a specific extension, the Codex engineering team investigates and typically ships a fix or a configuration workaround within one release cycle.
After configuring your IDE plugins, the next logical enhancement is setting up the CLI for terminal-native workflows that complement your editor experience. Developers building custom automation should review the API reference to integrate Codex into proprietary tools and dashboards. Teams with CI/CD pipelines can add automated code review by configuring CI/CD integration for GitHub Actions, GitLab CI, Jenkins, and CircleCI. For containerized development environments, Docker container setup ensures every team member works in an identical, reproducible environment. The webhook system enables event-driven automations that react to Codex events in real time. For deeper platform understanding, read the full documentation, browse AI code generation capabilities, or explore automated code review configuration. Organizations can compare plans, review security certifications, or visit the resource hub for tutorials and case studies. For direct assistance, contact the support team.