# JetBrains Launches JetBrains Air EAP Across IDEs to Deliver Open Multi-Agent Workbench for Parallel Software Development

Source: TechNewsList (https://technewslist.com)
Canonical URL: https://technewslist.com/en/article/jetbrains-launches-jetbrains-air-eap-agentic-ide-workbench-2026-10-09-night
Section: Software (https://technewslist.com/en/software)
Author: TechNewsList
Language: en
Published: 2026-10-09T17:22:20.386+00:00
Updated: 2026-10-09T17:22:20.616104+00:00

> JetBrains released the Early Access Program for JetBrains Air across its IDEs, introducing an open multi-agent workbench implementing the Agent Client Protocol.

## TL;DR
- JetBrains launched the Early Access Program for JetBrains Air across its 2026.3 IDE product line on October 1, 2026.
- Functions as an open agentic workbench allowing developers to run and monitor multiple coding agents in parallel.
- Implements the open Agent Client Protocol (ACP), supporting external agents including Claude, Codex, Gemini, and Cursor.
- Eliminates vendor lock-in by supporting personal API keys and third-party subscriptions without proprietary fees.
- Includes Air Teams for shared cloud execution environments and Air Governance for enterprise spending and policy management.

## Key points
- Transitions developer tooling from single-turn code generation to asynchronous multi-agent task orchestration.
- Isolates concurrent agent workflows into dedicated background Git worktrees to prevent uncommitted file collisions.
- Provides a unified IDE dashboard tracking real-time agent execution progress, diff reviews, token consumption, and API expenses.
- Ships with Junie Lite as an included base agent alongside out-of-the-box connectors for leading commercial AI providers.
- Air Teams allows engineering organizations to automate recurring background workflows like PR triage and security audits.
- Available immediately as an IDE marketplace plugin and bundled into all 2026.3 EAP IDE distributions.

## What happened

In a major reimagining of how professional software engineers interact with autonomous artificial intelligence, developer tooling giant JetBrains officially launched the Early Access Program (EAP) for JetBrains Air across its comprehensive ecosystem of integrated development environments. Announced on October 1, 2026, JetBrains Air is engineered not as another proprietary code completion chatbot, but as an open, vendor-neutral workbench designed specifically to orchestrate, supervise, and coordinate multiple autonomous coding agents operating concurrently within a single developer environment.

The system is available immediately as an IDE plugin on the JetBrains Marketplace and natively bundled within the 2026.3 EAP builds of IntelliJ IDEA, PyCharm, WebStorm, CLion, and GoLand. Instead of locking developers into a closed walled garden or requiring a mandatory proprietary AI subscription, JetBrains designed Air around the newly introduced Agent Client Protocol (ACP)—an open architectural specification that enables third-party coding agents to communicate bidirectionally with the IDE. Through ACP, developers can seamlessly connect external autonomous agents from providers including Anthropic (Claude Agent), OpenAI (Codex), Google (Gemini), and Cursor, running them alongside JetBrains’ own built-in agent, Junie.

Alongside the desktop IDE integration, JetBrains outlined the broader JetBrains Air ecosystem, introducing two complementary enterprise tiers: Air Teams and Air Governance. Air Teams provides cloud-hosted shared workspaces where development teams can offload long-running agentic tasks—such as comprehensive unit test generation, cross-repository dependency refactoring, and automated code review triage—into pre-configured cloud containers. Meanwhile, Air Governance equips enterprise engineering directors with centralized observability, budget enforcement, and compliance telemetry to monitor token consumption and model usage across global development organizations.

## Why it matters

The launch of JetBrains Air directly tackles the operational chaos that has emerged as software developers increasingly integrate autonomous AI agents into daily development workflows. Over the past eighteen months, AI coding tools have rapidly progressed from simple inline autocomplete suggestions to complex multi-file autonomous agents capable of modifying dozens of files simultaneously. However, running these agents within standard editor buffers often creates severe file lock conflicts, clobbers active working trees, and leaves developers with sprawling uncommitted diffs that are tedious and error-prone to audit manually.

![Enterprise software development centers deploy open agentic protocols to orchestrate collaborative multi-agent coding pipelines](https://rkhynbcsbnkkcwgexzwg.supabase.co/storage/v1/object/public/media/api/1791566529766-rr8owp-jetbrains-launches-jetbrains-air-eap-agentic-ide-workbench-2026-10-09-night-inside-1-8348b30f02.webp "Enterprise software development centers deploy open agentic protocols to orchestrate collaborative multi-agent coding pipelines.")

By elevating the IDE into an agentic workbench, JetBrains Air introduces structured process discipline to autonomous coding. Developers no longer have to wait passively while a single agent completes a complex task. Instead, an engineer can dispatch multiple agents simultaneously: assigning one agent to refactor a legacy database migration in one branch, tasking a second agent with authoring end-to-end integration tests in a separate worktree, while the human developer continues writing business logic in the main editor pane without interruption.

Crucially, JetBrains’ commitment to an open protocol model provides the developer community with vital protection against platform lock-in. While proprietary developer tools frequently force teams to route all queries through their marked-up model gateways, JetBrains Air allows engineers to bring their own API keys or personal subscriptions. This open architecture ensures that teams can immediately adopt newer, more capable frontier reasoning models the day they are released without waiting for IDE vendor permission.

## Technical details

The foundational technical innovation underpinning JetBrains Air is its Git worktree virtualization architecture. When an agent is dispatched to solve an issue, Air automatically provisions an isolated, ephemeral Git worktree running in the background. The agent executes within this isolated sandbox, interacting with language servers, syntax trees, and build tools via the IDE's semantic index without altering the files currently loaded in the developer's visible editor buffer.

Communication between the IDE and external agents is governed by the Agent Client Protocol (ACP). Implemented over JSON-RPC and WebSockets, ACP standardizes essential editor interactions, including semantic code search, symbol lookup, diagnostic reporting, file editing, and test execution. When an agent proposes a set of changes, Air compiles the modifications into a structured review session. The developer is presented with an intuitive three-way merge interface that highlights syntax-aware diffs, test pass/fail statuses, and step-by-step reasoning logs, allowing the engineer to accept, reject, or request revisions on individual hunks before any code touches the primary branch.

![Modern integrated development environments combine local Git branch isolation with asynchronous autonomous agent execution](https://rkhynbcsbnkkcwgexzwg.supabase.co/storage/v1/object/public/media/api/1791566532346-ok7i3f-jetbrains-launches-jetbrains-air-eap-agentic-ide-workbench-2026-10-09-night-inside-2-3588a1a95c.webp "Modern integrated development environments combine local Git branch isolation with asynchronous autonomous agent execution.")

To ensure enterprise-grade security and cost control, the workbench includes comprehensive execution telemetry. The IDE interface features a real-time monitor displaying active model token consumption, elapsed execution time, and cumulative API dollar expenditures for each running agent. In cloud-hosted Air Teams environments, administrators can enforce granular policy boundaries, restricting which internal repositories can be indexed and defining hard budget caps to prevent runaway agent loops.

## Market / industry impact

JetBrains’ strategic entrance into the agentic developer market intensifies its competitive positioning against specialized AI-first code editors such as Cursor and Cognition’s Devin, as well as Microsoft’s GitHub Copilot Workspace. While newer VC-backed editors have gained significant traction by building lightweight forks of VS Code with deeply integrated AI interfaces, JetBrains retains immense structural advantages: decades of deep semantic code analysis engines, industry-leading refactoring tools, and millions of deeply embedded enterprise licenses.

By creating an open workbench rather than attempting to compete directly as an AI model provider, JetBrains neatly sidesteps the brutal capital expenditures and margin pressures associated with training and hosting frontier models. Instead, it positions its IDEs as the indispensable, agnostic operating system for AI software development—the neutral cockpit from which developers orchestrate models from OpenAI, Anthropic, Google, and open-source communities alike.

Furthermore, the establishment of the Agent Client Protocol could serve as a unifying standard for the fragmented AI developer ecosystem. If ACP achieves widespread industry adoption, tool builders and open-source researchers will be able to build specialized coding agents once and deploy them seamlessly across JetBrains IDEs, VS Code extensions, and continuous integration pipelines without maintaining custom editor bindings.

## What to watch next

During the initial Early Access Program throughout late 2026, the primary metric of success will be community adoption and the expansion of the ACP ecosystem. Software analysts will watch how quickly third-party agent creators publish certified ACP adapters, particularly whether leading open-source models (such as DeepSeek and Qwen) can match the integration fidelity of commercial frontier APIs within the Air workbench.

Another critical area of evaluation will be the performance footprint of local Git worktree isolation on complex enterprise monorepos. Developers working on massive codebases containing millions of lines of code will scrutinize whether running multiple background agent worktrees causes memory exhaustion or disk I/O bottlenecks on standard developer workstations.

Finally, industry watchers will track the commercial rollout of Air Teams and Air Governance in early 2027. The pricing model JetBrains selects for cloud orchestration and team telemetry will determine how readily corporate IT departments transition from informal individual developer AI usage toward standardized, enterprise-wide agentic engineering pipelines.

## Sources

- [JetBrains Official Blog](https://blog.jetbrains.com/blog/2026/10/01/introducing-jetbrains-air-in-ides-eap/) - Official release announcing JetBrains Air EAP, Agent Client Protocol architecture, multi-agent worktrees, and Junie Lite availability.
- [Daily.dev Developer Insights](https://daily.dev/blog/jetbrains-air-the-open-workbench-for-agentic-software-engineering) - Independent analysis reviewing open ACP protocol integration with Claude Agent, Codex, Gemini, and Cursor alongside cost governance.
- [Laravel News Tooling Overview](https://laravel-news.com/jetbrains-air-agentic-ide-eap-launch) - Community technical coverage examining parallel agent worktree isolation, team governance controls, and IDE 2026.3 compatibility.

Mentions: JetBrains, JetBrains Air, Agent Client Protocol, IntelliJ IDEA, Junie

## Sources
- [JetBrains Official Blog](https://blog.jetbrains.com/blog/2026/10/01/introducing-jetbrains-air-in-ides-eap/)
- [Daily.dev Developer Insights](https://daily.dev/blog/jetbrains-air-the-open-workbench-for-agentic-software-engineering)
- [Laravel News Tooling Overview](https://laravel-news.com/jetbrains-air-agentic-ide-eap-launch)