JetBrains now ships OpenAI’s Codex agent directly inside its IDEs, starting with version 2025.3. That is not a plugin install or a marketplace extension. It is a first-class entry in the AI chat agent picker, sitting alongside Claude, Gemini, and whatever local model you pointed at Ollama last week. The announcement landed on January 22, 2026, with a free promotional credit pool to lower the switching friction for teams already paying for JetBrains AI.
What JetBrains actually shipped
The Codex integration adds a new agent option to the AI Assistant chat panel already built into IntelliJ, PyCharm, Rider, and the rest of the JetBrains fleet. Users on IDE version 2025.3 or later select Codex from the agent picker and start a session. The agent supports multiple autonomy levels, ranging from question-response mode up to autonomous execution with network access and command-line operations, and the user can switch between OpenAI models and adjust the reasoning budget mid-conversation without leaving the chat.
This is distinct from the earlier OpenAI chat model integration that shipped with AI Assistant 2024.3. That release added user-selectable models for the chat pane; Codex is an agent layer on top of those models, with its own autonomy controls and execution capabilities.
Three auth paths, three procurement stories
JetBrains built three ways to authenticate Codex inside the IDE, and the choice matters for how teams account for the cost:
- JetBrains AI subscription. Codex usage draws from the existing JetBrains AI credit pool. During the promotional period starting January 22, JetBrains is offering Codex agent usage for free under that credit pool. The “limited time” qualifier means this is credit-bounded, not open-ended.
- ChatGPT account. Users with an OpenAI/ChatGPT login can authenticate directly. This bypasses JetBrains AI credits entirely, and the free promotional offer does not apply to this path.
- BYOK (OpenAI API key). Teams that already hold OpenAI API contracts bring their own key. Same exclusion from the promotional credits.
The BYOK path is the one worth watching. A team that has negotiated an enterprise OpenAI API rate can route Codex traffic through that contract while using JetBrains AI credits for Claude or Gemini on other features. The IDE becomes a procurement aggregator, not a single-vendor billing surface.
One picker, seven providers
The JetBrains AI Assistant now lists support for Anthropic Claude, Google Gemini, Google Vertex AI, OpenAI, OpenAI-compatible endpoints (llama.cpp, LiteLLM), Ollama, and LM Studio. That is not a “we also support” footnote. The model picker in the chat panel presents these as first-class options, and has done so since the 2024.3 release established the multi-model pattern.
The practical effect: a developer working in IntelliJ can run a Codex agent for code generation, switch to a local Ollama model for a quick docstring rewrite where latency matters more than quality, and use Claude for a code review pass, all without installing a plugin or switching windows.
Per-feature model assignment
JetBrains goes further than a single model selector. The IDE exposes per-feature model assignment across three categories: core assistant, instant helpers, and code completion. Each category can point at a different provider. A fallback model list handles cases where the primary model is unavailable or rate-limited.
This architecture lets teams slot a local model into code completion (low latency, offline-friendly) while keeping a cloud model on the core assistant (higher quality, accepts network access). The fallback chain means a degraded provider does not break the feature; the IDE rolls to the next entry in the list.
What this changes for JetBrains-standardized teams
For organizations already committed to IntelliJ, PyCharm, or Rider across their engineering org, the calculus shifts in two directions.
First, model selection is now a setting inside the IDE, not a separate procurement decision. A team lead can configure the default model and fallback chain for the whole org through JetBrains AI settings, and individual developers can override per-task. This collapses what used to be three decisions (which IDE, which AI plugin, which model provider) into one surface.
Second, the free Codex promotional credits create a trial path that does not require a credit card or an OpenAI account. For teams evaluating whether autonomous code agents are worth the token spend, the friction to find out is now roughly zero if they already hold a JetBrains AI subscription.
What the sources do not say
The research brief covers JetBrains’ side of this thoroughly. What it does not contain is any data on GitHub Copilot’s market position, pricing response, or competitive reaction. As of early 2026, Copilot remains the incumbent AI coding tool by install base, but the specific claim that this integration “squeezes” Copilot requires evidence about Copilot adoption, churn, or pricing pressure that the available sources do not provide.
What can be said: JetBrains has positioned the IDE itself as a model-agnostic AI distribution surface. If the editor is where developers actually invoke AI assistance, the plugin marketplace matters less than it did. GitHub Copilot’s advantage was being first and being bundled with the GitHub workflow. JetBrains’ move makes the IDE subscription, not the plugin, the procurement gate. Whether that erodes Copilot’s position depends on how many teams actually switch, and on that question, no public data exists yet.
Frequently Asked Questions
Does the Codex agent work on IDE builds older than 2025.3?
No. Codex requires IDE version 2025.3 or later because it hooks into the agent picker and autonomy controls introduced in that release. Teams pinned to 2024.x for plugin compatibility keep the older OpenAI chat model integration that shipped with AI Assistant 2024.3, but not the agent layer with its network access and command execution modes.
How is the Codex agent different from the OpenAI chat integration that shipped in AI Assistant 2024.3?
The 2024.3 release exposed OpenAI models as a chat completion backend inside an existing JetBrains conversation. Codex is an agent layer sitting on top of those models, with discrete autonomy levels (question-response, tool use, autonomous network and shell access) and inline switching of both the underlying OpenAI model and its reasoning budget without restarting the session. Auth also widens: Codex accepts JetBrains AI credits, a ChatGPT login, or a BYOK OpenAI API key, while the 2024.3 picker routed through JetBrains AI credits alone.
What does per-feature model assignment actually let a team segregate?
JetBrains splits the AI Assistant into three assignable buckets: core assistant for chat and agent work, instant helpers for inline quick fixes like rename suggestions or docstring stubs, and code completion for keystroke-level suggestions. Pointing Ollama at code completion while keeping a cloud model on the core assistant isolates both latency and token spend, because completion traffic volume typically dwarfs the other two buckets by an order of magnitude on an active codebase.
What does the promotional free Codex offer actually exclude?
Only traffic authenticated through the JetBrains AI subscription path draws from the promotional credit pool. Sessions started with a ChatGPT login or a BYOK OpenAI API key bill at OpenAI’s published rates from the first token, and the credit is specific to the Codex agent. Claude, Gemini, Vertex AI, and local-model usage through the same chat panel continue to consume JetBrains AI credits at their normal rates.
What would force a rethink of the IDE-as-procurement-aggregator framing?
A GitHub Copilot move to bundle multi-vendor model selection inside its own subscription would push the aggregation layer back out of the IDE and into the GitHub workflow tier. The available sources show no sign of that move today, but Microsoft already has the OpenAI partnership and a distribution surface that reaches past any single editor, so the barrier is strategic rather than technical.