JetBrains Air Is the Multi-Vendor Control Plane Every Coding Agent Will Run Through — and JetBrains Wrote It on Purpose

JetBrains shipped Air on 2026-09-22: three products (Air in IDEs, Air Teams, Air Governance), twelve ACP-compatible agents, and an explicit admission that the winning surface is the router + review + audit layer above the agent.

September 24, 2026 – JetBrains CEO Kirill Skrygan announced JetBrains Air on September 22. The pitch is short and unusual for a vendor that has spent 26 years focused on the developer workbench: the agent inside the IDE is no longer the surface that matters. The surface above the agent is.

Air is not a coding agent. It is a control plane that accepts twelve of them. JetBrains’ own Junie runs across all three Air surfaces. So do Gemini CLI, GitHub Copilot, Codex, Cursor, Mistral Vibe, OpenCode, Kimi CLI, Qwen Code, Factory Droid, Cline, and Kiro CLI, via the open Agent Client Protocol (ACP). JetBrains IDEs, Zed, and the mobile clients are the consumers. Skrygan’s own framing – “the era in which the whole software development system can be contained in one window is ending” – is the load-bearing sentence in the announcement. It is JetBrains publicly conceding that the IDE as an application boundary is dissolving, and re-positioning itself as the layer that survives the dissolution.

What Air actually is

Air is three products under one brand, and two of them are renamed from work JetBrains shipped over the past six months:

Product What it is Status
Air in JetBrains IDEs Agent orchestration and verification inside IntelliJ-family IDEs. Junie plus any ACP-compatible agent, pluggable. Shipping today
Air Teams Shared cloud workspaces for developer + agent workflows. VM size controls, internet access, secrets, shared MCP servers, automations for code review, release notes, and fixes. Early access today; gradual rollout planned
Air Governance The renamed JetBrains Central. Organizational policy, audit trails, per-agent AI spend caps. Shipping today as the new name

The naming consolidation matters. The three products were already there as Junie, Central, and a cloud-execution story. Folding them under Air is not a new product launch; it is JetBrains admitting the umbrella is the product. The strategic read is that an umbrella without open standards would not survive the agent churn happening underneath it. Hence ACP.

The ACP bet, in concrete numbers

The Agent Client Protocol is JetBrains’ answer to the lock-in question every enterprise buyer is now asking. ACP is an open specification. The JetBrains ACP registry currently lists twelve agents and three client surfaces. The full roster, from the official JetBrains ACP page:

  • Agents (12): Junie, Gemini CLI, GitHub Copilot, Codex, Cursor, Mistral Vibe, OpenCode, Kimi CLI, Qwen Code, Factory Droid, Cline, Kiro CLI.
  • Clients (3): JetBrains IDEs, Zed, mobile (announced as “coming soon” per Unite.AI).

This is the same anti-lock-in pitch Stripe/OpenRouter ran on the model-routing layer in August (see TopClanker’s August 18 piece on the Stripe-OpenRouter acquisition) – only one layer up the stack. The architectural commitment is “multi-vendor by design.” Per the InfoWorld breakdown, JetBrains is positioning ACP as a plug-and-play protocol: connect an agent, route through it, audit it, cap it. The cost of switching agents in an Air-managed workspace is the cost of changing a config, not the cost of changing a platform.

Air Teams: where execution moves

Air Teams is the cloud-execution layer most enterprise buyers have been quietly waiting for. The InfoWorld piece and the JetBrains launch page describe the same feature set: shared cloud environments with automations for code review, release notes, and fixes, plus admin controls for VM size, internet access, secrets, and shared MCP servers. The MCP-server control is the underrated one – it is the mechanism by which an organization governs which tools its agents can reach, and it is the piece every agent vendor has been punting on.

Air Teams is in early access as of September 22. The JetBrains launch page describes a “gradual rollout” with no hard GA date. Per InfoWorld, the early-access framing is “available now for qualifying teams” – read that as a closed beta with a sales motion attached.

Air Governance: the renamed plane

The piece most enterprise readers will care about is Air Governance, because it is the only one that is unambiguously a revenue surface. Air Governance is the renamed JetBrains Central. The rename, per Techzine, is the headline; the functionality is unchanged from the Central product JetBrains has been shipping since spring.

What Central / Air Governance actually does:

  • Per-agent spend caps. Each agent registered via ACP can have its own budget ceiling. The cap is enforced server-side, not client-side – which means a runaway agent loop in your cloud workspace cannot blow through your quarterly AI budget.
  • Audit trails. Every action an agent takes in an Air-governed environment is logged with the actor (developer or agent), the action class (read, edit, run, network), and the policy that allowed or denied it.
  • Policy enforcement. Org-level rules on which agents are allowed in which workspaces, which MCP servers are reachable from which environments, and which model providers each workspace can hit.

The skeptical read is that none of this is technically novel – Central has shipped most of it for months. The honest read is that the rename is a positioning move. JetBrains wants the governance plane to be the durable revenue surface, and the “Air Governance” name puts it next to “Air Teams” and “Air in IDEs” as a peer, not a back-office admin tool.

The competitive read: agent is commoditized, control plane is the prize

The headline that matters is the one Skrygan gave away. “The era in which the whole software development system can be contained in one window is ending” is JetBrains publicly admitting three things at once:

  1. The IDE-as-application-boundary model is dissolving. Coding agents are becoming ambient – they run in clouds, on mobile, in chat surfaces, in CI.
  2. The coding agent itself is a commodity. Twelve agents are already compatible with ACP. The next twelve will be too. Differentiation at the agent layer is going to look like differentiation at the model layer has looked since 2024 – narrow, fast-moving, and margin-compromised.
  3. The durable surface is the layer above the agent: routing, review, audit, policy, cost control.

That is the surface JetBrains is betting on, and it is the surface nobody else has standardized on yet. Cursor has an agent. Codex has an agent. Copilot has an agent. None of them have shipped a multi-vendor control plane that lets an enterprise pick which agents run in which workspaces, with policy and spend caps applied at the protocol layer rather than the per-vendor dashboard.

Why “open” is the necessary part

JetBrains’ “multi-vendor by design” framing is not generosity. Every agent vendor on the ACP list is also a JetBrains customer in some form – Cursor and Codex have IDEs that compete with IntelliJ, but their developer teams still use JetBrains tooling, and large enterprises that buy Cursor or Copilot licenses are buying them through JetBrains-shaped procurement relationships. JetBrains cannot lock them out without losing the relationship. The architectural commitment to ACP is the response: if everyone has to come through JetBrains to govern their agents, the platform survives the agent churn regardless of which agent wins.

The strategic read is that governance and cost controls are the durable revenue surface, the IDE is the durable distribution surface, and the agent itself is the churn surface. JetBrains is making the bet that owning the first two is worth conceding the third.

The honest counter-read is that this only works if enterprises actually want a JetBrains-shaped control plane. The data so far suggests they do: JetBrains reported in summer 2026 that the Central product (now Air Governance) had crossed 1,000 enterprise deployments. The Air rename is JetBrains betting the number goes up significantly.

What this means for teams picking an agent stack

Three concrete implications for any team evaluating coding agents today:

  1. Do not over-commit to a single agent vendor’s governance story. Cursor, Copilot, and Codex each have admin dashboards. None of them are multi-vendor. If your organization is going to run more than one agent in production – and most will by Q1 2027 – the single-vendor admin plane becomes a coordination liability. Air’s pitch is the escape hatch.
  2. Per-agent spend caps are now table stakes. Anthropic’s cache-read cuts on Opus 5.5 (see TopClanker’s September 23 piece on the OpenAI/Anthropic price cuts) and OpenAI’s GPT-6 Sol/Luna cuts have made per-token pricing volatile enough that a single runaway agent loop can blow a quarterly budget. Air Governance’s server-side spend caps are the mechanism that makes “let developers pick whichever agent” financially survivable.
  3. MCP-server governance is the next compliance surface. Most enterprise security teams have not yet asked which tools their agents can reach. Air Teams’ shared-MCP-server control is the first mainstream product to put that on an admin dashboard. Expect this to become a procurement requirement within two quarters.

The honest read for any engineering leader is this: JetBrains shipped a control plane that treats the agent as a pluggable commodity and the governance/review/cost surface as the durable product. If that framing is correct – and the next twelve months will tell – the JetBrains position is stronger after Air than before it. The 26-year workbench story is over. The control-plane story is just starting.

Sources