JetBrains launched JetBrains Air on September 22, 2026, introducing an open product ecosystem designed to coordinate, execute, and govern multi-agent software engineering workflows across modern development organizations. As JetBrains CEO Kirill Skrygan explained during the announcement, the platform represents an evolution from the company’s traditional focus on isolated developer workbenches toward an integrated framework for orchestrating AI agents across entire engineering teams. While standalone coding plugins can accelerate individual tasks, uncoordinated AI assistants quickly break down when deployed across large repositories, leaving development organizations burdened with fragmented tooling, inconsistent code quality, and unmanaged API costs.
Engineering teams increasingly struggle with fragmented AI tooling, unmonitored API consumption, and restrictive vendor lock-in. The progression from isolated assistant experiments—such as running Claude Agent within PhpStorm’s AI Assistant in PhpStorm 2025.3—to dedicated orchestration infrastructure marks a significant shift in software tooling. Rather than binding an entire engineering organization to a single proprietary model provider, scalable agentic engineering demands an open layer where specialized agents, cloud execution environments, and local IDEs work in unison.
The Three-Product Architecture: IDEs, Cloud Teams, and Centralized Governance
The JetBrains Air suite comprises three dedicated products that span the entire development lifecycle: Air in JetBrains IDEs, Air Teams, and Air Governance. Each product targets a distinct operational layer within an engineering organization, providing local interactive tooling, asynchronous cloud infrastructure, and administrative policy controls.
Air in JetBrains IDEs is currently available in public preview as a free plugin. It integrates directly into developer workstations, enabling engineers to interact with diverse AI models and coding agents, including Claude Agent, Codex, Copilot, Junie, and OpenCode. Air Teams, available in early access, provides shared cloud execution environments designed to handle long-running, asynchronous tasks such as running automated code reviews, executing test suites, and generating release notes. Air Governance represents the institutional management tier, evolving from JetBrains Central (introduced in March 2026) to manage organization-wide model permissions, enforce spending caps, and track real-time usage telemetry.
| Product Tier | Availability & Pricing | Key Capabilities | Primary Target Workflow |
|---|---|---|---|
| Air in JetBrains IDEs | Public Preview (Free plugin) | Local IDE agent execution, ACP compatibility, multi-agent switching (Junie, Codex, Copilot, Claude) | Interactive coding, real-time code completion, local refactoring |
| Air Teams | Early Access | Shared cloud execution environments, asynchronous agent task runner, background task routing | Automated pull request reviews, test triage, release documentation |
| Air Governance | Enterprise Release (evolved from JetBrains Central) | Centralized model whitelisting, team spending caps, token telemetry, security policy enforcement | Institutional compliance, cost control, organizational audit trails |
Separating local execution, asynchronous cloud execution, and central governance addresses a core operational bottleneck in engineering pipelines. Local developer environments must remain responsive and unencumbered by background batch processing. By shifting heavy analytical workloads to Air Teams while maintaining central cost and security controls through Air Governance, technical leaders can prevent shadow AI adoption while maintaining developer autonomy.
The Agent Client Protocol (ACP): Standardizing Open Multi-Agent Interoperability
A central technical foundation of JetBrains Air is the Agent Client Protocol (ACP), an open communication standard co-developed by JetBrains and Zed. ACP standardizes the connection between developer interfaces and AI coding agents, eliminating the custom integration code historically required to hook proprietary assistants into various code editors.
The ACP ecosystem connects multiple development environments—including JetBrains IDEs, Zed, and Neovim—directly to a diverse fleet of specialized agents such as Junie, Codex, GitHub Copilot, Claude Agent, and OpenCode. This standardized interface allows developers to trigger agents across different editors using consistent protocols.
JetBrains has maintained an explicitly model-agnostic stance. As Skrygan stated, JetBrains develops its own proprietary agent, Junie, and aims to optimize its capabilities, but JetBrains Air does not require customers to use it. Furthermore, JetBrains’ strategy does not depend on which model provider leads quarterly benchmark rankings. By decoupling the interface from the underlying model, ACP ensures that organizations can swap backend LLMs or agent architectures as technological breakthroughs occur, insulating engineering pipelines from vendor obsolescence.
Operationalizing Multi-Agent Workflows: Cloud Execution and Asynchronous Tasks
Scaling AI adoption across an engineering organization requires shifting repetitive, compute-heavy engineering steps out of the local IDE into coordinated cloud agents. Air Teams operationalizes this transition by providing headless, shared cloud runtime environments that execute asynchronous background workflows without occupying local machine resources.
In practice, Air Teams allows organizations to offload routine maintenance workflows to background agents. When a pull request is opened, cloud-hosted agents can evaluate the diff against organizational standards, run static analysis checks, verify documentation coverage, and draft comprehensive release notes. The results are submitted back to the repository as structured suggestions, draft commits, or pull request annotations.
This asynchronous architecture fundamentally improves developer hand-off workflows. Human engineers are no longer forced to pause active development while waiting for local agents to run extensive refactoring or validation loops. Instead, developers review agent-generated pull requests within their standard review interfaces, accepting or modifying proposed changes with minimal friction. Running these tasks in shared cloud environments also ensures strict environment parity, eliminating discrepancies caused by divergent local toolchains.
Enforcing Organizational Guardrails with Air Governance
As developer adoption of generative AI tools expands, engineering leaders face mounting concerns regarding unmonitored API spending, compliance, and code privacy. Evolved from the foundation established by JetBrains Central in March 2026, Air Governance provides an administrative control plane to manage institutional agent fleets.
Air Governance equips engineering directors and platform administrators with granular administrative capabilities:
- Budget Caps and Cost Allocation: Setting strict monthly spending limits per team, project, or developer to prevent runaway API billing.
- Model Access Policies: Specifying which foundation models and external agents are approved for enterprise source code, preventing unvetted services from processing proprietary IP.
- Usage Telemetry and Auditing: Recording complete token consumption logs, latency figures, and agent invocation histories across the organization.
These capabilities allow engineering leadership to accurately calculate the return on investment for their AI tooling while satisfying enterprise security requirements. Detailed telemetry reveals which teams derive measurable efficiency gains from specific models, enabling data-backed tooling decisions rather than speculative software purchases.
Evolution Roadmap: Deep Context Routing and Cross-Environment Workflows
JetBrains has outlined a rolling release schedule designed to expand Air beyond traditional desktop IDEs. As the product system develops, JetBrains plans to extend the Air suite into mobile and remote interfaces, allowing engineers to initiate, monitor, and review agentic tasks across different operational environments.
A major technical initiative in JetBrains’ roadmap is deep context routing. Rather than feeding AI models isolated code snippets or shallow prompt context, JetBrains plans to route deep contextual telemetry into agent workflows. This context includes Abstract Syntax Tree (AST) analysis, broader software architecture maps, repository dependency graphs, live runtime behavior, and centralized organizational knowledge bases.
Shallow, prompt-based assistants often hallucinate invalid methods or violate architectural patterns because they lack insight into project-wide dependencies. Providing agents with deep runtime context and repository-level architectural graphs dramatically reduces syntax errors and ensures generated code respects established design patterns.
Implementing Agentic Workflows in Your Development Stack
For engineering teams planning to integrate multi-agent workflows into their existing operations, adopting JetBrains Air requires a phased approach that balances developer flexibility with operational governance.
Step 1: Deploy Air in Local IDEs
Install the free Air plugin across your team’s JetBrains IDE installations during the public preview. Allow developers to test various supported agents—such as Claude Agent, Codex, Copilot, or Junie—to identify which tools excel at specific language ecosystems and tasks.
Step 2: Connect Agents via the Agent Client Protocol
Standardize local toolchains around ACP-compliant agents. Evaluate task performance across different models to determine which agents deliver the highest code accuracy for your stack without locking your team into a single proprietary ecosystem.
Step 3: Establish Baseline Policies in Air Governance
Configure spending caps and approved model lists before rolling tools out across the wider organization. Establishing clear cost boundaries and security parameters early prevents billing surprises and ensures enterprise compliance.
Step 4: Pilot Air Teams on Asynchronous Tasks
Introduce Air Teams into non-critical background pipelines first. Pilot automated pull request reviews, changelog generation, and documentation drafting before assigning background agents to core refactoring or production code generation.
Who Should Adopt JetBrains Air Now vs. Who Should Wait
- Adopt Now: Mid-to-large engineering teams already using JetBrains IDEs that need centralized billing controls, multi-model flexibility, and automated background pull request reviews.
- Wait: Solo developers or small teams with simple workflows who only require a single, basic auto-complete assistant and do not need multi-agent coordination or enterprise governance.
The Future of Protocol-Driven Agentic Engineering
JetBrains Air represents a structural shift in how software engineering organizations deploy generative AI. By pairing an open communication standard (ACP) with dedicated local tooling, cloud execution environments, and institutional governance, the platform bridges the gap between individual developer productivity and enterprise management. As multi-agent engineering workflows mature, open protocols and deep contextual integration will serve as the foundation for scalable, vendor-agnostic software development.
Frequently Asked Questions
What products are included in the JetBrains Air suite?
The suite consists of three products: Air in JetBrains IDEs for local coding workflows, Air Teams for asynchronous cloud execution, and Air Governance for administrative cost and model policy management.
What is the Agent Client Protocol (ACP)?
The Agent Client Protocol (ACP) is an open communication standard co-developed by JetBrains and Zed that standardizes how code editors interact with diverse AI coding agents.
How does Air Governance help control AI spending?
Air Governance provides centralized budget caps per team or project, enforces approved model whitelists, and logs real-time token consumption telemetry to prevent unexpected API costs.
