JetBrains Launches Air: The IDE Stops Being Just a Place to Write Code and Becomes the Agent Mission Control

What Air is: a three-layer architecture, one consolidation

On September 22, JetBrains CEO Kirill Skrygan announced JetBrains Air on the company's official blog, calling it "one of the most significant steps in our 26-year history." Air is not a new IDE, nor yet another coding agent — it is "a system of products for agentic software development," spanning individual developers, teams, and organizations.

The system has three products. Air in JetBrains IDEs is the in-IDE agent orchestration and verification experience: developers direct multiple agent sessions and review their changes inside the IDE they already know, with JetBrains' code intelligence (symbol understanding, project-structure awareness) serving as the inspection toolkit. Notably, it isn't locked to JetBrains' own models: Claude Agent, Codex, and JetBrains' own Junie all plug in, and developers can use their existing subscriptions. JetBrains also introduced a free Junie Lite configuration, urging users to "give it a real task and see how it feels." The Early Access Program is already open.

Air Teams (detailed further in a September 28 official blog post) attacks the problem that "agentic workflows used to live on one developer's laptop": configure once, and the whole team can run, validate, and improve it. Tasks execute in shared cloud environments (Docker containers), triggered by repository events (e.g., labeling an issue spins up an agent that investigates and opens a PR) or on schedules (dependency updates, automatic reviews when PRs open). Costs can be charged to project AI credits or personal user credits. Air Teams is already available to JetBrains business customers.

Air Governance is the renamed and upgraded JetBrains Central: organizational policy, visibility, auditability, AI cost management, and accountability. Skrygan's announcement contains a line worth savoring: "while the work can be delegated, accountability cannot."

This launch didn't come from nowhere. Air's individual workspace entered public preview in March, Central launched the same month, and over the following half year JetBrains shipped Central CLI, shared context, cloud agents, automations, and team cost controls. September's move folds six months of experimentation into one brand and one architecture. In Skrygan's words: "For 26 years, we have focused primarily on the individual developer workbench. Now, we are building for the wider system through which agentic work is initiated, executed, coordinated, reviewed, and governed."

The most interesting bet: no Junie lock-in, verification as the product

JetBrains could have taken the easy road: make Junie mandatory and use its IDE install base to lock users into a closed stack. It didn't. Air explicitly supports third-party agents via the Agent Client Protocol, with Claude Agent and Codex named at launch. Skrygan's bet is counterintuitive: models will be replaced and agents will go stale, but "context, review processes, and governance machinery" are evergreen. As long as JetBrains' products remain irreplaceable at "understanding your code" and "helping you stand behind what AI produces," it doesn't matter whose agent the customer uses.

Behind this bet is a harsh cost truth that JetBrains states plainly in the announcement: AI can generate code fast, but the cost to engineering organizations hasn't disappeared — it has moved, into review, rework, security failures, infrastructure, and incidents. "Plausible code carrying a mistaken assumption" is far harder — and more expensive — to catch than code that simply fails. So JetBrains elevates "verification" from post-generation cleanup to a core feature: inspecting diffs with the IDE's understanding of symbols and project structure, commenting on individual lines, sending changes back to the agent. It's the 26-year-old "code intelligence" moat, repackaged as the agent era's inspection capability.

Compare the routes rivals are taking and you'll see the agent war of late 2026 has split into three fronts: Cursor's September wave shipped Projects (coordinator agents delegating to thousands of subagents) and Rollouts (deployment monitoring with automatic revert PRs) — betting on the "agent orchestration platform." GitHub announced on September 24 a "default enablement" policy for Copilot enterprise features (effective October 22) — betting on platform default power. JetBrains is betting on the "verification and governance layer." None of the three is fixated on "whose model writes the best code" — because everyone now assumes models will keep getting stronger and cheaper, and the real scarcity lies elsewhere.

One more detail worth noting: both Air Governance (née Central) and Air Teams' cloud execution point the same way — agent workloads are migrating from "personal laptops" to "organizational infrastructure." When agents start running scheduled jobs, auto-fixing bugs, and auto-reviewing PRs in the cloud around the clock, "who pays for what and who is accountable for results" becomes unavoidable. JetBrains writing "cost management" and "accountability" into the product matrix first shows it smells the change in enterprise buying lists: next year, CIOs won't be buying "AI coding tools" — they'll be buying "agent governance."

What it means for vibe coders: the IDE war enters its second half

The direct impact first: if you're a heavy JetBrains IDE user, the Air in IDEs EAP is worth trying — especially the free Junie Lite. Directing multiple agents (including Claude and Codex) inside a familiar environment with full code intelligence is a "mission control" experience that pure terminal agents can't currently match. JetBrains' diff review, symbol navigation, and refactoring tools were born for "understanding code" — turning them on "reviewing AI-generated code" is a natural overmatch.

The indirect impact: JetBrains' pivot signals that the center of competition in agent tooling is shifting from "generation" to "governance." For indie developers and small teams, the selection criteria need updating: don't just ask "which agent writes the best code" — ask "which workflow gives me the most confidence in results at the most controllable cost." Air Teams' "configure once, reuse across the team" is a good litmus test: is your agent workflow a craft you re-tune from scratch every time, or engineering that compounds into team assets?

One final judgment: the smartest part of this launch is JetBrains admitting "the IDE is no longer the center of the universe." Skrygan says Air will extend into mobile and remote experiences, with agentic work flowing between environments. The IDE's role shrinks from "where code gets written" to "where code gets verified" — but verification is precisely the most valuable link in the AI era. When generation becomes cheap, judgment becomes expensive. JetBrains spent 26 years learning how to help developers "understand code"; now it wants to sell that craft to the agent era. The second half of the IDE war won't be won by whoever helps you write faster, but by whoever lets you sign off on what AI wrote with confidence.

A 26-year-old shop's pivot: why JetBrains said "governance" first

JetBrains has earned the right to say "governance." Among IDE vendors, it is the only one that turned "understanding code" into a core asset: IntelliJ's indexing, refactoring, and symbol resolution, built over two decades. When Cursor disrupted editors with "AI first," JetBrains' first reaction was actually sluggish — Junie arrived much later than Cursor, and Air's individual preview only came this March. But slowness has its upside: it saw clearly what the first wave of agent tools never solved — generation is easy, governance at scale is hard.

Skrygan's résumé is worth noting too: he joined JetBrains in 2010, worked on ReSharper, led Rider, then ran the entire IntelliJ department before becoming CEO in February 2024. He's a "tools person" turned CEO, with a feel for what developers actually pay for. His announcement talks about no parameters and no leaderboards — it talks about "accountability cannot be delegated." That's a pain point only someone who has built enterprise-grade tools would seize. Individual developers pay for delight; enterprises pay for control. Air's three-layer architecture is essentially selling "delight" (in-IDE agent experience) and "control" (Teams reuse, Governance auditing) separately, each earning its own money.

For Chinese developers, Air's launch carries an extra layer of significance. JetBrains IDEs enjoy extremely high penetration in China (especially among Java/Kotlin backend and Python developers), while agent tools like Junie and Cursor have long been hampered there by network and payment friction. If Air in IDEs can land smoothly through JetBrains' existing China channels, it may become many Chinese teams' first stop for "multi-agent orchestration." One question to watch during the EAP: where do Air Teams' cloud execution environments live, and how is data compliance handled? Those details will decide its enterprise landing speed in China — whether it's genuinely compelling or just something to admire from afar.

Skepticism won't be in short supply, of course. The most direct critique: Air is currently "some components available, others on the way" — the launch event is over, but the product matrix is still half-baked. JetBrains' answer is "rolling releases," but the market votes with its feet — Cursor's Projects is already usable, GitHub's default policy takes effect October 22, and JetBrains doesn't have much time to finish drawing the picture. A second critique concerns the sustainability of the openness pledge: today it supports Claude Agent and Codex; tomorrow, if Junie's commercialization needs "differentiation," will the openness promise get discounted? Skrygan will need to answer with actions, not just blog posts.

Still, JetBrains did one thing right: it moved "verification" from the backstage to the front. In an era when the cost of agent-generated code approaches zero, the only scarce resources are "people who dare to sign off" and "tools that help people dare to sign off." Air is betting on the latter. Whether the bet pays off depends on how enterprise buying lists change over the next year. But the direction is right — when everyone competes on who generates faster, someone competing on who makes you feel safer is itself a sign of maturity.

Three practical suggestions for readers who want to try it. First, start with the Air in IDEs EAP, not Air Teams — individual experience has the lowest verification cost. Run a familiar small task with the free Junie Lite and feel what "multi-agent sessions + IDE-grade diff review" does differently from the terminal agents you use now. Second, focus on the "send back" motion (commenting on individual lines, returning changes to the agent): JetBrains considers it the killer feature, and you should verify firsthand whether it's genuinely more efficient than "copy-pasting error messages into a terminal." Third, if you lead a team, start inventorying which of your current agent workflows are "craft that must be re-tuned by hand every time" — those are exactly the scenarios future Air Teams will absorb. Document them now. Whether or not you end up using JetBrains' product, that inventory itself is already worth it.

One easily overlooked angle: JetBrains is actually "redefining the IDE's billing unit." IDEs used to sell licenses per seat; Air will likely charge per "agent workload + governance seat" — Air Teams' "project AI credits or personal credits" already hints at it. For users, that means doing two sets of math when evaluating: the token cost of the agents themselves, and the cost of the "orchestration and governance" middleware layer. Middleware is never free — the bill just gets a new name.