AI Coding Agents in JetBrains IDEs

AI coding agents inside JetBrains IDEs don't just chat with you about your code. They run inside a system that already understands your project, which changes what "agentic" actually means in practice. This piece walks through why that distinction matters, how the market shift toward agents forced JetBrains to build for it, and what that looks like once you get past the demo and into daily use.

Why AI agents in JetBrains IDEs are a different category from chat-in-an-editor

When the agent starts working, does it already know your codebase, or does it have to figure that out from scratch, again, every single time?

It's an architecture question, and the answer depends entirely on what the agent is plugged into.

JetBrains IDEs, the whole family of them, IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, Rider, RubyMine, DataGrip, CLion, and RustRover, come with decades of accumulated project intelligence baked in. Inspections that catch bugs before you run the code. Refactoring tools that understand what a rename actually touches. Test runners wired into the project. Debuggers that step through real execution, not guesses about it. Framework indexes, Gradle and Maven integration, run configurations, database tooling, and navigation that understands what a symbol actually means in context. It's the thing that makes the IDE smarter than a text editor with a nice theme.

An agent plugged into that system can drive the debugger directly. It can invoke the real test runner and read real results. It can perform an actual refactor instead of a find-and-replace that happens to look like one. Compare that to an agent working from raw file text and terminal output: it's reading tea leaves while the IDE agent is reading the actual chart.

JetBrains has been direct about the design philosophy behind this. Two legitimate ways of writing code exist side by side now: the classic way, typing, refactoring, and debugging by hand, line by line, and the new way, collaborating with AI or handing off whole tasks to an agent. JetBrains isn't picking a winner between them. The stated goal is that both can run in the same IDE without one getting in the other's way, so a developer who wants to write every line themselves still gets a clean, fast editor, and a developer who wants to delegate a feature to an agent gets real power doing it.

How agent adoption has shifted the baseline expectation for what an IDE must support

Agent adoption stopped being a frontier experiment and became the default way professional developers work. It's the current baseline, and it's moving fast enough that standing still is its own kind of risk.

OpenAI Codex grew its adoption roughly five times over between January 2026 and the May-to-July 2026 window. That's a tool going from a niche pick to a mainstream one inside a single calendar stretch. Meanwhile, GitHub Copilot, the tool that put AI-assisted coding on the map back in 2023, saw its adoption decline over the past year, even while it kept very high name recognition among developers.

The agent landscape is not settling into a stable top three the way, say, an earlier infrastructure category once settled on a single dominant tool, and it keeps churning hard, with the tool a team standardizes on this year unlikely to be the tool it wants next year, which is just what a young, fast-moving category looks like from the inside.

For a developer or a team working inside a JetBrains IDE, that churn has one clear practical implication. An IDE that locks a team into one agent is betting that the market has already picked a permanent winner. The market hasn't shown any sign of doing that. Flexibility, in which agents an IDE supports and which models those agents can run on, is the baseline requirement now, the same way syntax highlighting or a working debugger is a baseline requirement. An IDE that can't adapt to wherever the agent market goes next is an IDE that's betting against its own users.

What the Agent Client Protocol does

The Agent Client Protocol, ACP, solves a specific plumbing problem: how does an IDE talk to an agent's full harness, meaning its planning logic, its tools, its model routing, its observability, without JetBrains having to hand-build a custom integration for every single agent that shows up in the market?

Before a standard like this exists, every new agent means another bespoke engineering project. With ACP, the IDE speaks one protocol, and any agent that also speaks that protocol can plug in. Agents can come from a curated registry inside the IDE or get configured manually, and once installed, they show up right inside the AI chat alongside everything else.

ACP didn't start as a JetBrains project. Zed built it first, and JetBrains later came on as a co-developer, positioning it as an open interoperability layer for the whole industry. An open protocol invites other IDEs and other agent builders in.

The practical payoff is immediate. Claude Agent, Codex, GitHub Copilot, and OpenCode are all integrated directly into the AI chat inside JetBrains IDEs, and dozens of additional agents can be added through ACP on top of that. That's the difference between an IDE that supports two agents because someone built two custom integrations, and an IDE that supports dozens because it built one protocol.

None of this landed without pushback. Developers raised fair questions when ACP launched: why a new protocol at all when LSP, MCP, and AG-UI already exist in adjacent spaces? There's also an awkward naming collision with IBM's own Agent Communication Protocol, which shares the acronym and causes its share of confused searches. On top of the naming noise, developer discussions have documented real rough edges, things like unsaved files not syncing cleanly or diffs rendering oddly in early integrations. ACP is genuinely useful and still young. Teams adopting it now should expect some sharp corners while the ecosystem catches up to the ambition.

Where Junie's integration goes deeper than the protocol layer

Junie is JetBrains' own coding agent, built for professional software development and available inside JetBrains IDEs, with support across all Air surfaces. It plans multi-step tasks rather than one-shot responses, works across multiple files at once, can drive the debugger directly, and lets the developer review and approve the key actions along the way rather than just accepting a wall of changes at the end.

The Rider 2026.2 release is the clearest real-world example of what "deep integration" actually buys a developer, beyond what a protocol connection alone can offer. Rider 2026.2 opens up the IDE's own intelligence to AI coding agents directly, so an agent working inside Rider is drawing on real project knowledge the IDE already has, rather than rebuilding an understanding of the codebase from file contents and terminal scrollback every time it starts a task. That release also adds a new set of agent skills covering testing, profiling, refactoring, and official Microsoft.NET workflows, which means the agent isn't guessing at.NET conventions, it's working with the same official toolchain a.NET developer already trusts. GitHub Copilot joins the lineup in Rider 2026.2 as a natively integrated agent, a first-class option alongside the others.

Separate from the agent layer, but part of the same integrated AI stack, JetBrains also builds Mellum, an open-source large language model built and optimized specifically for code completion. Mellum is doing the much narrower, much faster job of predicting the next few tokens of code well, and it's part of how JetBrains keeps the completion experience fast even as the agent layer above it gets more ambitious.

Model flexibility in practice: subscriptions, BYOK, and activation pathways

JetBrains has stated its AI strategy: avoid locking developers into one vendor, and keep workflows compatible across providers. The way that strategy actually shows up on a developer's screen is through several distinct activation pathways: a JetBrains AI-managed subscription, bring-your-own-API-key (BYOK), OAuth sign-in where a provider supports it, and ACP agents brought in independently.

On the subscription side, JetBrains AI connects to a wide spread of providers: models from several major foundation-model vendors, cloud-hosted model access, and other independent model makers, alongside JetBrains' own proprietary and hosted models. Recent additions show where this is heading: Junie has adopted Gemini 3.7 Flash as its default model, added OpenAI GPT-5.2 and xAI Grok 4.1 Fast (Reasoning) as options, and introduced BYOK support for OpenAI and Anthropic directly inside the AI Chat interface. That's a genuinely multi-vendor setup, not a single-provider product with a few extra buttons.

Pricing runs in tiers, and figures should always get confirmed directly with JetBrains before anyone budgets around them, since tiers shift. AI Ultimate sits above it, with a larger credit allocation on the same 30-day cycle. AI Pro also comes bundled inside the All Products Pack and dotUltimate, so some teams may already have it without realizing it.

The credit system is where teams need to pay close attention, because it behaves differently from the per-token billing many developers are used to. When the included credits for a billing period run out, cloud AI features pause until the quota renews or credits get topped up. The renewal clock runs from the date the license was first activated, which doesn't necessarily line up with the calendar billing period, and unused credits don't roll over into the next cycle. That combination (activation-date renewal plus no rollover) has been flagged as a real source of confusion, and it's a legitimate budgeting concern for any team trying to predict AI spend month to month. It is a detail worth building into any rollout plan from the start.

What visibility and governance look like as agent work scales beyond a single developer

Once an agent is doing real execution, writing code, running tests, touching multiple files, the hard part of the job shifts from writing the code to understanding, verifying, and taking ownership of what got written. Code that's almost right but carries one bad assumption buried in it is far harder to catch than code that's obviously broken. That's the exact problem an IDE's built-in intelligence is positioned to help with: it's the same inspections, test runners, and debuggers a human developer relies on, now doing double duty as a check on what the agent produced.

That problem doesn't stay contained to one developer's machine for long. Once agents are running across a team, the question of oversight becomes organizational, not personal.

JetBrains announced Air in September 2026 as the structure meant to span that whole range, from individual developer up through the organization. In JetBrains IDEs, Air names the agentic development experience itself, the part where a developer directs an agent and verifies its output using JetBrains' code intelligence. Air Teams sits a layer up, coordinating and automating software-delivery workflows that mix human developers and autonomous agents. Air Governance, previously known as JetBrains Central, handles organizational policy: visibility, auditability, cost management, and accountability across AI-assisted and agent-driven work. Air was announced in preview form, so it is a direction JetBrains is building toward rather than a finished, fully mature product today.

For organizations with stricter requirements, the AI Enterprise tier adds controls built for exactly that: on-premises LLMs, organization-wide provider keys, SSO and SCIM for identity management, AI audit logs, and on-premises or hybrid deployment options.

JetBrains Air is designed specifically to make those four questions answerable, rather than leaving them as something each team figures out informally after something goes wrong.

Where external agents fit: Claude Code, Codex, and GitHub Copilot inside JetBrains IDEs

Because ACP makes supporting multiple agents a structural feature rather than a special case, nobody using a JetBrains IDE has to give up their preferred agent to keep their preferred editor. The real question becomes which agent fits which job, not which agent the IDE happens to allow.

Claude Code is well suited to large, multifile refactors and complex bug investigations, the kind of work that needs an agent to hold context and reason across an entire session. Inside JetBrains IDEs, this agent shows up as "Claude Agent" through ACP, a distinct, natively bundled integration, separate from connecting Claude Code itself through a third-party ACP adapter.

OpenAI Codex is built more for day-to-day, multistep coding work, whether that's running interactively in a terminal or handed off to run in the cloud, and it also handles non-interactive runs inside CI pipelines and scripts well. The model stays OpenAI's in every case, but where it executes is flexible: OpenAI's own cloud, Amazon Bedrock, or a local runtime are all on the table, and it ships as an open-source CLI and SDK, so teams aren't locked into one client shape either.

GitHub Copilot, now natively integrated as of Rider 2026.2, brings the tool with the highest name recognition in the industry directly into the IDE, giving teams already standardized on it a path that doesn't require a separate protocol bridge.

Across all of these, the shape of the decision stays the same: pick the agent that matches the task and the provider policy in front of you, not the agent that happens to be the only one an IDE will let through the door.