Pimp My IDE / garage dispatch
Back to the garage
October 6, 2026 | IDEs / agent sessions / control

Your IDE is the tower now.

JetBrains Air brings several coding-agent sessions into one IDE view. The useful part is not another chat box. It is the chance to put each session's worktree, provider route, spend, and review owner where you can see them.

Parallel work needs visible lanes, not a bigger prompt window.
Gate 01Agent named
worktree named
Gate 02Provider known
budget named
Gate 03Diff waiting
owner named
Gate 04Parked
no assignment
3 active / review not complete

Air is a control room, not an agent.

JetBrains opened the Early Access Program for Air in its IDEs on October 1. The plugin can connect Codex, Gemini, GitHub Copilot, Claude Agent, Junie, and other agents that support the Agent Client Protocol. JetBrains says Air ships with no agent installed and is not an AI provider.[1][2]

That distinction is useful. The IDE can show sessions, changed files, outgoing commits, diffs, and cost. The agent still executes the task. The provider still receives the requests covered by its own agreement. A local or cloud worker still owns the process and files. Air can make those routes easier to inspect, but the window does not merge them into one trust boundary.

A unified screen is not unified custody.

Parallel sessions move the hard part.

Chat puts one conversation in front of you. Air is designed to track several sessions across projects. JetBrains also offers temporary worktrees so sessions can start on separate branches or detached work, then return through a cherry-pick.[1]

That is the right mechanical shape. The review problem grows with every active session. One session can be waiting for an answer while another changes a database migration and a third spends against a different provider account. The operator needs a short session manifest before those lanes blur together.

ACP connects the editor and agent.

The Agent Client Protocol standardizes communication between code editors and coding agents. Local agents can run as editor subprocesses over JSON-RPC on standard input and output. Remote support uses HTTP or WebSocket, but the ACP documentation says full remote-agent support is still in progress. ACP also reuses Model Context Protocol representations where practical and adds coding-interface types such as diffs.[3]

Protocol support reduces custom integration work. It does not choose your approval policy, cap spend, isolate branches, or decide when a patch is safe to land. Those remain operating rules.

Make each session carry a tag.

Before dispatch, record five things: the task, agent and provider, execution location, branch or worktree, and the person who accepts the result. Add a spend stop if the route can bill by token or time. Save the outgoing revision and incoming commits. Review the diff in the IDE, then run the checks that match the changed system.

JetBrains already exposes project knowledge to agents through IDE skills in Rider. Its 2026.2 release documents skills for profiling, test placement, code-quality hooks, and framework work.[4] That can make the agent better informed. It does not turn an inspection or a profiler hint into a passing build.

Interactive makeover / parallel-session manifest

Air session apron

Traditional purpose replaced: a flat list of agent chats. Better version: set the active load, choose the fields every session must carry, and copy a dispatch card that keeps acceptance work open.

Set loadTag lanesReview diffsAccept patch
Set active session load
Concurrent sessions3 sessions
1 session4 sessions

This count sizes the planning card. It does not start an agent or measure safe capacity.

Include session interlocks

These controls select fields for a planning template. They do not inspect a live Air session, verify isolation, read provider terms, or review a patch.

3 sessions planned2 of 4 field groups selected

The planning card covers isolation and route identity. Budget and review fields are still missing.

3 sessions are planned. 2 of 4 field groups are selected.

Sources read

Source log and evidence boundary
  1. JetBrains, "A New Agentic Experience: JetBrains Air in IDEs - EAP Now Open", October 1, 2026, read October 6, 2026. It describes the EAP, supported agents, session view, worktrees, cost display, provider routing, cloud availability, data path, and disable control. Product claims remain JetBrains claims unless attributed otherwise.
  2. JetBrains Marketplace search for Air, read October 6, 2026. The maintained listing identifies JetBrains as publisher, describes the plugin as a workspace for agentic development, and shows a real installable artifact. We did not install the EAP plugin in this run.
  3. Agent Client Protocol introduction, read October 6, 2026. It documents the editor-agent boundary, local standard-input transport, remote transport direction, reuse of MCP representations, and the current remote-support caveat.
  4. JetBrains, "Rider 2026.2", July 22, 2026, read October 6, 2026. It documents IDE skills, profiler and test workflows, code-quality hooks, and supported agent integrations. Performance numbers on that page are vendor measurements and are not used as independent proof here.

Evidence boundary. We read the launch, product, protocol, marketplace, and Rider material. We confirmed that the Marketplace exposes an Air listing, but we did not install the EAP plugin, connect a provider, start a session, or test a worktree. The apron creates a planning template. Real acceptance still needs live session records, exact provider and host details, revision IDs, measured spend, test output, diff review, and a named merge owner.