JetBrains is repositioning itself from a company that makes IDEs to one that manages the entire system through which AI agents build software. The new brand, JetBrains Air, packages three products aimed at different layers of the agentic development stack: individual developer environments, team coordination, and organizational governance. The announcement marks a strategic shift for a company that has spent 26 years focused primarily on the individual developer workbench.
Why the IDE Alone No Longer Suffices
The core observation driving the rebrand is that agentic development has split the software creation process across more surfaces than a single editor can contain. Developers are adopting AI agents faster than organizations can build infrastructure around them. The agents produce code quickly, but the costs surface elsewhere: in review, rework, security, infrastructure, and spend. JetBrains' framing is that the bottleneck has shifted from producing change to understanding, verifying, and owning it.
This is a concrete problem. Code that is obviously wrong gets caught quickly. Code that is almost right, plausible enough to pass a superficial check but carrying a bad assumption or architectural inconsistency, is the kind agents produce reliably and humans miss until it is expensive to fix. An agent will not get the call at 3:00 am when something breaks. The responsibility for what ships still belongs to the people and organizations that ship it.
The Three Products
Air in JetBrains IDEs provides the agentic development environment inside existing JetBrains editors. It gives developers tools to direct agents and verify their output using the company's code intelligence. Junie, JetBrains' coding agent, is supported across all Air surfaces.
Air Teams turns individual agent activity into coordinated team workflows. The product addresses the coordination gap: which agents can access company code, where data can go, which output requires human review, and who approved the resulting change.
Air Governance, formerly JetBrains Central, provides organizational policy, visibility, auditability, cost management, and accountability for AI-assisted and agent-driven development. It extends governance across providers and the different tools through which agentic work takes place, so developers can choose the agent or model suited to the task without sacrificing organizational control.
Multi-Vendor as a Design Principle
JetBrains is betting that the market will not consolidate around a single model or agent provider. Models vary in what they are good at, and rankings change every few months. Teams inside the same company already make different choices, and standardizing on one AI vendor means making a multi-year commitment in a market that will not look the same next quarter.
The problem with openness, as JetBrains frames it, is what it currently costs. Every new model or service an organization adds takes away more visibility into its own development work. Context does not carry over between tools. Spend cannot be attributed. Policies have to be rebuilt for each service. Air is designed to sit above several vendors at once, providing shared context, one set of policies, a single cost view, and a record of what happened regardless of which vendor produced the change.
The Agent Client Protocol standardizes the connection between an IDE and an agent's full harness, including planning, logic, tools, model routing, and observability. Through the ACP Registry, developers can discover and run compatible agents inside JetBrains IDEs. The protocol is the technical mechanism that makes multi-vendor support possible without fragmenting the development workflow.
The Economics of Verification
JetBrains' 26 years of code intelligence becomes a different kind of asset in an agentic world. Agents spend time and money rediscovering information the codebase already contains. An agent that can retrieve that knowledge is cheaper and more accurate than one that has to reconstruct it. Because the intelligence does not belong to one model, the benefit extends across supported agents and services.
This is both a technical and an economic argument. If JetBrains' deterministic code intelligence can reduce the verification burden, it creates a reason for organizations to run multiple agents through Air rather than through ad hoc integrations. The value proposition is not that Junie is the best agent, but that the system makes whatever agent you choose more reliable and more accountable.
What Organizations Actually Need
The gap between individual developer productivity and organizational software delivery is the real market JetBrains is targeting. Developers can point to time saved with agents. Organizations struggle to prove the economics because the costs are diffuse: review overhead, security review, infrastructure spend, and the risk of shipping code nobody fully understands.
Air Governance addresses this by making agent activity visible and attributable. Cost management, auditability, and policy enforcement are not features developers ask for, but they are features organizations require before they will allow agents to touch production code. JetBrains is building for the buyer who signs the procurement contract, not just the user who writes the code.
The Trajectory
Air will develop through a rolling series of releases. JetBrains says it will be explicit about what customers can use now, what is entering preview, and what remains part of the longer-term direction. Future work will extend into mobile and remote experiences, allowing people to initiate, monitor, and review agentic work as it moves between environments.
More work will be triggered by repository events, schedules, and delivery processes rather than by a developer opening an editor and issuing a prompt. JetBrains Air is the company's answer to a reality it did not create but is now building for: the software development system is no longer contained in one window, and the tools that govern it need to span the same distance the work now covers.