JetBrains Air: Building a System of Products for Agentic Software Development - The JetBrains Blog

Skip to content

Topics

Search

Burger menu icon

IDEs

CLion
DataGrip
GoLand
IntelliJ IDEA
PhpStorm
PyCharm
RustRover
Rider
RubyMine
WebStorm

Plugins & Services

JetBrains Platform
Scala
Toolbox App
JetBrains AI
Junie
JetBrains for Data
Air

Team Tools

Datalore
TeamCity
YouTrack
Qodana
Databao

.NET & Visual Studio

.NET Tools
ReSharper C++

Languages & Frameworks

Kotlin
Ktor
MPS
Amper

Education & Research

JetBrains Academy
Research

Company

Company Blog
Security
Community Programs
Life at JetBrains

Company

Follow

Follow:
X X
Facebook Facebook
Linkedin Linkedin
Instagram Instagram
Youtube Youtube
RSS RSS
Tiktok Tiktok

Visit jetbrains.com

All

News
Events
New Products
Interviews

Agentic AI
AI
JetBrains
New Products
News
Releases
JetBrains Air: Building a System of Products for Agentic Software Development

Kirill Skrygan

AI can produce code. Organizations still have to produce software. Agentic development is changing how software gets made, but it hasn’t changed what it costs to be wrong.
Six months ago, we began publicly experimenting with agentic development environments. Around the same time, we introduced JetBrains Central as an open control and execution system for agent-driven development. We subsequently began rolling out JetBrains Central CLI, shared context, cloud agents, automations, governance, and AI cost controls for teams and organizations.
Today, we are bringing this work together as JetBrains Air: an open, coherent system of products for developers, teams, and organizations, inside and beyond JetBrains IDEs. It is multi-surface and multi-service. Each product solves a distinct problem, but the products work better together.
JetBrains Air marks a significant expansion in what JetBrains is building for. For 26 years, we have focused primarily on the individual developer workbench. Now, we are building for the wider system through which agentic work is initiated, executed, coordinated, reviewed, and governed.
The IDE remains important to JetBrains’ future. The era in which the whole software development system can be contained in one window is ending. As part of our continued investment, we are now bringing the foundational agentic experience into JetBrains IDEs, giving professional developers an environment where they can work effectively with agents while understanding, changing, and verifying the resulting code. JetBrains Air connects the wider system developing around it.
That system is based on a core belief that the future of agentic development will be multi-vendor. No single model, agent, or service will be right for every developer, team, or task.
From one product to an open system of products
This strategic shift has a practical consequence: JetBrains Air cannot be just another agent or development environment. It must connect products for individual work, team coordination, organizational control, context, and process automation – and remain open to the tools and agents developers choose, including those JetBrains does not build.
JetBrains Air includes products that are available today alongside others that will be introduced as the system develops:

Air in JetBrains IDEs – a complete agentic development experience for directing and orchestrating agents and verifying their work inside JetBrains IDEs. 
Air Teams – a new way to coordinate and automate software-delivery workflows involving developers and autonomous agents. 
Air Governance (formerly JetBrains Central) – organizational policy, visibility, auditability, cost management, and accountability for AI-assisted and agent-driven development. 

Junie is JetBrains’ coding agent for professional software development. It will be supported across all Air surfaces.
Air in JetBrains IDEs gives developers the environment to direct agents and verify their output using JetBrains’ code intelligence. Air Teams turns individual agent activity into coordinated team workflows. Air Governance makes that activity visible, governable, and accountable across the organization.
But an open system cannot stop at JetBrains’ own products. The Agent Client Protocol (ACP) standardizes the connection between an IDE and an agent’s full harness, including its planning, logic, tools, model routing, and observability. Through the ACP Registry, developers can discover and run a growing range of compatible agents while continuing to work inside JetBrains IDEs.
Air Governance is designed to extend visibility and cost governance across providers and the different tools through which agentic work takes place. This means developers can choose the agent, model, or service suited to the task without forcing the organization to give up context, visibility, or control.
Together, the Air products allow work to move between developers, agents, tools, and environments without losing the context and controls surrounding it.
Individual adoption has moved faster than organizational infrastructure
Since March, our products have progressed significantly, but so has our understanding of what agentic development requires.
Developers have been adopting agents faster than organizations can build the infrastructure around them. Agent capabilities have advanced, and different models and agents have proven useful for different tasks. However, the context, coordination, governance, and cost management surrounding them have not kept pace.
For many developers, agents are already delivering practical value. At the organizational level, the economics are much harder to prove. The costs surface elsewhere – in review, rework, security, infrastructure, and spend. 
Which agents can access company code? Where can data go? Which output requires human review? What happened while an agent was working remotely? Who approved the resulting change, and how was it verified?
Fragmentation at this level isn’t just irritating. It makes software development harder to understand, measure, and govern at exactly the point when more of the work is being delegated.
The bottleneck is shifting with the work
Code that’s obviously wrong gets caught quickly. That part of the system still works. The harder problem is code that’s almost right: plausible, capable of passing a superficial check, but quietly carrying a bad assumption or architectural inconsistency that won’t surface until it’s expensive.
As agents take on more of the execution, the bottleneck shifts from producing change to understanding, verifying, and owning it. Code becomes cheaper to generate but more expensive to verify. Agent activity becomes easier to start but harder to coordinate, audit, and explain.
And while the work can be delegated, accountability cannot. 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. 
This is why control becomes harder, not easier, as AI improves. A more capable model may produce better output. It does not establish organizational policy, preserve provenance, provide cost visibility, or decide who accepts responsibility for the resulting change.
The future is multi-vendor
Multi-vendor support is a foundational design principle of JetBrains Air, shaping how the system is being built from the outset.  
We don’t believe this market will consolidate any time soon. Models vary in what they’re good at, and rankings change every few months. Teams inside the same company already make different choices, and they are often right to do so. Standardizing on one AI vendor today means making a multi-year commitment in a market that won’t look the same next quarter.
Keeping the options open is the reasonable thing to do. The problem is what openness currently costs. Every new model, agent, or service an organization adds takes away a little more visibility into its own development work. Context doesn’t carry over between tools. Spend can’t be attributed. Policies have to be rebuilt for each service. 
Organizations should not have to choose between using the best available tools and understanding what is happening inside their own engineering. That trade-off exists because nothing in the current stack was built to sit above several vendors at once.
This is the work JetBrains has taken on. We build our own agent, and we intend to make it excellent. But JetBrains Air does not require customers to use ours, and our strategy does not depend on which model provider leads the rankings this quarter. We have no reason to make the ecosystem smaller than it is.
What we can offer instead is one place to run, see, govern, and account for agentic development across every model, agent, and service – for the developer, the team, and the organization.
Supporting multiple models and agents is the floor, not the ceiling. The part that matters is what sits above them: shared context, one set of policies, a single cost view, and a record of what happened, regardless of which vendor produced the change.
Why JetBrains?
Multi-vendor choice solves only part of the problem. Agents also need reliable software intelligence.
JetBrains brings 26 years of engineering intelligence to the problem, helping developers understand the structure and behavior of complex software, not simply generate more of it. That deterministic code intelligence provides a foundation for making agentic work more reliable, efficient, and understandable across different models and agents. We are seeing promising results from giving AI agents access to deterministic code intelligence. 
This is an economic advantage as well as a technical one. Agents spend time and money rediscovering information the codebase already contains. An agent that can retrieve that knowledge is cheaper and more accurate than one that has to reconstruct it. Because intelligence does not belong to one model, the benefit can extend across supported agents and services. 
We are also going through the same transition as the organizations we build for, adopting agents internally, redesigning workflows, and learning where individual productivity gains translate into better software delivery and where they simply move work elsewhere.
What comes next
JetBrains Air will develop through a rolling series of releases. We will be explicit about what customers can use now, what is entering preview, and what remains part of our longer-term direction.
Over time, JetBrains Air will extend further into mobile and remote experiences, allowing people to initiate, monitor, review, and continue agentic work as it moves between environments. The goal is not to reproduce the IDE on every surface. We are making the right context and controls available wherever decisions need to be made. 
We will also bring JetBrains’ intelligence into more agentic workflows. This includes richer context drawn from code, architecture, repositories, runtime behavior, and organizational knowledge, as well as better ways to route work between developers, models, agents, and services.
More work will be triggered by repository events, schedules, and delivery processes rather than by a developer opening an editor and issuing a prompt. JetBrains Air will provide the intelligence, oversight, and human control these workflows require across surfaces and services.
We will not name future products before their scope and availability are ready to be confirmed. With each release, we will explain what works, how it connects, and what’s still in progress.
Where JetBrains Air is going
The companies that succeed in adopting AI will not necessarily be those that generate the most code or deploy the most agents. They will be those that can expand experimentation without losing quality, context, cost discipline, or human understanding.
JetBrains Air is our commitment to building for that reality. It expands JetBrains from the developer workbench into a system of products connecting developers, agents, teams, and organizations.
The goal is not more code. It is software that developers, teams, and organizations can understand, verify, and stand behind.

Explore JetBrains Air

Share
Facebook
Twitter
Linkedin

Prev post Why Focus Matters in a Crowded DevOps Landscape

Subscribe to JetBrains Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!

Discover more

JetBrains AI for Teams and Organizations: From Fragmented AI Usage to Coordinated Software Development

We’re about to start rolling out a new set of AI capabilities that provide shared context, reusable agentic workflows, organization-level governance, and cost control for software production.

Developers use different AI tools depending on the task – from JetBrains IDEs to terminal-based agents su…

Oleg Koverznev

Your JetBrains IDE Expertise, Now on LinkedIn

Connect your IDE to your LinkedIn profile and showcase your JetBrains IDE expertise based on real tool usage.

Ekaterina Ryabukha

Introducing the Cloud9 JetStream Theme for JetBrains IDEs

Meet Cloud9 JetStream: a custom theme for JetBrains IDEs inspired by Cloud9’s visual identity, built for fans and everyday coding.

Elena Kerpeleva

JetBrains Blog RSS Support Is Now Generally Available

We're excited to announce that RSS feed support for blog.jetbrains.com and all JetBrains product blogs is now generally available.

Anastasiia Korzhova

Privacy & Security
Terms of Use
Legal
Genuine tools

Twitter

Facebook

Linkedin

Instagram

Youtube

RSS

Tiktok

Merchandise store iconMerchandise store

Copyright © 2000 JetBrains s.r.o.

Agentic development is reshaping the software creation process, yet the cost associated with errors remains a critical factor. JetBrains has developed JetBrains Air, an open, coherent system of products designed to manage the entire agentic workflow for developers, teams, and organizations, extending beyond the traditional focus on the individual developer workbench provided by IDEs. This evolution stems from earlier experimental work with agentic development environments and the introduction of JetBrains Central, which served as an open system for control and execution.

JetBrains Air is conceived as a multi-surface and multi-service system that interconnects disparate products to manage the initiation, execution, coordination, review, and governance of agent-driven activities. The core philosophy of Air is that the future of agentic development will be multi-vendor, necessitating a design that connects various tools and agents rather than being tethered to a single vendor’s offering. This requires Air to function as a system connecting individual work, team coordination, organizational control, context, and process automation.

The system is composed of several integrated products. Air in JetBrains IDEs provides a complete experience for directing and verifying agents through the use of JetBrains’ code intelligence capabilities. Air Teams addresses the need for coordinating and automating software delivery workflows that involve both human developers and autonomous agents. Air Governance, formerly JetBrains Central, focuses on establishing organizational policies, ensuring visibility, auditability, cost management, and accountability for AI-assisted and agent-driven development across the enterprise. A foundational element enabling this flexibility is the Agent Client Protocol (ACP), which standardizes the connection between an IDE and a full agent harness, including its planning, logic, tools, model routing, and observability, allowing developers to discover and utilize compatible agents.

The necessity for this system arises from a fundamental shift in the bottleneck of software development. While the generation of code has become cheaper, the challenge has shifted to understanding, verifying, and owning the results. As agents assume more execution tasks, the focus moves from producing changes to ensuring the correctness and accountability of those changes. This environment creates fragmentation at the organizational level, making it difficult to measure, govern, and audit agent activity, especially regarding data access, review processes, and cost attribution across different tools and services.

JetBrains Air addresses this fragmentation by providing a unified layer of control above various agents, models, and tools. The system ensures that shared context, unified policies, a single cost view, and a clear record of provenance are maintained, irrespective of which specific agent or service was utilized. JetBrains contributes to this system by providing 26 years of engineering intelligence, offering deterministic code intelligence that enhances the reliability, efficiency, and understandability of agentic work across different models. This intelligence offers an economic advantage, as agents can leverage existing code knowledge more efficiently, regardless of the downstream agent or service.

Looking forward, JetBrains Air is designed to evolve through a series of releases, expanding into mobile and remote experiences to provide context and control wherever decisions are made, rather than replicating the IDE across all surfaces. Future developments will focus on integrating richer context drawn from code, architecture, and runtime behavior, and on triggering agentic workflows through repository events and delivery processes rather than solely through developer prompts. Ultimately, JetBrains Air aims to support the reality of AI adoption by focusing not on generating more code, but on creating software that developers, teams, and organizations can fully understand, verify, and stand behind.