JetBrains is turning Air from one agentic development environment into a wider system for directing, coordinating and governing software agents.
JetBrains Air is now three connected layers
JetBrains Air now names a product system rather than only a desktop environment. JetBrains describes Air in its IDEs for directing and verifying agent work, Air Teams for coordinating delivery workflows, and Air Governance, formerly JetBrains Central, for organizational policy, visibility, auditability, cost management and accountability.
The announcement matters because companies are discovering that adding more coding agents does not automatically produce a manageable software process. Generated patches still need context, review, ownership and a record of what happened. Air is JetBrains’ attempt to place those controls above individual agents and models.
What buyers can use now and what remains ahead
| Layer | Published purpose | Reporting boundary |
|---|---|---|
| Air in JetBrains IDEs | Direct agents and verify work using JetBrains code intelligence | Existing agentic IDE capabilities are available, but the full product system will expand through rolling releases |
| Air Teams | Coordinate developers and autonomous agents across delivery workflows | JetBrains presents it as part of the system; availability must be checked feature by feature |
| Air Governance | Apply policy, visibility, auditability and cost controls | Builds on JetBrains Central, with additional scope developing over time |
JetBrains explicitly says Air includes products available today alongside products that will be introduced as the system develops. That sentence prevents a common launch-day mistake: treating every item in a strategy announcement as generally available software.
Multi-vendor support changes the governance problem
JetBrains says no single model or agent will be right for every team or task. Air therefore uses the Agent Client Protocol, or ACP, to connect an IDE to an agent harness, including planning, tools, routing and observability. The ACP Registry gives developers a route to discover compatible agents without leaving the IDE workflow.
Choice creates its own cost. Each provider can have different billing, retention, tool permissions and audit records. Air Governance is intended to preserve shared policies and a common cost view across that fragmented stack. Our Codex versus Claude Code guide explains why teams already need workload-specific model selection instead of a permanent winner.
The real product is verification, not more generated code
JetBrains argues that the bottleneck is moving from producing changes to understanding and verifying them. That is a useful test for the product. A dashboard showing thousands of agent actions is not governance if reviewers cannot trace requirements, see tool use, reproduce decisions or identify who approved a risky change.
- Measure accepted changes and escaped defects, not generated lines.
- Attribute model, tool and infrastructure cost to completed work.
- Keep approval records for high-impact actions.
- Preserve the context and test evidence used during review.
- Make it possible to suspend, inspect and reverse agent work.
How Air compares with the current coding-agent stack
GitHub is adding managed settings, sandbox controls and OpenTelemetry to Copilot. Anthropic and OpenAI expose their own permission and agent-management systems. JetBrains is making a different architectural bet: a neutral layer tied to deterministic code intelligence and designed to sit above several vendors.
That does not make Air automatically neutral in practice. Buyers should test which third-party agents receive the same policy, context, cost and audit coverage as JetBrains products. A multi-vendor claim is most valuable when controls remain consistent at the edges.
A practical JetBrains Air evaluation plan
- List the agents and models your teams already use, including unofficial local tools.
- Choose one repository with repeatable tests and real review history.
- Define which data, tools and actions each agent may access.
- Run the same work through the IDE, team and governance surfaces that are actually available.
- Verify that cost, tool calls, approvals and final changes share one traceable record.
- Measure reviewer time, defects, reversals and cost per accepted change.
- Repeat the test with a third-party ACP agent before accepting the multi-vendor promise.
What JetBrains still needs to document
The announcement does not provide a complete feature-by-feature availability matrix, final commercial packaging or independent outcome data. Organizations will need product documentation for data residency, retention, access controls, supported providers, failure handling and audit export. JetBrains also needs to show how Air Teams and Air Governance behave when an agent operates outside an IDE or across several repositories.
The practical verdict
JetBrains Air is strategically important because it treats agentic development as an organizational system rather than an editor feature. Its strongest idea is shared governance across models and agents. Its success will be measured by whether teams can prove what an agent did, why a change was accepted, how much it cost and who remains accountable when the software fails.
For a useful comparison, see our Codex and Claude Code guide, which examines the execution layer that an organization-wide control plane must govern.
Primary sources
Checked September 23, 2026. Product direction and benefits are JetBrains-reported. Availability should be verified for each Air component before purchase.
