JetBrains launches Air, a multi-product system for agentic software development

What JetBrains announced

On 22 September 2026, JetBrains announced Air, a system of products for agentic software development that gathers up work the company has been rolling out publicly for roughly six months. That earlier work included experiments with agentic development environments plus the launch of JetBrains Central, an open control and execution layer for agent-driven development, along with a CLI, shared context, cloud agents, automations, governance and AI cost controls for teams and organisations.

JetBrains describes Air as a significant widening of what it builds. For 26 years the company concentrated on the individual developer's workbench; it now says it is building for the broader process through which agent-driven work is started, run, coordinated, reviewed and governed. The announcement, which reached the front page of Hacker News, still positions the IDE as central to the company's future — while acknowledging that software development increasingly no longer fits inside a single window.

The products in the system

According to the blog post, Air is multi-surface and multi-service, made of products that each address a distinct problem but are designed to work better together. Some are available now and others will arrive as the system develops:

• Air in JetBrains IDEs: a full agentic development experience for directing and orchestrating agents and verifying their output inside JetBrains IDEs, using JetBrains' code intelligence.
• Air Teams: coordination and automation of software-delivery workflows that mix human developers and autonomous agents.
• Air Governance: the renamed JetBrains Central, covering organisational policy, visibility, auditability, cost management and accountability for AI-assisted and agent-driven work.

Junie, JetBrains' coding agent for professional development, will be supported across all Air surfaces.

Two connective pieces matter for openness. The Agent Client Protocol (ACP) standardises the link between an IDE and an agent's full harness — its planning, logic, tooling, model routing and observability — while the ACP Registry lets developers discover and run compatible agents without leaving JetBrains IDEs. JetBrains says Air Governance is built to extend visibility and cost governance across providers and tools, so developers can choose whichever agent, model or service suits a task while the organisation keeps its context, visibility and control.

The multi-vendor argument

JetBrains states that multi-vendor support is a foundational design principle, and its reasoning is straightforward. Models differ in what they are good at, rankings shift every few months, and teams inside the same company already make different choices — often correctly. Standardising on a single AI vendor today means a multi-year commitment in a market that will look different next quarter.

The catch, the company argues, is what openness currently costs: context does not carry over between tools, spending cannot be attributed, and policies have to be rebuilt for each new service. Nothing in the existing stack was designed to sit above several vendors at once. Air is JetBrains' attempt to be that layer — a place to run, see, govern and account for agentic development across models, agents and services. The company says it will keep improving its own agent but that Air does not require it and the strategy does not depend on which provider leads the rankings.

Where the bottleneck is moving

The blog post's diagnosis is that developers have adopted agents faster than organisations have built the infrastructure around them. Individuals are getting practical value; the organisational economics are harder to prove, with costs showing up in review, rework, security, infrastructure and spend.

JetBrains also argues the quality problem is changing shape. Obviously wrong code gets caught quickly; the harder case is plausible output that passes a surface check while quietly carrying a bad assumption that surfaces expensively later. As agents take on more execution, generating code gets cheaper while verifying it gets more expensive, and agent activity becomes easier to start but harder to coordinate, audit and explain. Accountability, meanwhile, cannot be delegated: when something breaks overnight, a human gets paged, and a more capable model does not by itself create organisational policy, preserve provenance, provide cost visibility or decide who accepts responsibility for a change.

Why it matters

One of the largest IDE vendors is repositioning itself from tooling the individual developer to running the wider system around agent-driven development — initiation, coordination, review and governance. That tracks a broader industry shift in which code generation is becoming cheap while verification and accountability are becoming expensive.

The strategically interesting part is the cross-vendor layer. If organisations really do end up using several agents and models, the product that provides unified context, auditing and cost control across all of them occupies a powerful position. The open questions are execution and adoption: parts of Air are still to ship, and the value of a vendor-neutral control layer depends on third-party agents and providers actually supporting it.