JetBrains opened an Early Access Program on October 2, 2026, that drops its multi-agent orchestrator, JetBrains Air, directly inside IntelliJ IDEA, PyCharm, WebStorm, CLion, and RustRover. The move takes a product that launched in March 2026 as a standalone app and wires it straight into the IDEs millions of developers already use every day, turning the editor itself into a dashboard for juggling Codex, GitHub Copilot, Junie, Cursor, Gemini, and Claude Agent sessions side by side.
The timing is not an accident. Zed shipped preview build 1.25.0 on October 14 with Gemini 4 Argon support. Anthropic pushed Claude Code to version 2.1.302 on October 17. Microsoft keeps iterating on Copilot inside VS Code. Every major editor vendor is racing to answer the same question: who controls the interface where developers supervise AI agents, rather than who builds the underlying model. JetBrains Air is the clearest bet yet that the answer is the IDE itself, not a separate chat window or a standalone app.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What JetBrains Air Actually Does Inside the IDE
JetBrains is explicit that Air is not another AI model and not a new agent competing with Junie, Codex, or Copilot. According to the official JetBrains announcement, Air ships without any agents installed at all. It is described instead as a conduit and orchestration layer: a workspace that sits inside the IDE and lets developers run, track, and review coding agents they already have access to through existing subscriptions or API keys.
In practice that means a developer can keep several agent sessions running across several projects at once, with a single pane showing unread updates, changed files, and outgoing commits for every session. Because the agents operate inside the IDE’s normal environment rather than a sandboxed chat panel, developers can lean on code insight, refactoring tools, debugging, version control, diffs, and line-level feedback on whatever an agent just generated. JetBrains says Air also uses the IDE’s own code intelligence, the same engine that resolves types, usages, and dependencies for human-written code, to help agents make fewer incorrect decisions and burn through fewer tokens doing it.
That framing matters for the jetbrains air search traffic already building around the release: most of what people want to know is not “what is this new AI,” but “can I plug my existing Cursor or Copilot subscription into my JetBrains editor.” The answer, per JetBrains, is yes.
Which IDEs and Agents Are Supported Right Now
The Air EAP is available two ways: as a plugin pulled from the JetBrains Marketplace, or bundled natively inside the 2026.3 EAP builds of JetBrains IDEs. Coverage from byteiota confirms the rollout spans IntelliJ IDEA, PyCharm, WebStorm, CLion, and RustRover, describing the install as free and taking about five minutes. A separate writeup from JetBrains’ own documentation extends functional support back to IDE version 2026.2, meaning developers do not strictly need to be on the bleeding-edge 2026.3 EAP track to try it.
On the agent side, JetBrains lists Codex, Gemini, GitHub Copilot, Claude Agent, and Junie as standard integrations, while also supporting any other agent that speaks the Agent Client Protocol, or ACP. Cursor is specifically named as one of the agents Air can detect and run if it is already installed on a developer’s machine. That is a notable detail: JetBrains is not trying to wall off a rival’s agent, it is trying to become the place where that rival’s agent gets supervised.
For developers who do not want to manage any outside subscription at all, JetBrains offers Junie Lite for free, described as suited to everyday tasks and requiring only a JetBrains account to switch on. It is the on-ramp JetBrains clearly expects most EAP testers to try first before connecting a paid agent.
From Standalone App to IDE-Native: Air’s Eight-Month Arc
Air did not appear out of nowhere this month. JetBrains shut down its lightweight Fleet editor at the close of 2025, and in March 2026 it introduced Air as a standalone desktop workspace where multiple agents could run side by side in isolated environments, paired with Junie CLI, a terminal-native agent meant to work with any editor or pipeline. That standalone app reportedly launched on macOS first, with Windows and Linux announced as follow-ons, and it supports running multiple tasks in parallel with isolation handled locally, through a Git worktree, or inside a Docker container.
What changed on October 2 is that Air stopped being a separate destination developers had to open on top of their IDE and became a feature of the IDE itself. That is a meaningfully different pitch. A standalone multi-agent cockpit asks a developer to change their workflow. An orchestrator embedded in PyCharm or WebStorm asks for almost nothing, since the editor was already open. JetBrains is effectively betting that distribution inside tools developers never close beats a separate app, however good that app’s isolation model is.
JetBrains Air EAP at a Glance
| Detail | Status as of October 18, 2026 |
|---|---|
| IDE EAP announcement date | October 2, 2026 |
| Standalone Air app original unveiling | March 2026 |
| Supported IDEs | IntelliJ IDEA, PyCharm, WebStorm, CLion, RustRover |
| Minimum IDE version for plugin | 2026.2 and later |
| Native bundling | 2026.3 EAP builds |
| Standard agent integrations | Codex, Gemini, GitHub Copilot, Claude Agent, Junie |
| Also supported via protocol | Cursor and other ACP-compatible agents |
| Free entry-level agent | Junie Lite (requires JetBrains account) |
| Cost to join EAP | Free |
| Final stable release date | Not yet announced |
Orchestration, Not a New Model: Why That Distinction Matters
It is worth sitting with how unusual JetBrains’ positioning is. Every other major push in AI-assisted coding over the past two years has been about shipping a better model or a tighter integration with one model family. Air explicitly refuses to play that game. JetBrains already has its own coding-focused model, Mellum, and its own semi-autonomous agent, Junie, both of which it continues to develop separately, as covered in JetBrains Mellum 2.1’s recent SWE-Bench gains. Air sits a layer above all of that, as a surface for coordinating whatever agent a developer or an engineering org has already standardized on.
An analysis from ChatPicture frames the ACP support as the real strategic move, arguing that betting on an open protocol rather than a proprietary agent is what lets JetBrains stay neutral while still owning the surface developers see every day. That is a bet on being the neutral ground in a market that otherwise keeps fragmenting by agent and by model provider. It also sidesteps a structural problem every single-agent coding tool runs into: a team that pays for Cursor, experiments with Claude Code, and also has GitHub Copilot seats from an enterprise agreement currently has three separate review surfaces for AI-written code. JetBrains is proposing to collapse that into one, inside an IDE family many of those same developers never left in the first place.
Junie Lite, BYOK, and the Subscription Fine Print
JetBrains’ messaging leans hard on bring-your-own-key flexibility: a JetBrains AI subscription is not universally required to use Air, since developers can connect existing third-party agent subscriptions or their own API keys. That said, JetBrains’ own Air site notes that a JetBrains AI subscription is required specifically for cloud-run sessions, a distinction worth watching as EAP testers push the product past local, single-machine use.
The JetBrains Toolbox storefront already lists a bundle that pairs Air with ten IDEs, three extensions, two profilers, and 20 JetBrains AI Credits per 30-day period, though JetBrains has not published a price for that specific bundle in the material reviewed for this story. That is one of the open questions hanging over the EAP: JetBrains has been clear about what Air does and which agents it can host, far less clear about what the finished, non-EAP version will cost once Early Access ends.
JetBrains Air vs Cursor vs GitHub Copilot vs Windsurf
Positioned against the rest of the field, Air is less a rival to Cursor, GitHub Copilot, and Windsurf than a layer that can sit on top of pieces of all three, provided the underlying agent speaks ACP or has a JetBrains-built connector. Cursor remains built as a VS Code fork with its own Composer-driven agent workflow. Windsurf ships as its own standalone IDE. GitHub Copilot continues operating primarily as a plugin layered onto an existing editor, with the deepest reach inside VS Code and the GitHub ecosystem generally, a dynamic Cursor’s own PR-merge numbers have made increasingly visible over the past year.
Pricing across that field varies by a meaningful margin. Published consumer tiers put Cursor Pro and Windsurf Pro at roughly $20 a month each, while GitHub Copilot Pro sits closer to $10 a month, reflecting Copilot’s position as an add-on to a platform developers are often already paying for rather than a destination editor in its own right. JetBrains has not published a standalone consumer price for Air itself; what is confirmed is that EAP access is free, and that production use may eventually draw down JetBrains AI Credits for cloud runs, Toolbox-bundle credits, or a developer’s own third-party subscription.
AI Coding Tool Landscape: Pricing and Model
| Tool | Published consumer price | Primary model |
|---|---|---|
| JetBrains Air (EAP) | Free during Early Access | Orchestrator; brings your own agent/subscription |
| Cursor Pro | ~$20/month | VS Code fork with built-in Composer agent |
| Windsurf Pro | ~$20/month | Standalone AI-native IDE |
| GitHub Copilot Pro | ~$10/month | Plugin layered on existing editors, GitHub-centered |
| JetBrains Junie Lite | Free | Lightweight JetBrains-built agent, in-IDE only |
The spread shown in that table is why Air’s orchestration pitch lands differently depending on who is evaluating it. A developer already paying $20 a month for Cursor has little reason to add another subscription; what Air offers that person is a way to keep paying for Cursor while reviewing its output with JetBrains’ refactoring and debugging tools layered on top, rather than inside Cursor’s own interface. For a shop standardized on GitHub Copilot’s cheaper plugin model, Air’s pitch is closer to a free upgrade to the review experience around an agent they already have.
What Engineering Leaders Are Saying
JetBrains has kept its own public framing of Air tightly focused on the agentic-workbench angle. Kirill Skrygan, a JetBrains executive, described the shift in direct terms: “We’ve reimagined JetBrains IDEs to become the ultimate agentic workbench. Air is an open hub for agents inside your IDE” (source).
JetBrains’ own account pushed a similar message when the EAP went live, pitching the multi-agent angle directly at developers already juggling more than one tool: “Running multiple agents in parallel? Want the freedom to choose your agent? Try JetBrains Air in your IDE – now in Early Access” (source). Both statements point at the same underlying claim: that the hard problem left in AI-assisted coding is not generating code, it is managing several agents generating code at once without losing track of what each one changed.
Market Impact: Why This Pressures Cursor, Copilot, and Windsurf
The practical pressure Air puts on rivals is distribution, not features. JetBrains IDEs already sit on a large, paying developer base across Java, Python, JavaScript, C++, and Rust shops, and Air reaches that base the moment someone updates to a 2026.3 EAP build or installs a Marketplace plugin, without requiring anyone to switch editors first. That is a structurally different go-to-market than Windsurf’s or Cursor’s, both of which still need developers to adopt a new primary editor to get the full experience.
It also changes the calculus for how AI-written code gets reviewed, an area the industry has been visibly anxious about. Recent coverage on this trend, including reporting on the trust gap between editors in hunk-by-hunk review tooling across Zed, Cursor, VS Code, and Claude Code, shows every major vendor converging on granular, line-level review as the feature developers actually ask for, rather than faster code generation. Air’s claim to reuse the IDE’s own code intelligence to catch wrong types and broken dependencies before a developer even reviews a diff fits squarely into that same shift.
For enterprise buyers, Air’s bring-your-own-agent model also softens a procurement headache. A company that has already negotiated GitHub Copilot Business seats, piloted Claude Code per the recent plugin ecosystem now official in Claude Code 2.1.302, and let individual engineers expense Cursor does not need to standardize on one agent to get a single, consistent review workflow across its JetBrains-based teams. That is a genuine point of differentiation rather than marketing language, assuming the ACP integration holds up as more agents adopt the protocol.
Historical Context: JetBrains’ Long Game Against Editor Fragmentation
JetBrains has spent more than two decades building IDEs for specific languages rather than one general-purpose editor, a strategy that looked increasingly unusual as VS Code’s extension model pulled developers toward a single, extensible core. The Fleet experiment, shut down at the end of 2025, was JetBrains’ attempt at a lightweight, VS Code-style alternative, and its retirement suggested the company had concluded it could not out-VS Code VS Code on lightness alone.
Air reads as the opposite bet: rather than chase a lighter editor, JetBrains is making its existing, language-specific IDEs heavier in exactly one dimension, agent orchestration, while explicitly refusing to lock that orchestration to JetBrains’ own models. It is a strategy that only works if JetBrains’ core IDEs remain the daily driver for enough developers that adding a feature there reaches more people than launching a new standalone product would. The March 2026 standalone Air app was, in effect, a proof of concept before the October IDE rollout made that bet explicit.
What’s Still Unconfirmed
- JetBrains has not announced a final, post-EAP release date for Air in IDEs.
- No price has been published for a standalone Air subscription outside the Toolbox bundle.
- Public reactions from GitHub, Cursor, or Windsurf to the IDE-native rollout have not been documented in available coverage as of October 18, 2026.
- Full architectural differences between Air, Junie, Mellum, and JetBrains AI Assistant have not been laid out in a single authoritative comparison.
- Windows and Linux timing for the originally standalone Air app beyond “announced” has not been pinned to a date.
Five Predictions for JetBrains Air’s Next Six Months
- JetBrains will publish a standalone Air pricing tier separate from the Toolbox bundle once the EAP label comes off, most likely tied to JetBrains AI Credit consumption for cloud runs.
- More ACP-compatible agents beyond the five standard integrations will add explicit Air support, since the protocol approach costs JetBrains little to extend.
- Cursor and Windsurf will respond with their own deeper IDE-agnostic orchestration layers rather than ignore the threat to their standalone-editor model.
- Enterprise sales conversations will increasingly treat agent-orchestration support, not raw model benchmark scores, as a top evaluation criterion for coding-tool procurement.
- JetBrains will extend native Air support to its remaining flagship IDEs, including Rider and GoLand, beyond the initial five covered in the October EAP.
Frequently Asked Questions
What is JetBrains Air?
JetBrains Air is a workspace and orchestration layer for coding agents. It is not an AI model or an agent itself; it lets developers run, track, and review sessions from agents like Codex, GitHub Copilot, Junie, Gemini, Claude Agent, and Cursor from inside a JetBrains IDE.
Which JetBrains IDEs support the Air EAP?
The Early Access Program covers IntelliJ IDEA, PyCharm, WebStorm, CLion, and RustRover, available as a Marketplace plugin for version 2026.2 and later or natively inside 2026.3 EAP builds.
Is JetBrains Air free to use?
Joining the EAP is free, and Junie Lite is available at no cost for everyday tasks with just a JetBrains account. A JetBrains AI subscription is required specifically for cloud-run agent sessions, and JetBrains has not published a standalone post-EAP price.
Which AI coding agents work with JetBrains Air?
JetBrains lists Codex, Gemini, GitHub Copilot, Claude Agent, and Junie as standard integrations. Cursor and any other agent that supports the Agent Client Protocol (ACP) can also connect.
How is JetBrains Air different from JetBrains Junie?
Junie is a single coding agent JetBrains builds and runs. Air is the surrounding workspace that can run Junie alongside other agents from different vendors, tracking all of their sessions in one place inside the IDE.
Do I need a JetBrains AI subscription to use Air?
Not universally. Developers can bring an existing third-party agent subscription or their own API key. JetBrains’ own Air site states that a JetBrains AI subscription is required specifically for cloud-run sessions.
How does JetBrains Air compare to Cursor and GitHub Copilot?
Cursor and Windsurf are standalone editors with built-in agents, priced around $20 a month each at the Pro tier. GitHub Copilot Pro runs closer to $10 a month as a plugin layered onto existing editors. Air does not replace any of them; it is designed to sit inside a JetBrains IDE and orchestrate agents from any of those products at once.
When will JetBrains Air leave Early Access?
JetBrains has not announced a final release date. The IDE-native rollout that began October 2, 2026, is explicitly labeled an Early Access Program, and no fixed timeline for general availability has been published.
