JetBrains Air Explained: An Agent Client, Not a New Model

2026-10-02
Brian

· Updated
Subscribe
Get New Posts by Email
New RepoSquare posts in your inbox: comparisons, setup guides and explainers on open-source tools and AI coding agents. No spam, and you can unsubscribe anytime.

JetBrains Air in IDEs is a plugin that runs coding agents you already have, such as Codex, Claude Agent, GitHub Copilot, Gemini and Junie, inside IntelliJ IDEA, PyCharm and other JetBrains IDEs. It is not a new AI model and not an AI provider. JetBrains says it “ships with no agents installed.” The plugin’s Early Access Program (EAP) opened on 1 October 2026. JetBrains CEO Kirill Skrygan said general availability would follow in November.

This guide explains where Air sits between the model and you, what the Agent Client Protocol (ACP) actually sends, where your code goes, what costs money, and how to try it safely. Checked on 23 October 2026 against JetBrains’ EAP announcement, the IntelliJ IDEA documentation for Air, and the ACP specification. I also ran two open-source ACP agents on my own machine to capture the real handshake. ACP isn’t the only way to keep two agents apart; ThinkRail vs Cursor gives the second session its own folder instead.

Model, harness and client: the three layers

Simple mindmap of JetBrains Air: client not model, ACP, IDE review, worktrees, own agents

People say “the AI” for three different programs:

LayerWhat it doesExamplesWho you pay
ModelPredicts the next piece of textClaude, GPT, GeminiThe model provider
HarnessRuns the loop: ask the model, call a tool, read the result, ask againClaude Code, Codex, JunieUsually included in the provider plan
ClientThe window that starts the harness and shows its workA terminal, Zed, JetBrains AirAir: free plugin
Three layers: model, harness, and client

Air is the client. When JetBrains says Air “supports Claude”, it means Air can start the Claude harness you installed and show its session in the IDE. JetBrains did not train a model. For the same split from the other side, see Claude Code and Codex on the same model.

Agent loop: ask, tool, read, ask again

What Air adds inside the IDE

Anatomy of an IDE: project tree, editor, search, and checks

According to the documentation and the announcement, Air in IDEs gives you:

  • Agent sessions as units of work. You can run several in parallel and see progress, changed files, commits and cost per session.
  • A global prompt. Double-tap Ctrl anywhere to start a session with your current context attached.
  • IDE context for the agent. You can attach files, commits, screenshots and skills, and supported agents get IDE tools for debugging, profiling, database work and semantic search.
  • Review tools. These include session summaries, line notes on diffs, sending your local changes to an agent for review, and merge-conflict help.
  • Presets that save an agent, model, effort level and access level under a name.
  • Temporary Git worktrees for parallel sessions, with results cherry-picked back.
  • Cloud runs through Air Teams. These need a JetBrains AI subscription and are for organisations with AI seats.

The plugin works with IntelliJ-based IDEs from version 2026.2 and is also built into the 2026.3 EAP builds. The documentation says it “does not enable AI features automatically, and it requires no login until you start an agent.”

What ACP looks like on the wire

ACP is an open protocol. Editors and agents exchange JSON-RPC 2.0 messages over standard input and output. The editor starts the agent as a subprocess, and no network port is needed for that local conversation. To see what Air actually sends, I wrote a minimal client in Node.js (about 30 lines) and ran it against two open-source ACP adapters from npm: @zed-industries/codex-acp 0.16.0 and @zed-industries/claude-code-acp 0.16.2. I used no credentials and an empty home directory.

ACP flow between JetBrains Air client and an agent harness
// Minimal ACP client: start an agent as a subprocess, speak JSON-RPC 2.0 over stdio.
import { spawn } from "node:child_process";
const [cmd, ...args] = process.argv.slice(2);
const agent = spawn(cmd, args, { stdio: ["pipe", "pipe", "ignore"], env: { PATH: process.env.PATH, HOME: "/tmp/acp-home" } });
let buf = "", id = 0; const waiting = new Map();
agent.stdout.on("data", (d) => {
  buf += d; let i;
  while ((i = buf.indexOf("\n")) >= 0) {
    const line = buf.slice(0, i); buf = buf.slice(i + 1); if (!line.trim()) continue;
    const msg = JSON.parse(line);
    if (msg.id !== undefined && waiting.has(msg.id)) { waiting.get(msg.id)(msg); waiting.delete(msg.id); }
  }
});
const call = (method, params) => new Promise((res) => {
  const m = { jsonrpc: "2.0", id: ++id, method, params };
  console.log(">>", JSON.stringify(m)); waiting.set(id, res);
  agent.stdin.write(JSON.stringify(m) + "\n");
});
const show = (r) => console.log("<<", JSON.stringify(r, null, 1).slice(0, 1500));
show(await call("initialize", { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false } }));
show(await Promise.race([call("session/new", { cwd: "/tmp/acp/demo-repo", mcpServers: [] }),
  new Promise((r) => setTimeout(() => r({ timeout: "no reply in 20s" }), 20000))]));
agent.kill(); process.exit(0);

The Codex adapter’s reply to initialize lists what it can do and how it can be signed in. Then it refuses to open a session:

"agentInfo": { "name": "codex-acp", "title": "Codex", "version": "0.16.0" },
"authMethods": [
  { "id": "chatgpt", "name": "Login with ChatGPT",
    "description": "Use your ChatGPT login with Codex CLI (requires a paid ChatGPT subscription)" },
  { "type": "env_var", "id": "codex-api-key", "name": "Use CODEX_API_KEY", ... },
  { "type": "env_var", "id": "openai-api-key", "name": "Use OPENAI_API_KEY", ... }
]
>> {"jsonrpc":"2.0","id":2,"method":"session/new","params":{"cwd":"/tmp/acp/demo-repo","mcpServers":[]}}
<< { "jsonrpc": "2.0", "error": { "code": -32000, "message": "Authentication required" }, "id": 2 }

The Claude Code adapter accepted session/new before any login. It returned a session ID, a model list and five permission modes. The login is only needed once a prompt goes to the model.

"authMethods": [ { "description": "Run `claude /login` in the terminal",
                   "name": "Log in with Claude Code", "id": "claude-login" } ]
...
"modes": { "currentModeId": "default", "availableModes": [
  { "id": "default", "description": "Standard behavior, prompts for dangerous operations" },
  { "id": "acceptEdits", "description": "Auto-accept file edit operations" },
  { "id": "plan", "description": "Planning mode, no actual tool execution" },
  { "id": "dontAsk", "description": "Don't prompt for permissions, deny if not pre-approved" },
  { "id": "bypassPermissions", "description": "Bypass all permission checks" } ] }

This test shows three things. First, the agent decides how you sign in, not Air. Second, the permission modes belong to the harness, so an access-level preset in Air maps onto modes the agent itself offers. Third, an agent can start a session without credentials, but it can’t do any model work. The model labels in that adapter’s reply came from the version bundled in the npm package and may trail the current models. I trimmed the output above with “…” for length. The full output is in the test log.

Where your code goes

Data path: local ACP pipe versus model provider versus cloud runs

JetBrains’ announcement answers three questions directly:

SituationWhere data goes
No agent signed in“nothing runs, and no data leaves your machine”
Third-party subscription (e.g. OpenAI, Anthropic)“directly to that provider under the agreement you already have”; it “doesn’t pass through JetBrains”
JetBrains AI planJetBrains AI Terms of Service, as with AI Assistant; Air adds no new data terms
Cloud runs (Air Teams)A JetBrains-managed cloud environment; requires a JetBrains AI subscription

The local ACP pipe is not the privacy boundary. Your prompt and the files the agent reads still go to the model provider. Air changes which window you watch, not who processes your code.

Whether IDE tools really save tokens

At launch, JetBrains said only that IDE tools can help agents “use fewer tokens” on some tasks. It gave no figure. In October, JetBrains published a Netflix case study. Netflix plugged a headless version of JetBrains’ code-intelligence engine into Claude Code and Codex and benchmarked it on two Java/Kotlin codebases in July and August 2026. The result was “typically 20–30% more efficient (fewer tokens, less time), and up to about 65% in the best case.” The gain was larger for stronger models and higher effort settings.

That study did not test Air. It tested the same engine through a daemon and CLI that Netflix built itself, on JVM code where agents otherwise have to dig through compiled JAR libraries. Treat 20–30% as a plausible range for Java and Kotlin projects, not a promise for a Python or TypeScript repo in Air. To measure your own savings, run the same task twice with identical settings and compare the per-session cost Air shows.

Running parallel agents with worktrees

Git worktrees keep parallel agent sessions from overwriting each other

Air can start each session in a temporary Git worktree. A worktree is a second working folder attached to the same repository, so two agents editing at once don’t overwrite each other’s files. You can do the same thing by hand in any repository:

git worktree add -b agent/fix-login ../repo-fix-login main
git worktree list
# when finished, after merging or cherry-picking:
git worktree remove ../repo-fix-login
git branch -d agent/fix-login

For a broader setup that runs two harnesses side by side, see Claude Code and Codex together. To record which agent wrote which lines once several are committing, see git-ai vs Scion.

What JetBrains Air costs

  • The Air plugin: free.
  • Your agents: billed by their providers under your existing subscriptions. Claude subscriptions work in Air’s terminal surface, which opens as a full-screen IDE tab.
  • Junie Lite: free runs after signing in with a JetBrains Account. JetBrains notes that “terms and available models may change.”
  • Cloud runs: need a JetBrains AI subscription.

One plugin conflict to know about: if you install Air from the notification in AI Assistant, AI Assistant is disabled so the two don’t run side by side. You can re-enable it in Settings → Plugins.

How to try Air without risking your repository

  1. Install Air from JetBrains Marketplace rather than through the AI Assistant prompt, if you want to keep AI Assistant on.
  2. Open a throwaway branch, or a clone of a small project.
  3. Start one agent you already pay for, at its most restrictive access level, the equivalent of the “default” mode in the handshake above.
  4. Give it a bounded task, such as one failing test, and review the diff with the IDE’s navigation and inspections before accepting.
  5. Try a second session in a worktree only after the first one behaves.
  6. To remove Air, disable the plugin. JetBrains says “nothing else changes.”
Decision guide: try JetBrains Air or skip it

When to skip JetBrains Air

Skip Air if your editor isn’t a JetBrains IDE, since it doesn’t come with you to VS Code or Cursor. Skip it if a terminal and git diff already cover your review needs. Skip it if you need a stable release today, because this is an EAP that JetBrains says will have “rough edges, and frequent updates.” For a terminal-first workflow with fast search, xerj vs grep covers the search side.

Common questions about JetBrains Air

Is JetBrains Air a new AI model?

No. It is a client inside the IDE that runs agents such as Codex, Claude Agent, Copilot, Gemini or Junie, plus other ACP-compatible agents from the agent registry.

Do I need a JetBrains AI subscription?

Not for local agents with your own subscriptions. You do need one for cloud runs, and Junie Lite needs a JetBrains Account.

Does my code go to JetBrains?

With a third-party provider, JetBrains says data goes directly to that provider and does not pass through JetBrains. With no agent signed in, nothing leaves your machine.

Which IDE versions support Air?

IntelliJ-based IDEs from 2026.2 via the Marketplace plugin, and the 2026.3 EAP builds with Air built in.

Get New Posts by Email
New RepoSquare posts in your inbox: comparisons, setup guides and explainers on open-source tools and AI coding agents. No spam, and you can unsubscribe anytime.

5 comments

Leave a comment