JetBrains launches Air — a development environment built around AI agents, not code editing

In December 2025, JetBrains did something painful: it killed Fleet, the lightweight IDE it had spent four years building. Fleet never made it past public preview. It went through multiple identity crises — first a lightweight multi-language editor, then an AI-first coding tool — before JetBrains pulled the plug, admitting that “another AI editor would not stand out.”

Three months later, Air emerged from Fleet’s codebase with a fundamentally different thesis. Instead of building yet another editor with an AI sidebar, JetBrains stripped the editor down to a support role and made AI agents the main event. Air isn’t where you write code. It’s where you tell Codex, Claude Agent, Gemini CLI, and Junie what to build, then review what they deliver.

The public preview launched on March 9, 2026, macOS only, and free. Within a week it landed on Product Hunt (128 upvotes on March 16), drew coverage from The Register, InfoWorld, DevOps.com, and DevClass, and ignited exactly the kind of debate you’d expect: Is multi-agent orchestration genuinely useful, or just a demo that looks impressive?

What Air actually does

The pitch is straightforward. You open Air, define a task, point it at specific code — a class, a method, a commit, a single line — and hand it off to an AI agent. While that agent works, you can spin up another task with a different agent. Each runs independently, isolated in its own Git worktree or Docker container so they don’t step on each other’s changes.

This is not autocomplete. It’s not inline code suggestions. Air treats AI agents as coworkers who need their own workspace, their own branch, and their own sandbox. You’re the reviewer, not the typist.

The built-in tooling reflects this. Air includes a terminal, a Git client, and a preview panel — enough to inspect and approve agent output without switching to a full IDE. A notification system lets you bounce between concurrent agent sessions, checking in on progress like a project manager doing rounds.

JetBrains has been explicit about the positioning: Air doesn’t replace IntelliJ, PyCharm, or any of their existing IDEs. It sits alongside them. You use Air for agentic work and your IDE for everything else. That’s a pragmatic admission that complex codebases aren’t ready for purely agent-driven development — but some tasks are.

The Agent Client Protocol bet

One of the more interesting architectural decisions behind Air is its adoption of the Agent Client Protocol (ACP), an open standard JetBrains co-developed with Zed. ACP is essentially a universal adapter between AI agents and development environments, similar in spirit to what the Language Server Protocol did for editor intelligence.

The idea: agents implement ACP once, and they work in any supporting editor. Editors adopt ACP once, and they support every compliant agent. It’s a deliberate bet on interoperability over lock-in — a notable stance from a company that has historically kept its ecosystem pretty tight.

The ACP Agent Registry is already live, listing Claude Code, Codex CLI, GitHub Copilot CLI, Gemini CLI, and others. For Air, this means its agent roster isn’t static. Any agent that adopts ACP can plug in, which could make Air increasingly useful as the protocol gains traction.

If you’ve been following the protocol wars in AI tooling — MCP for model-to-tool connections, ACP for agent-to-editor connections — Air is the first major product to ship with ACP at its core. That alone makes it worth watching, regardless of whether you plan to use Air itself.

Where Air fits in the AI coding landscape

Air enters a market that’s gotten crowded fast. Cursor and Windsurf dominate the “AI-native editor” category. GitHub Copilot is everywhere. And a new wave of multi-agent tools has emerged — GitHub Agent HQ lets you run Claude, Codex, and Copilot agents in parallel, while the OpenAI Codex macOS app turns agent management into a native desktop experience.

Here’s how Air stacks up:

Air vs. Cursor / Windsurf: These are AI-enhanced code editors. You still write code; the AI helps. Air flips that — agents write code, you review. They’re complementary, not competitive. JetBrains seems to understand this, which is why they’re not positioning Air as an IDE replacement.

Air vs. GitHub Agent HQ: Both orchestrate multiple agents, but Agent HQ is tightly integrated with GitHub’s ecosystem (issues, PRs, Actions). Air is editor-agnostic and protocol-driven via ACP. Agent HQ is better for teams already deep in GitHub; Air is more flexible on the agent side.

Air vs. Emdash: Emdash, the Y Combinator-backed open-source tool, supports 21+ agents and adds workflow integrations with Linear, Jira, and GitHub. Air currently lacks these workflow connections — tasks are manually defined. Emdash also runs on all platforms, while Air is macOS-only for now.

Air vs. terminal workflows: Several Hacker News commenters pointed out that you can achieve similar results with multiple terminal windows, each running Claude Code or Codex in separate Git worktrees. It’s scrappier, but it works. Air’s value add is the unified review interface and agent management — whether that’s worth a dedicated app is a matter of taste.

The review bottleneck problem

The most interesting criticism of Air came from the developer community itself. On Hacker News, one comment captured a sentiment shared by many: “Even a single agent is faster at generating code than I am at evaluating its fitness.”

Running four agents in parallel sounds productive. But if the bottleneck is human review — reading diffs, checking logic, testing edge cases — then more agents just means a longer review queue, not faster delivery. As one developer put it: “The reviewing step is the bottleneck, not token generation speed.”

Several developers also noted that Air feels like “just another parallel Claude UI” rather than something that leverages JetBrains’ actual strengths. Where’s the debugger integration? Where are the test runner views? Where’s the deep static analysis that makes IntelliJ legendary? JetBrains’ own Junie agent reportedly taps into the IntelliJ analysis engine, which gives it genuine context that other agents lack — but Air itself doesn’t surface those capabilities.

That said, there are workflows where parallelism genuinely helps. Running one agent on a refactoring task that takes an hour while another writes boilerplate tests is a real use case. The question is whether Air provides enough value over simpler setups (multiple terminals, Git worktrees, dedicated CLI tools to justify its own window on your screen.

Pricing, access, and what’s coming

Air itself is free to download on macOS. Windows and Linux versions are planned for later in 2026.

To use agents through JetBrains’ infrastructure, you need either an AI Pro or AI Ultimate subscription. JetBrains’ own Junie agent starts at $10/month for individuals and goes up to $60/month for enterprise. But Air also supports BYOK (Bring Your Own Key) — plug in your API keys from Anthropic, OpenAI, or Google and you can use Claude, Codex, or Gemini directly without a JetBrains AI subscription.

Cloud execution — running agents in remote isolated sandboxes instead of locally — is in tech preview and expected to go live soon. Team collaboration features are also on the roadmap, starting with shared task refinement before agents get involved.

One gap worth noting: local model support (Ollama, Qwen, etc.) has no ETA. JetBrains has acknowledged it’s “an active topic,” but for enterprise teams with data sensitivity concerns, this could be a dealbreaker.

The Fleet ghost

It’s impossible to talk about Air without addressing Fleet’s shadow. JetBrains spent four years on Fleet, never shipped a stable release, and then shut it down. The official explanation — that maintaining two IDE families “created confusion and diluted focus” — was reasonable, but it left a trust deficit.

Air inherits that uncertainty. It’s in public preview, just like Fleet was for its entire existence. macOS-only, just like Fleet was initially. Backed by bold positioning, just like Fleet was. Developers who invested time in Fleet and got burned are understandably cautious.

The difference, JetBrains would argue, is clarity of purpose. Fleet tried to be everything — lightweight editor, full IDE, AI assistant — and ended up being nothing distinctive. Air has a narrow, specific mission: orchestrate AI agents. Whether that focus is enough to sustain a standalone product or whether it gets absorbed into IntelliJ remains to be seen.

FAQ

How much does JetBrains Air cost?

Air itself is free on macOS. Using JetBrains’ AI infrastructure requires an AI Pro or AI Ultimate subscription. The Junie agent costs $10-60/month depending on the plan. Alternatively, you can bring your own API keys from Anthropic, OpenAI, or Google and skip the JetBrains subscription for third-party agents.

What AI agents does JetBrains Air support?

Air currently supports four agents: OpenAI Codex, Anthropic’s Claude Agent, Google’s Gemini CLI, and JetBrains’ own Junie. Through the Agent Client Protocol (ACP), additional agents can be added as they adopt the standard.

Is JetBrains Air available on Windows and Linux?

Not yet. The public preview is macOS-only. JetBrains has confirmed that Windows and Linux versions are planned for 2026 but hasn’t given specific dates.

Does JetBrains Air replace IntelliJ IDEA?

No. JetBrains has positioned Air as a complement to its existing IDEs, not a replacement. Air handles agent-powered task delegation; IntelliJ, PyCharm, and others handle traditional coding workflows.

How does JetBrains Air compare to Cursor?

They solve different problems. Cursor is an AI-enhanced code editor where you write code with AI assistance. Air is an agent orchestrator where AI agents write code and you review the output. Many developers will likely use both — or pair Air with their existing JetBrains IDE.

Top AI Product