JetBrains Air Evolves: The Rise of the Agentic Development Environment

In the rapidly shifting landscape of software engineering, the definition of an Integrated Development Environment (IDE) is undergoing a fundamental metamorphosis. JetBrains, a titan in the developer tools industry, has released a significant update to JetBrains Air, its dedicated agentic development environment. This release represents a pivotal shift in how AI-driven coding agents interact with local codebases, effectively transforming Air into an orchestration layer for the modern, multi-agent development stack.

With this update, JetBrains is no longer just offering a tool; it is defining a new workflow. By embracing the Agent Client Protocol (ACP), Air now functions as a universal command center, allowing developers to plug in their preferred AI agents—whether enterprise-approved tools like GitHub Copilot or open-source solutions like Cline and OpenCode—into a unified, sandbox-controlled workspace.

The Core Evolution: A Universal Agent Orchestrator

The central philosophy behind the new Air release is "choice through standardization." Previously, developers were often locked into the specific AI integrations provided by their IDE vendor. If a company mandated the use of GitHub Copilot for security or compliance reasons, developers were often forced to abandon more experimental or feature-rich agentic environments.

JetBrains has dismantled this barrier by championing the Agent Client Protocol (ACP), an open-source standard developed in collaboration with Zed. By supporting ACP, Air acts as a host that provides the "harness"—the essential infrastructure for parallel task execution, workspace sandboxing, and human-in-the-loop review—while offloading the intelligence to the agent of the developer’s choice.

Chronology of the Air Ecosystem

• Initial Launch: JetBrains introduced Air as an experimental agentic environment designed to isolate AI tasks in parallel workspaces.
• The Shift to Interoperability: Recognizing that the AI agent market is highly fragmented, JetBrains prioritized the development and adoption of the Agent Client Protocol.
• The July 2026 Update: The current release marks the transition from a closed system to an open, extensible platform, adding support for external agents, local LLM runners, and deep IDE-engine integration for Java and Kotlin.

Supporting Data: Why "Agentic" Matters

The shift toward agentic workflows is supported by a growing consensus in software engineering: AI should not just be a chatbot in a sidebar; it should be an actor capable of executing tasks. Air’s architecture is built on three pillars that address the limitations of traditional AI coding assistants:

1. Parallelism: Unlike standard plugins that operate sequentially, Air creates separate, isolated workspaces for each agent, allowing multiple tasks to run concurrently without corrupting the main codebase.
2. Safety & Review: Every change proposed by an agent is subjected to a human-gated review process. Developers can inspect full-file diffs in the "Proposed Change" tab before authorizing any commit.
3. Context Management: By integrating directly with the IntelliJ IDEA engine, Air provides agents with a semantic understanding of the project, including symbol resolution and cross-file navigation, which reduces "hallucination" errors significantly compared to plain-text LLM prompts.

Official Perspectives and Technical Implications

JetBrains’ leadership and engineering teams have positioned this release as a necessary evolution to keep pace with the "Bring Your Own Agent" (BYOA) trend.

The Enterprise Compliance Angle

One of the most significant implications of this update is how it solves the "Enterprise Dilemma." Many corporations have rigid security policies regarding AI. By connecting the GitHub Copilot CLI via ACP, developers can now maintain enterprise-grade security protocols while utilizing Air’s advanced task management and review workflows. This effectively bridges the gap between organizational security requirements and the high-productivity potential of agentic AI.

Language Intelligence: The IntelliJ Advantage

Perhaps the most technically impressive addition in this update is the beta integration of the IntelliJ IDEA code engine for Java and Kotlin. This moves Air from a generic text-manipulation tool to a language-aware developer environment.

When an agent performs a task, it is no longer just guessing based on syntax; it is utilizing the same deep-code analysis engine that powers IntelliJ IDEA. This allows the agent to:

• Jump to definitions and find usages with perfect accuracy.
• Identify compilation errors and warnings in real-time.
• Understand complex refactoring patterns that require cross-file awareness.

For developers working in large-scale Java/Kotlin ecosystems, this feature is transformative. It allows for the automation of complex refactoring tasks that were previously too risky for autonomous agents to handle.

Local Models: Privacy and Performance

The inclusion of support for local model runners—such as Ollama and LM Studio—addresses the increasing demand for data sovereignty. For developers working on proprietary or highly sensitive code, the ability to run an agentic harness against a local model ensures that no code ever leaves the local machine. This capability, combined with Air’s sandboxed environment, creates a "fortress" for AI-assisted development.

Implications for the Future of Software Engineering

The release of Air suggests that the future of coding is not in the "model," but in the "harness." As LLMs become commoditized, the real value for developers lies in the environment that can manage those models.

1. The Death of Monolithic Tooling

We are witnessing the end of the monolithic IDE era. Instead, we are moving toward a modular ecosystem where the "Editor" (like VS Code or IntelliJ), the "Model" (Claude, GPT, or Llama), and the "Harness" (Air) are separate, interoperable components. JetBrains is effectively betting that by providing the best harness, they will remain the primary hub for developers, regardless of which LLM wins the intelligence race.

2. Increased Automation of Technical Debt

With the ability to run tasks in Docker containers (now supported on Windows, following macOS), Air makes it easier for agents to handle "dirty" work—such as dependency updates, environment configuration, or large-scale legacy code migrations—in isolated environments. This is likely to accelerate the rate at which development teams can tackle long-standing technical debt.

3. Human-Agent Collaboration Standards

The introduction of "effort levels" (such as the new "xhigh" setting for Claude) and detailed token usage monitoring indicates that AI is no longer a "black box." Developers are becoming "Agent Managers," responsible for tuning the reasoning capabilities and resource consumption of their digital subordinates.

Conclusion: A New Standard for Agentic Development

The latest release of JetBrains Air is a bold declaration of intent. By opening its platform to external agents, embracing open protocols like ACP, and doubling down on deep language intelligence, JetBrains has provided a framework that feels both mature and future-proof.

For the professional developer, the choice is clear: as agents become more capable, the primary concern shifts from whether they can code to how we control, review, and integrate their contributions. With this update, Air has provided a sophisticated, robust, and enterprise-ready answer to that question. Whether through the use of local models for privacy or the leveraging of company-approved agents for compliance, Air is positioning itself to be the operating system for the next generation of software development.

As the industry continues to iterate, the ability to orchestrate, monitor, and refine agentic workflows will separate the high-velocity engineering teams from the rest. With Air, JetBrains is providing the tools to lead that transition.