JetBrains Air entered public preview today — an agentic IDE built on the Fleet codebase that supports running multiple AI coding agents in parallel. If you’ve been following the agentic IDE space and want to get hands-on, this guide walks through installation, initial configuration, and your first parallel agent workflow.

Prerequisites

Before you start, confirm you have:

  • A JetBrains account — Air requires a JetBrains account, even in public preview. Free accounts work during the preview period.
  • JetBrains AI subscription (optional for basic use, required for premium models) — if you want to use Claude or GPT-5 as your underlying model, you’ll need a JetBrains AI subscription. The default model (JetBrains’ own hosted model) is available free during preview.
  • System requirements: macOS 13+, Windows 11, or Ubuntu 22.04+. M1/M2/M3 Mac or Windows ARM is recommended for performance. 16GB RAM minimum, 32GB recommended for larger codebases.

Step 1: Download and Install Air

  1. Go to jetbrains.com/air and click Download Public Preview
  2. You’ll be prompted to log in to your JetBrains account
  3. Download the installer for your platform
  4. Run the installer — Air installs independently from other JetBrains IDEs and does not replace or affect IntelliJ IDEA, PyCharm, or other products

The install is straightforward. Air does not use the JetBrains Toolbox App for management during the preview period — it’s a standalone installer.

Step 2: Open Your Project

Air uses workspace folders rather than project files. To open an existing codebase:

  1. Launch Air
  2. Click Open Workspace on the welcome screen
  3. Select your project root folder

Air will index your codebase on first open. For a medium-sized project (50k–200k lines of code), this takes 2–5 minutes. During indexing, you can start exploring the UI, but agent features won’t be available until indexing completes. A progress indicator in the status bar shows index status.

Step 3: Configure Your AI Model

Air ships with JetBrains’ own hosted model enabled by default. To use Claude or GPT-5:

  1. Open Settings (⌘, on macOS, Ctrl+, on Windows/Linux)
  2. Navigate to AI Assistant → Model Configuration
  3. Select your preferred model from the dropdown
  4. If required, enter your API key or JetBrains AI subscription credentials

For most use cases, Claude 3.7 Sonnet is the recommended starting point — it balances quality and latency well for coding tasks. GPT-5.3-Codex is worth evaluating if your work is heavily code-generation-focused.

Step 4: Your First Single-Agent Task

Before jumping to parallel agents, get familiar with Air’s single-agent workflow. It’s different from other IDEs in a few ways.

Open the Agent Panel by pressing ⌘⇧A (macOS) or Ctrl+Shift+A (Windows/Linux), or clicking the robot icon in the right sidebar.

Type a task in natural language. Example:

Refactor the UserAuthService class to use the new TokenManager interface. 
The interface is defined in /src/auth/TokenManager.java.

Air will:

  1. Parse your instruction and generate a step-by-step plan
  2. Show you the plan before executing — this is important. Review it. The plan step is your opportunity to catch misunderstandings before the agent touches code.
  3. Execute the plan, showing each step as it completes
  4. Present a diff of all changes before applying them

You can accept, reject, or modify the proposed changes at the diff review stage. Never skip the diff review on your first few tasks — this is where you’ll calibrate Air’s understanding of your codebase conventions.

Step 5: Running Parallel Agents

Parallel agents are Air’s headline feature. Here’s how to use them effectively.

In the Agent Panel, click the + New Agent button (or press ⌘⇧N / Ctrl+Shift+N) to open a second agent context alongside the first. You’ll see a tabbed interface with Agent 1 and Agent 2.

A task well-suited for parallel agents:

Agent 1: Refactor UserAuthService to use TokenManager interface
Agent 2: Write unit tests for the new TokenManager interface contract

These tasks are parallelizable because Agent 2 doesn’t depend on Agent 1’s output — it can work against the interface definition directly. Tasks that are sequential dependencies shouldn’t be parallelized.

To dispatch both agents simultaneously:

  1. Set up the task in each agent tab
  2. Click Run All in the toolbar, or press ⌘⌥↵ (macOS) / Ctrl+Alt+Enter (Windows/Linux)

Air will run both agents concurrently. Each agent’s output appears in its own tab. When both complete, you’ll review two separate diffs before applying any changes.

Important: Air does not automatically merge parallel agent changes. You review and apply each agent’s work separately. This is intentional — merging concurrent edits to the same codebase is complex, and Air puts that judgment in your hands.

Step 6: Agent Memory and Context Windows

For large codebases, effective agent use requires understanding how Air manages context.

Air uses an adaptive context window that selects the most relevant files for each task. You can inspect what’s in the agent’s context by clicking the context indicator (file stack icon) in the agent panel header.

If an agent is missing relevant context:

  1. Click the + Add Context button in the agent panel
  2. Select files, folders, or symbols to add explicitly
  3. The agent will incorporate this additional context in its next action

For projects with complex cross-cutting concerns, explicitly seeding the agent’s context with relevant architecture documents or interface definitions significantly improves output quality.

Tips for Production Use

Start with read-only tasks until you’ve calibrated the agent’s understanding of your codebase. Have it explain, analyze, or propose before it modifies.

Use task descriptions that reference file paths explicitly. “Fix the bug in auth” produces worse results than “Fix the null pointer exception in UserAuthService.java line 247.”

Review plans before execution. The planning step is Air’s most useful differentiator from editors that generate code directly. A 30-second plan review can save 20 minutes of debugging an unexpected change.

Parallelize by independence, not by speed. Two tasks that are sequential dependencies should run sequentially. Parallelism only helps when tasks genuinely don’t share intermediate state.

Air is in public preview, which means you’ll encounter rough edges. The JetBrains Air public forum and issue tracker are active — bug reports and feature requests are being processed quickly during the preview window.