JetBrains expands Air into a control system for rival coding agents

Why it matters

Air makes JetBrains' code intelligence part of a multi-vendor system for reviewing, coordinating and governing AI-written software, giving the company a role even when customers choose a rival coding agent.

JetBrains CEO Kirill Skrygan (@kskrygan) on September 22nd introduced JetBrains Air, a system spanning coding agents, developer workspaces, team automation and organization-wide governance. JetBrains is betting that its next durable position in software development will sit above a shifting collection of AI models and agents, including products JetBrains competes with.

Skrygan arrived at that bet through the IDE itself. He joined JetBrains in 2010 and was leading the IntelliJ department before he became CEO in February 2024.

Air is his answer to that fragmentation. It groups three layers under one name: Air in JetBrains IDEs for running and reviewing agents, Air Teams for shared projects and automated workflows, and Air Governance, the renamed JetBrains Central, for policies, permissions, audits and AI spending controls. JetBrains' Junie coding agent will work across those surfaces, while outside agents can connect through the Agent Client Protocol.

The structure reveals where Skrygan thinks the value will settle. Model providers can keep trading benchmark wins and developers can keep switching tools. JetBrains wants its products to provide the context, review process and administrative machinery that remain useful when the preferred agent changes.

JetBrains moves beyond the IDE

JetBrains built its position by putting increasingly sophisticated code analysis, navigation, debugging and refactoring inside a developer's workbench. Air extends that logic into an environment where some work begins without a developer opening a file.

Air in JetBrains IDEs can detect compatible agents, run several sessions and open their changes inside JetBrains' review tools. Developers can use provider subscriptions or API keys and switch access methods during a session, according to the Air product page. JetBrains says its code intelligence can give agents precise information about a repository rather than forcing a model to reconstruct that knowledge by scanning files.

Air Teams moves execution into shared cloud environments. JetBrains lists automations for code review, release notes and fixes, along with controls for virtual machine size, internet access, secrets and shared MCP servers. That product is in early access. Air Governance provides organization-level permissions, spending limits and usage analytics across providers.

Those capabilities turn JetBrains' familiar developer tooling into an enterprise control layer. A large deployment creates questions about code access, data movement, approval, provenance and cost allocation. Skrygan is packaging those questions as a product category before buyers settle on a single answer.

JetBrains has some distribution for the attempt. Its 2026 annual highlights report 12.5 million recurring active users, 2,600 employees and customers among 88 of the Fortune Global Top 100. JetBrains also reported that its AI products reached a six-figure active paid user count in the fourth quarter of 2025. Those are JetBrains-wide figures, rather than evidence of Air adoption.

JetBrains would rather arbitrate the agent market

Air's multi-vendor design is the strategic center of the launch. JetBrains' website lists Claude Agent, Codex, Junie, Copilot and OpenCode among the agents Air can run, with other products available through ACP. Customers can bring keys from providers including OpenAI, Anthropic and Amazon Bedrock.

That openness carries a clear incentive. JetBrains cannot control which model leads on coding quality from one quarter to the next. It is positioning repository context, workflow coordination, review, permissions, and cost visibility as the layer that remains useful when customers switch agents.

Skrygan wrote that standardizing on one AI vendor amounts to a multi-year commitment in a market that can look different by the next quarter. Air gives JetBrains a product position that survives those rankings. Junie can win work when it performs well, while JetBrains still has a role when a customer chooses Claude, Codex or another agent.

ACP is essential to that pitch. The protocol connects an IDE to an agent's broader harness, including planning, tools, routing and observability. An ACP registry gives developers a path to discover compatible agents. The practical test will be how consistently third-party agents expose their capabilities and how much control organizations can retain across systems built by different vendors.

Developers are already assembling their own orchestration layers. RuntimeWire reported in July on Herdr, Can Celik's terminal control room for keeping Claude Code, Codex and other agents running across panes and remote sessions. JetBrains is pursuing the same underlying demand from the opposite end of the market, attaching orchestration to established IDE intelligence and enterprise administration.

Skrygan is making verification the product

JetBrains first launched Air as a public preview in March 2026, presenting it as a workspace for delegating tasks to multiple agents and reviewing their output. Later that month, JetBrains introduced Central as a control and execution layer for agent-driven development. The September launch folds those efforts into one architecture and one brand.

The consolidation also sharpens Skrygan's argument about where AI coding creates costs. Generated code can appear quickly, while engineering organizations still pay for review, rework, security failures, infrastructure and incidents. Plausible code carrying a mistaken assumption is harder to catch than code that simply fails.

JetBrains therefore treats verification as a core feature rather than cleanup after generation. Developers can inspect diffs using the IDE's understanding of symbols and project structure, comment on individual lines and return changes to an agent. JetBrains says Air Governance adds organizational policy, visibility, auditability, cost management and accountability.

That position fits Skrygan's background: he worked on ReSharper, led the Rider project, and later led JetBrains' IntelliJ department.

JetBrains is also declining the easiest form of lock-in. It could have made Junie the required agent and used its IDE reach to push customers toward a closed stack. Skrygan instead has to prove that JetBrains' context, coordination and governance remain useful regardless of which agent performs the coding.

Air makes that wager explicit. Skrygan is expanding JetBrains from the window where developers write software into the system where people and agents decide, execute, review and account for the work. The IDE remains the point of inspection. JetBrains now wants Air to coordinate the work that happens around the IDE.