JetBrains Air Bets Verification Beats Faster Code Generation

JetBrains on September 22, 2026 folded six months of agent tools into JetBrains Air, a system aimed at teams that already run many coding agents. Kirill Skrygan, the company’s CEO, wrote that AI can produce code while organizations still have to produce software, and that being wrong still costs the same.

The branded agent inside that story is not the centre of it. JetBrains is selling the layer that watches other vendors’ agents, because generating a patch got cheap and checking it did not.

JetBrains Air Gathers Six Months of Agent Tools

Skrygan’s post frames Air as a product system for developers, team leads, and engineering directors, open enough to steer almost any model and harness. That is a different pitch from a new autocomplete box in IntelliJ IDEA. For 26 years JetBrains sold the individual workbench. Air is the company building the path around that window: start the work, run it, coordinate it, review it, and govern it.

Today we introduce JetBrains Air – the product system for software development orgs in the age of agents.

Built for developers, team leads & engineering directors.

Open and flexible: steer and control almost any LLM & harness.

Read more: https://t.co/pXzAn10bnP

— Kirill Skrygan (@kskrygan) September 22, 2026

The name gathers work that was already public. Air first showed up as a public preview on March 9, 2026. JetBrains Central, the control and execution plane, was introduced on March 24. The Central CLI, shared context, cloud agents, automations, and cost controls followed through the summer. On September 22 those pieces were grouped as Air in JetBrains IDEs, Air Teams, and Air Governance, the new name for Central. Junie, the in-house coding agent, is meant to run across those surfaces.

THE SIX-MONTH BUILD

1. January 28, 2026: JetBrains and Zed put the Agent Client Protocol registry in front of IDE users.
2. March 9, 2026: Air opens as a public preview for running several agents in one workflow.
3. March 24, 2026: Central is announced as the control and execution plane for agent-driven work.
4. July 8, 2026: The Central CLI, now part of Air Governance, opens to early access for people with JetBrains AI credits.
5. September 22, 2026: JetBrains Air becomes the umbrella, and Central is renamed Air Governance.

The company product page now calls this one system for building software with agents, reachable from JetBrains IDEs, the browser at air.jetbrains.cloud, and the command line through Air Gateway. The IDE plugin is listed as Air (alpha). Air Teams is still an early-access door, not a finished suite on every desk.

WHAT WE KNOW

• The umbrella: Air is the September 22 name for IDE, team, and governance products that already existed in pieces.
• Junie’s place: The in-house agent is supported across Air surfaces rather than being the only agent the system will run.
• Bring-your-own access: The product page lets teams bring a provider subscription, an API key, or a base URL, and switch even mid-session.
• Partial cloud: Cloud runs are already available for some customers in IDEs and the browser, with a wider rollout described as gradual.

WHAT IS UNCONFIRMED

• General availability: JetBrains has not set a date when Air Teams or full cloud access ships to every customer.
• Org pricing: A public seat-plus-usage price list for Air Governance was not published with the September 22 post.
• Mobile and remote: Later surfaces are promised without names or ship dates.

The blog reads like a strategy memo, which is why people who opened it still asked what to install. The landing page is the clearer map of the three surfaces and the early-access links.

90% of Developers Use Agents Weekly

The reason for the rename sits in JetBrains’ own research, not in a demo reel. Mikhail Bogdanov’s August 18 write-up of the Developer Ecosystem Survey 2026, a tenth-year study of more than 15,000 professional developers, found that in May to July 2026, 90% used AI coding agents at work at least weekly, and 68% used them daily.

AGENT ADOPTION AT WORK, MAY TO JULY 2026

Claude Code is the most used AI coding tool for 31% of developers. Codex awareness jumped from 27% in January 2026 to 65% in May to July. Copilot still has 79% awareness even as workplace use fell. Cursor’s mind share rose from 69% to 75% while use fell, including a drop in China from 28% to 16%. OpenCode, which has no giant vendor brand behind it, reached 7% use and 42% awareness.

Around 9% is JetBrains’ own branded stack. That is a different number from how often a rival still runs inside a JetBrains window: 39% of GitHub Copilot users say they use it, among other surfaces, in JetBrains IDEs. The workbench is still a place people review code. It is no longer the place that wins the agent vote.

Terminal-first tools took the share that IDE-native assistants lost. If that pattern holds, a company that only ships a better pane inside the editor is chasing last year’s bottleneck. Air is the attempt to sit above the zoo instead of replacing Claude Code with Junie.

What Air Governance Controls

Oleg Koverznev, vice president and head of the agentic platform, wrote in the March 24 Central launch that code generation is cheap and no longer a bottleneck. The expensive part, in that post and again in Skrygan’s September 22 essay, is aligning results with intent and managing the operational mess of agent-driven work. Air Governance is that former Central console: policy, visibility, audit, cost, and who is on the hook.

WHAT AIR GOVERNANCE IS BUILT TO DO

• Access: Set which models and agents a whole company, a team, or one person may use.
• Spend: Put budgets on teams, policies, or users, and see current, past, and forecasted consumption.
• Keys: Add a key from Amazon Bedrock, OpenAI, Anthropic, or another provider once and share that access.
• Record: Keep an audit trail of remote agent work, including who approved a change and how it was checked.
• Analytics: Attribute cost and use by developer, agent, and IDE instead of sorting vendor invoices by hand.

Those questions are the ones Skrygan listed in plain language. Which agents can touch company code, where data may go, which output needs a human, what happened while an agent ran off-laptop, who signed off, and how the result was verified. Fragmentation here is not a taste issue. It is how a company loses the plot once more of the typing is delegated.

Air in JetBrains IDEs is the verification surface in that design: direct agents, then open diffs, run IDE inspections, and leave line comments for the agent. Governance is supposed to follow the same job when the agent is Claude Code in a terminal rather than Junie in a tool window. That only works if the CLI traffic actually passes through JetBrains’ router.

A 10x Bill and a Homegrown CLI

Inside JetBrains, the bill arrived before the product name did. An August 3 engineering post said AI development expenses increased roughly 10x in the first half of 2026. Developers were still in the IDEs. They had also added CLI agents, multi-agent environments, and extra IDE AI tools, and most of them used between three and five AI tools in a given month.

JETBRAINS INTERNAL AI SPEND

• The spike: Use almost doubled each month after Claude Opus 4.5 and 4.6 landed in January 2026, across Claude Code CLI, IDE chat, and Junie.
• The seats: The company hit 150 Claude Code seats, then moved to an Enterprise plan billed on API use, which is when costs jumped.
• The spreadsheet: Pulling vendor consoles into one snapshot by department took four days and could not set limits.
• The CLI: A personal wrapper became the Central CLI, which auto-detects agents and sends requests through JetBrains’ AI traffic layer as credits.

On July 8, after using the wrapper on itself, JetBrains opened the Central CLI to anyone with JetBrains AI credits. Over a thousand of its own developers switched in a few weeks. The public CLI covers three of the most used terminal agents, with four more in internal beta. Niche setups and personal subscriptions stay out of scope on purpose.

The same post says the JetBrains AI Platform has routed more than a billion LLM requests since 2023. The honest limit is also in that write-up: if AI use is still small, the economics of a control plane probably do not pay. The product exists for teams already drowning in API traffic across several third-party tools.

Limiting everyone to one or two vendors would have been cheaper to administer. JetBrains rejected that internally, arguing that the best setup changes from week to week, Claude Code on one model mix then Codex on another. Air Governance is the bet that you can keep that freedom without losing the bill, the policy, or the log.

ACP Puts Rival Agents Inside the IDE

Multi-vendor is not a slogan on the side of Air. It is how JetBrains avoids a bet on which lab leads the rankings next quarter. Skrygan wrote that standardizing on one AI vendor now is a multi-year commitment in a market that will not look the same next quarter, and that Air does not require customers to use Junie.

The plumbing for that is the Agent Client Protocol, built in the open with Zed, which treats an agent the way the Language Server Protocol treated languages: implement once, attach to any client that speaks it. Through the ACP Registry of compatible agents, a JetBrains IDE can install an agent the way it installs a plugin. Zed’s January 28 post said JetBrains pushed the registry specification with Zed, and both editors shipped a registry browser.

The live registry list includes Junie, Cursor, Devin, Amp, Auggie CLI, and a long tail of other harnesses. JetBrains’ own ACP page also points at Gemini CLI, GitHub Copilot, and Kiro CLI. Claude Agent, Codex, GitHub Copilot, and OpenCode already sit in JetBrains IDE AI chat without a custom integration each. That is the practical answer to the question people asked under Skrygan’s post: you can bring a Claude or ChatGPT subscription, or a key, rather than waiting for JetBrains to pick a single model.

Openness still has a cost, which is the gap Air Governance is meant to close. Each extra agent usually means another context store, another invoice, and another policy rewrite. The company line is that nothing in the current stack was built to sit above several vendors at once. Whether a registry entry is enough for a bank’s audit team is a separate test. A listing means the agent speaks ACP. It does not mean every optional capability is there, or that behaviour matches the next name in the list.

Shared Cloud Projects and Event-Triggered Agents

Air Teams is the slice that treats an agent run as team work rather than a private terminal session. The product page describes shared projects in dedicated cloud environments, invites and access in one place, and automations for code review, release notes, and fixes. MCP servers can be connected once so people and agents reuse the same external tools. Each project can set VM size, internet access, and secrets.

WHERE AIR TEAMS TAKES THE WORK

• Browser: The web app at air.jetbrains.cloud is for organization accounts; an admin enables it from the console.
• Cloud agents: Tasks run in a container, commit to a task branch, and wait for a human to open a pull request.
• Triggers: More work is meant to start from repository events, schedules, and delivery process, not only from a prompt in an editor.
• Context: Air Context’s semantic index is sold as a way to stop agents from burning tokens rediscovering a repo they should already know.

Help pages still mark pieces as EAP or limited EAP. Cloud runs exist for some customers in IDEs and the browser, and JetBrains says remaining customers will get them over the coming months. Mobile is on the public site as coming soon. The point of those surfaces, Skrygan wrote, is not to clone the IDE onto a phone. It is to put context and controls wherever someone has to accept or reject a change.

That is also where the second-order cost shows up. A merge-triggered reviewer or an issue-triage bot can run while nobody is at the laptop. Someone still has to own the diff. Air Teams without Air Governance is another place work can hide. Together they are an attempt to make the hidden work visible enough to budget.

The Call at 3 am Still Goes to People

Skrygan’s sharpest line is not about models. Obviously wrong code still gets caught. The painful case is code that is almost right, plausible enough to pass a skim, carrying a bad assumption that stays cheap until it is not. As agents take more of the execution, the bottleneck moves from producing a change to understanding, verifying, and owning it.

An agent will not get the call at 3:00 am when something breaks. The responsibility for what ships still belongs to the people and organizations that ship it.

Kirill Skrygan, CEO, JetBrains blog, September 22, 2026

A stronger model does not write the policy, keep provenance, show the bill, or decide who accepts the patch. JetBrains is going through that shift on its own code, and it is unusually blunt about the 9% share of its branded agent. The September 22 system is the company trying to charge for the part of software that did not get cheaper: review, rework, security, and spend, across Claude Code, Codex, Copilot, Junie, and whatever lands in the registry next month.

Companies that win this round, in Skrygan’s closing, will not be the ones that generate the most code or deploy the most agents. They will be the ones that can try more of that without losing quality, context, cost discipline, or a human who still knows what shipped. Air is the wager that JetBrains’ 26 years of deterministic code intelligence still matter once the typing is no longer the scarce resource.