What JetBrains Air Actually Is
JetBrains Air is an open system of products for agentic software development that JetBrains announced on September 22, 2026. Instead of selling you one AI coding assistant, Air organizes how AI coding agents get directed, coordinated, and governed across individual developers, teams, and entire organizations. CEO Kirill Skrygan called it one of the most significant steps in the company’s 26-year history, and the framing matters: after decades of building tools for the individual developer, JetBrains is now building for the whole system through which agentic work gets initiated, executed, reviewed, and governed.
The short version for busy developers: Air has three parts. Air in JetBrains IDEs is where you direct agents and check their work inside the IDEs you already use. Air Teams coordinates agent-driven delivery workflows across your engineering org. Air Governance handles policy, cost, and auditability. JetBrains’ own coding agent, Junie, works across all three, but Air is deliberately model-agnostic.
The Three Products Under JetBrains Air
Air in JetBrains IDEs: Directing Agents Where You Code
This is the piece individual developers will touch first. Air in JetBrains IDEs provides a complete agentic development experience inside JetBrains’ existing IDE products like IntelliJ IDEA and PyCharm: you direct and orchestrate AI agents, and you verify their output without leaving your editor.
The verification angle is the whole bet. JetBrains has been explicit that the IDE remains central to its future specifically because someone has to review AI-generated code. As agents write more of the codebase, the review surface becomes the product. Air in IDEs is built around that loop: assign work to agents, watch what they do, and approve or correct the result.
Air Teams: Coordinating Agents Across the Org
Air Teams is the newest and most operationally interesting piece. JetBrains detailed it on September 28, 2026, and it is available now for business customers, with individual customers to follow.
What you get: shared cloud environments, cloud tasks, team projects, and automations for recurring work, with 10 automation templates at launch. Projects have their own service accounts and AI credits, and administrators decide whether an automation draws on the project’s credits or the creator’s personal credits. Connectors link to Jira, Figma, and Linear, and GitHub pull requests and events can trigger agent work automatically.
The idea, in JetBrains’ words: “What one developer figures out, everyone can use.” Automations capture a working agent workflow once and make it reusable across the team, which is the difference between ten developers each reinventing agent prompts and an org that actually compounds what it learns.
Air Governance: Policy, Cost, and Audit for AI Coding
Air Governance is the rebrand of JetBrains Central, the control system JetBrains introduced in March 2026. It covers organizational policy, visibility, auditability, cost management, and accountability for AI-assisted and agent-driven development.
This is the piece enterprises actually need before they let agents touch production code. Who ran which agent, on what code, at what cost, under whose approval? Six months of public experimentation fed into it: Central CLI, shared context, cloud agents, automations, governance controls, and AI cost tracking for teams.
The Openness Play: ACP and Multi-Agent Support
One of the smartest architectural decisions in Air is the Agent Client Protocol (ACP), a standardized way to connect development environments with coding agents, plus an ACP Registry for finding compatible agents. Junie is JetBrains’ own agent, but ACP means Claude Code, Codex, Gemini CLI, and other agents can plug into the same surfaces.
JetBrains’ stated reasoning is blunt: no single model, agent, or service will suit every developer, team, or task. Multi-model support is treated as a minimum requirement, not a feature. For developers, that means you’re not locked into one vendor’s agent to use Air’s orchestration and governance layers. For teams, it means you can standardize on Air’s workflow while letting individual developers pick the agent that works best for their stack.
What This Means If You Code for a Living
For Solo Developers and Freelancers
Air in IDEs is the relevant surface. If you already live in a JetBrains IDE, the agentic experience arrives where you work rather than in a separate chat window or terminal tool. The practical question is whether the verify-and-direct loop is genuinely faster than your current setup. Early signal to watch: how well Air’s agent orchestration handles multi-file refactors and test-driven loops compared to standalone agents you run today.
For Teams and Agencies
Air Teams is the pitch: recurring agent workflows (code review passes, test generation, dependency updates, boilerplate scaffolding) become automations with shared credits and connectors to the tools you already use. The GitHub PR trigger is the one to evaluate first, since review automation is where agent coding either pays for itself or creates noise.
For Enterprises
Air Governance is the compliance story. Cost attribution per project, audit trails of agent actions, and policy controls are table stakes for regulated industries. If your org has been holding back on agent coding because of the governance gap, this is the product line to pilot.
How JetBrains Air Compares to the Alternatives
The agentic coding space is crowded. Standalone agents like Claude Code and Codex run in the terminal and are genuinely good at what they do. What Air offers that they don’t is the organizational layer: shared automations, credit management, auditability, and IDE-native verification in one system.
The honest tradeoff: Air’s value compounds inside the JetBrains ecosystem. If your team lives in VS Code, the switching cost is real, and ACP support for external agents only partially offsets it. If you’re already on IntelliJ or PyCharm, Air is a natural extension rather than a new tool to adopt.
Pricing details are still rolling out as components reach general availability, so check JetBrains’ official pages for current plans before budgeting. The components that are available now versus those still developing is a moving target, and JetBrains has said Air will grow through a rolling series of releases.
The Bigger Picture: Coding Is Becoming Management
The subtext of the Air announcement is worth stating plainly. JetBrains spent 26 years optimizing the individual developer’s workbench. Air assumes the developer’s job is shifting toward directing and verifying agents. The IDE survives not as a typing surface but as the review and orchestration layer.
Whether that vision is right or just self-serving, the direction of travel is clear: every serious coding tool is adding an orchestration and governance layer. JetBrains got there with a coherent three-product story and an open protocol. Developers who learn to direct agents well, verify output ruthlessly, and build reusable workflows will be the ones who benefit, regardless of which vendor’s logo is on the system.
Sources: InfoWorld’s coverage of the JetBrains Air announcement. For current availability and pricing, see JetBrains’ official Air pages.
Related: Claude Code Projects Gets Multi-Agent Coding (2026)
Official source: JetBrains
Related: What Cursor Projects’ Cloud Subagents Actually Do (2026)
Frequently Asked Questions
What is JetBrains Air?
JetBrains Air is an open system of products for agentic software development, announced September 22, 2026. It spans three products: Air in JetBrains IDEs (directing and verifying agents), Air Teams (coordinating agent-driven delivery workflows), and Air Governance (policy, cost, and audit for AI coding).
Is JetBrains Air available now?
Some components are available now and others are arriving through rolling releases. Air Teams became available to business customers on September 28, 2026, with individual availability to follow. Check JetBrains’ official pages for the current status of each component.
Does JetBrains Air only work with Junie?
No. While Junie is JetBrains’ own coding agent and works across all Air surfaces, Air connects to agents through the open Agent Client Protocol (ACP), so agents like Claude Code, Codex, and Gemini CLI can also plug in.
What is the Agent Client Protocol (ACP)?
ACP is a standardized protocol for connecting development environments with coding agents, accompanied by an ACP Registry for discovering compatible agents. It’s JetBrains’ mechanism for keeping Air open to multiple models and agents rather than locking users into one.
How is Air different from GitHub Copilot or Claude Code?
Standalone agents focus on the individual coding session. Air adds the organizational layer on top: shared automations, per-project AI credits, connectors to Jira/Figma/Linear/GitHub, and governance with audit trails and cost management.
Should freelancers care about JetBrains Air?
If you already use JetBrains IDEs, Air in IDEs is worth watching as the agentic experience lands where you work. The team and governance products matter more to agencies and enterprises. Either way, learning to direct and verify coding agents is becoming a core developer skill.