JetBrains Put an Agent Orchestrator Inside Every IDE It Ships

JetBrains opened early access for Air in its IDEs on October 1. It is available as a plugin on the JetBrains Marketplace or bundled in the 2026.3 EAP builds of IntelliJ, PyCharm, WebStorm, Rider and the rest of the family, and it works from version 2026.2 onward. The plugin is free.

The framing is the interesting part. Air is not a model and not an agent. It ships with no agents installed. JetBrains describes it as a conduit for agents and subscriptions a developer already pays for, and it detects what is already on the machine the way the IDE detects terminals.

Sessions instead of chat

JetBrains argues that orchestrating several tasks concurrently is a different activity from having a conversation with a model, and that using one interface for both has been a mistake. Classic IDE AI centred on chat. Air centres on sessions.

Each session is an agent working on a task, and the interface tracks them together: activity, unread updates, changed files, outgoing commits and the cost of each session in one view. Sessions can run across projects, appear as editor tabs, or stay in a terminal or graphical chat depending on the task. Double-tapping Ctrl anywhere in the IDE opens a prompt window with the current context attached.

Isolation is handled with temporary Git worktrees. A session can start from any branch, on a new branch or detached, and results are cherry-picked back into the main project. JetBrains says that agent output shows up as a reviewable diff inside the IDE, using the same tooling a developer would use to review a pull request, and that changes are not auto-applied.

The protocol play is the strategic part

Air connects agents that support the Agent Client Protocol, an open standard JetBrains co-built with Zed and released under the Apache licence. ACP uses JSON-RPC 2.0 over stdin and stdout, and JetBrains, Zed, Google, GitHub and more than 25 agents have adopted it. The two companies also launched an ACP Registry, a discoverable directory of compatible agents built into the IDE.

The easiest comparison is to the Language Server Protocol. LSP let any editor support any language through one shared standard instead of a bespoke integration per pairing. ACP aims to do the same for agents.

JetBrains is competing for the layer where agents are launched, supervised and reviewed rather than on model quality, and co-authoring the protocol that governs how agents talk to editors is a way to be infrastructure rather than a feature. The company's own explanation is blunter: an IDE that keeps agents at arm's length will struggle as agentic development becomes normal.

Supported agents include Codex, Claude Agent, GitHub Copilot, Gemini, OpenCode and JetBrains' own Junie, plus other ACP-compatible tools. A user with an existing Anthropic, OpenAI or Google key pays nothing to JetBrains. For those without an agent subscription, JetBrains offers free Junie Lite runs after signing in with a JetBrains account. JetBrains AI credits start at ten dollars a month for the company's own hosted model access.

The feature Cursor does not have

The differentiator JetBrains leans on is that Air-connected agents can invoke IDE tooling as skills. An agent can trigger a debug run to investigate a failing test, or run the profiler, or use the refactoring engine with full multi-file context. Agents can also reach IDE tools over MCP and work with structured context instead of pasted text.

JetBrains says this produces better results for some tasks and, in some cases, uses fewer tokens. The token claim is the company's, and no independent testing has been published.

The underlying argument is about what an agent can see. An agent that can only read and write files works from text. An agent that can profile a slow function and inspect the call stack has the context a senior developer would have when diagnosing the same problem. JetBrains has spent 26 years building that tooling, and Air is the first time agents get access to it.

Why the timing makes sense

JetBrains is launching this into a moment when the review step has become the acknowledged bottleneck. Writing code is no longer the constraint for many teams. Checking what was written is.

That judgment is showing up across the tooling market at once. Qodo shipped version 3.0 in the same week with review as its centrepiece, and Cursor added a review bot to its agent workflow. Three vendors converging on the same conclusion suggests the constraint has moved for good: when agents can produce code faster than humans can read it, the value shifts to whatever reduces the reading cost.

Air's design reflects that. The product treats parallel agent sessions as a queue of work to be reviewed rather than as a conversation to be steered, and it puts cost per session in the same view as changed files. For an engineering manager deciding how many agents to run, that cost line is the practical limit.

The per-session cost display is a small feature with an outsized effect on behaviour. A team that cannot see what a long-running agent is spending tends to run one agent cautiously. A team that can see the number per session is more willing to run several, because the decision becomes an allocation rather than a gamble. That is the same shift that happened with cloud spending dashboards, and it changes how people organise work.

There is also a coordination problem Air is trying to solve. A team running Claude on one task, Codex on another and Copilot on a third ends up with three separate interfaces and no shared record of what each one touched. Consolidating them in an IDE that already owns diffs, inspections and version control is a smaller change than adopting a new tool, and for teams standardised on JetBrains for Java, Kotlin or Python, it avoids pushing everyone onto a different editor just to get agents.

What is not settled

Air is an early access release. JetBrains says to expect rough edges, changes to the UI and behaviour, and updates roughly every week. It has not given a general availability date. Cloud execution for long-running tasks is limited to organisations with AI seats, and JetBrains has not stated pricing for it.

On privacy, the company says that with no agent signed in, nothing leaves the machine, and that with a third-party subscription, data goes to that provider under the existing agreement rather than through JetBrains. Disabling the plugin changes nothing else, and the separate AI Assistant remains supported.

The claim worth testing in a team's own repository is the one about review. Air makes it easier to run several agents at once. Whether that produces more merged work or more diffs nobody reads is an empirical question, and it will be answered in the first month of use rather than in a launch post.