What’s new: Air gets more agents, local models, and Java/Kotlin code intelligence – The JetBrains Blog

JetBrains Air, the innovative agentic development environment from industry leader JetBrains, has announced a substantial new release, significantly expanding its capabilities with support for a wider array of coding agents, integration of local AI models, and advanced language intelligence for Java and Kotlin. This update, rolling out in 2026, solidifies Air’s position as a flexible and powerful platform designed to streamline developer workflows through autonomous AI agents, pushing the boundaries of what’s possible in AI-assisted software creation. The release introduces compatibility with prominent agents such as GitHub Copilot, OpenCode, Pi, and Cline, alongside IntelliJ-powered navigation and diagnostics for two of the most widely used programming languages, and extends Docker task execution to Windows environments.

The Evolution of Agentic Development and JetBrains Air’s Vision

The year 2026 is proving to be pivotal in the evolution of software development, characterized by an accelerating shift towards agentic AI. This paradigm moves beyond simple code completion or suggestion tools, empowering AI to act as autonomous "agents" that can understand complex tasks, plan execution, interact with development environments, and propose comprehensive code changes. JetBrains, a company synonymous with best-in-class developer tools like IntelliJ IDEA, PyCharm, and WebStorm, entered this burgeoning field with JetBrains Air, envisioned as a dedicated environment where these intelligent agents could operate effectively.

Launched with the promise of transforming development cycles, JetBrains Air distinguishes itself by offering separate, parallel workspaces for coding agents, allowing them to tackle tasks concurrently. This architecture facilitates a structured review process, enabling developers to meticulously examine and approve agent-generated changes before they integrate into the main codebase. From its inception, Air aimed to provide a robust framework for managing the output of AI agents, ensuring quality control and developer oversight. Early iterations of Air supported a curated set of agents, including Claude, Codex, Gemini CLI, and Junie, demonstrating the potential for AI to handle everything from minor bug fixes to substantial feature implementations. However, the burgeoning ecosystem of AI models and agentic frameworks necessitated a more open and adaptable platform, a need directly addressed by this latest release.

Key Innovations: Broadening Agent Compatibility with ACP

One of the most impactful features of this update is the significantly expanded support for a diverse range of ACP-compatible agents. This includes industry giants like GitHub Copilot, along with emerging solutions such as OpenCode, Pi, and Cline. This monumental shift is underpinned by the Agent Client Protocol (ACP), an open standard developed collaboratively by JetBrains and Zed. ACP serves as a universal communication layer, enabling coding agents and development environments to interact seamlessly, eliminating the need for bespoke integrations for each new agent.

The introduction of ACP compatibility marks a strategic pivot towards an open ecosystem, addressing two critical demands from the developer community and enterprise clients. Firstly, it resolves the challenge of corporate standardization. Many organizations mandate the use of specific AI coding tools, often due to security protocols, licensing agreements, or internal best practices. Previously, if a company had standardized on GitHub Copilot, for instance, its developers might have been unable to leverage Air’s unique parallel workspaces and review workflows. Now, with Air’s ability to connect to the GitHub Copilot CLI through its ACP server mode, developers can utilize their company-managed Copilot access within Air. This integration allows Copilot to handle the core coding agent functions and model access, while Air layers on its distinctive parallel workspaces and structured review process, providing an optimal blend of corporate compliance and advanced AI development features. This flexibility extends to any ACP-compatible agent, offering unparalleled freedom for companies to use their approved tools without compromising on advanced agentic capabilities.

Secondly, the update empowers developers with choice over their preferred "agent harness." While a large language model (LLM) forms the intelligence core of an agent, the "harness" is the surrounding software that orchestrates its operations—gathering context, invoking tools, managing tasks, and translating model outputs into actionable code changes. Different harnesses offer distinct approaches to workflow management and support various model providers. With Air now connecting to supported ACP agents like OpenCode and Pi, developers can select a harness that aligns with their specific needs, configuring it with their preferred cloud provider or even a local model. This modularity ensures that the available models and agent-specific features are dictated by the chosen harness, maximizing customization and performance for diverse development scenarios. JetBrains has also provided detailed setup guides, including working acp.json configurations, to facilitate rapid adoption of agents like GitHub Copilot, OpenCode, or Cline with local Ollama models.

Embracing Local Models for Enhanced Privacy and Control

Responding to one of the most fervent requests from its user base, JetBrains Air now fully supports the integration of local AI models. This groundbreaking feature allows developers to utilize models running directly on their local machines through popular model runners such as Ollama or LM Studio. The workflow is elegantly designed: an ACP-compatible coding agent establishes a connection to the local model, and Air, in turn, connects to that agent.

The implications of local model support are profound. It enables developers to conduct AI-assisted development entirely offline, a crucial capability for environments with limited internet access or stringent network security policies. More importantly, it addresses growing concerns around data privacy and security. By processing code and context locally, sensitive intellectual property remains on the developer’s machine, mitigating risks associated with transmitting data to external cloud-based AI services. This is particularly vital for organizations handling proprietary codebases or operating under strict regulatory frameworks. Furthermore, local models offer greater control over customization and performance. Developers can fine-tune models to better suit their specific codebase, task requirements, or computational environment, potentially leading to more accurate and efficient code generation. The ability to choose a model that best fits the project’s unique characteristics—be it size, complexity, or language—adds another layer of flexibility that was previously unavailable with purely cloud-dependent solutions.

IntelliJ-Powered Language Intelligence for Java and Kotlin

Leveraging its deep expertise in language tooling, JetBrains has integrated IntelliJ IDEA’s robust code engine into Air, bringing powerful Java and Kotlin language intelligence (currently in Beta). This addition bridges the gap between agentic development and the rich, context-aware capabilities of traditional Integrated Development Environments (IDEs).

For developers working on Java and Kotlin projects, including mixed-language codebases, this means a significantly enhanced understanding of the code an agent interacts with. Within Air, users can now effortlessly jump to definitions, find usages, search for symbols, and follow complex code paths. This immediate access to code intelligence during task creation is invaluable, allowing developers to provide agents with more precise context, thereby improving the accuracy and relevance of AI-generated solutions. Post-agent execution, Air automatically highlights errors and warnings in the affected Java and Kotlin code. This proactive problem detection empowers developers to inspect and rectify issues before accepting changes, eliminating the need to switch to an external IDE or wait for compilation failures to identify basic syntax or semantic errors. The visual feedback within Air streamlines the review process, ensuring that only high-quality, functional code integrates into the project, further reinforcing the platform’s commitment to developer oversight and code quality.

Cross-Platform Consistency: Docker Tasks on Windows

Enhancing its commitment to cross-platform usability, JetBrains Air now supports running agent tasks in Docker containers on Windows. This crucial update brings Windows users into parity with existing macOS support, ensuring a consistent and isolated development experience across major operating systems. The integration requires Docker Desktop, a widely adopted tool for containerization.

The ability to execute agent tasks within Docker containers offers several significant advantages. It provides an isolated environment for dependencies and agent commands, preventing conflicts with the host system’s configuration. This containerized approach ensures reproducibility, meaning that an agent’s task will run identically regardless of the underlying machine’s setup, which is invaluable for team collaboration and continuous integration/continuous deployment (CI/CD) pipelines. By standardizing the execution environment, developers can minimize "it works on my machine" issues and ensure greater consistency in agent output. This feature is particularly beneficial for complex projects with numerous dependencies or for environments where maintaining a clean, consistent local setup is challenging. JetBrains has made Air available for both x64 and ARM64 Windows architectures, reflecting its dedication to broad hardware compatibility.

Empowering Developers with Greater Control and Visibility

Beyond core functionality, this release introduces several refinements aimed at providing developers with enhanced control and visibility during agent runs:

• Detailed Proposed Changes: When an agent proposes file modifications, developers can now click the file name to open a complete, side-by-side view of the proposed edit in the "Proposed Change" tab. This moves beyond relying on short chat snippets, enabling a thorough inspection of the agent’s intentions and the full scope of its modifications before granting permission, fostering greater trust and accuracy.
• Claude Agent Context Usage: For users leveraging Claude Agent, Air now displays real-time context-window usage and token counts. This invaluable metric helps developers understand how much contextual information Claude is processing, allowing them to recognize when a long task might be approaching its context limit. This insight is crucial for optimizing agent performance, deciding whether to conclude a task, or initiating a new one with a refined scope to avoid token overflow and potential loss of coherence.
• Adjustable Effort Levels for Claude Models: Claude Fable, Opus, and Sonnet 5 now support an "xhigh" effort level. This setting is designed for demanding tasks that require more extensive reasoning and deeper problem-solving capabilities from the AI, allowing developers to fine-tune the agent’s intensity based on the complexity of the problem at hand.
• macOS Sleep Prevention: A practical quality-of-life improvement for macOS users, a new setting prevents the computer from sleeping during long-running agent tasks. This ensures that autonomous operations continue uninterrupted, even when the developer steps away from their machine, enhancing the reliability of extended AI-driven workflows.

Statements and Industry Implications

A JetBrains spokesperson emphasized the company’s commitment to an open, flexible, and powerful agentic development ecosystem. "This release of JetBrains Air is a significant stride towards a future where AI agents are not just assistants, but integral, collaborative partners in the development process," the spokesperson stated. "By embracing open protocols like ACP and empowering developers with local model support and deep language intelligence, we are giving them unprecedented control and flexibility. Our goal is to make AI-driven development accessible, secure, and highly productive for every developer and every enterprise, regardless of their preferred tools or infrastructure."

Industry analysts are quick to recognize the strategic importance of this update. "The move by JetBrains to embrace an open Agent Client Protocol is a game-changer," commented a leading analyst in developer tooling. "It positions Air not just as another AI coding tool, but as a potential hub for the entire agentic development ecosystem. This openness, combined with robust enterprise-grade features like local model support and deep language intelligence for popular languages like Java and Kotlin, makes Air a compelling solution for companies looking to integrate advanced AI into their development pipelines while maintaining control over data and compliance." The analyst further noted that the demand for agentic capabilities is projected to grow exponentially, with the AI coding assistant market expected to reach multi-billion dollar valuations in the coming years, making interoperability and flexibility key differentiators.

The developer community is expected to welcome these changes enthusiastically. The ability to use company-approved agents directly within Air will likely accelerate enterprise adoption, while local model support addresses long-standing privacy and cost concerns for individual developers and smaller teams. The enhanced Java/Kotlin intelligence, leveraging JetBrains’ renowned expertise, will be particularly impactful for the vast enterprise development landscape that heavily relies on these languages.

Broader Impact and Future Outlook

The latest JetBrains Air release heralds a significant step forward in the broader landscape of software development. For individual developers, it translates to increased productivity, the ability to offload mundane or complex tasks to intelligent agents, and more time to focus on creative problem-solving and architectural design. For enterprises, the implications are even more profound: enhanced security and compliance through local model processing, reduced vendor lock-in via ACP, faster development cycles, and the potential to scale development efforts more efficiently by leveraging AI agents.

This update also positions ACP as a strong candidate for a de facto standard in agent interoperability, which could foster a more collaborative and innovative AI development tools market. As AI agents become more sophisticated, the lines between traditional IDEs and autonomous agent environments will continue to blur, leading to entirely new development workflows and paradigms.

However, the advancement of agentic AI also brings challenges. The need for robust human oversight remains paramount, as developers must critically evaluate and debug agent-generated code. Trust in AI systems, managing complex agent interactions, and addressing potential biases in AI models will continue to be critical areas of focus for the industry.

In conclusion, the latest update to JetBrains Air is more than just a feature release; it represents a foundational shift towards a more open, intelligent, and developer-centric future for software creation. By democratizing access to diverse AI agents, prioritizing privacy with local models, and embedding deep language intelligence, JetBrains Air is poised to redefine how developers interact with code, collaborate with AI, and bring innovative software to life. Developers are encouraged to download the latest Air release from air.dev/download or update via JetBrains Toolbox to experience these transformative capabilities firsthand.