GitHub Copilot Comes to JetBrains Air: How It Works

GitHub Copilot is now a selectable agent inside JetBrains Air, JetBrains' agentic development environment, letting developers run Copilot coding tasks either locally in a JetBrains IDE or remotely in the cloud through Air Teams — all billed against an existing Copilot subscription rather than JetBrains AI credits. JetBrains announced the integration on November 3, 2026, and GitHub confirmed it the same day in its own changelog, making Copilot the fourth major agent (alongside Claude, Codex, and Junie) to run natively inside Air's task list.

The move matters because Air is JetBrains' answer to the shift toward agentic coding — where developers hand off whole tasks to an AI agent and review the result, rather than chatting with an assistant line by line. Copilot support means the millions of developers already paying for GitHub Copilot can now use that same subscription inside IntelliJ IDEA, PyCharm, WebStorm, Rider, and other JetBrains IDEs without buying a second AI plan.

What JetBrains Just Announced

In a post titled "Use Your GitHub Copilot Plan in JetBrains Air – in Your IDE and in the Cloud," JetBrains engineer Vladimir Gromozdin confirmed that Air now runs "the official GitHub Copilot CLI over the Agent Client Protocol (ACP)," the open protocol Air uses to connect any compatible agent. That means developers get the real Copilot agent and whichever models their plan includes, sitting in the same task list as Claude, Codex, and Junie — not a reimplementation or a JetBrains-branded wrapper.

GitHub's own changelog entry, published the same day, states plainly that tasks "use your Copilot plan rather than JetBrains AI credits," which is the detail most developers will care about first: adding Copilot to Air costs nothing beyond the Copilot subscription they may already have.

How Copilot Runs Inside Air: Local vs. Cloud

Air supports two distinct ways to run a GitHub Copilot task, and the requirements differ for each:

For the local path, a developer installs the Air plugin, opens it in their IDE, picks "GitHub Copilot" from the agent picker, signs in with GitHub when prompted, describes the task, and sends it. Copilot then works directly in the local project, and its changes are reviewed in Air the same way as any other agent's output.

The cloud path requires Air Teams, which is currently available to JetBrains business customers. A task can be started either from the Air web app or from inside the IDE; either way, the developer connects a GitHub account under Settings → VCS Providers, picks a repository and branch (cloud agents work from a remote branch, so local changes need to be pushed first), and chooses GitHub Copilot as the agent. JetBrains notes there's no separate Copilot sign-in step — Air reuses the GitHub connection to authenticate Copilot on the remote machine.

Where Cloud Tasks Actually Run

According to JetBrains, every cloud task gets its own virtual machine, and Copilot runs inside a Docker container on that machine, signed in to GitHub with the developer's account. All of the agent's network traffic goes through a proxy, and nothing persists between tasks — so Copilot can install dependencies, run a test suite, or build a project without touching the developer's laptop or leaving residue for the next run. JetBrains points to a companion post on how Air's cloud sandboxing works for the full architecture.

JetBrains also suggests starting small: a flaky test, a dependency bump, or a minor bug fix are the kinds of tasks it recommends for a first cloud run with Copilot, both to build trust in the workflow and to keep credit usage predictable before automating anything larger.

Running Copilot on a Schedule or on Every Pull Request

Beyond one-off tasks, Air lets teams configure automations that kick off a cloud task on a schedule or in response to a repository event, such as a new pull request. If GitHub Copilot is the agent attached to that automation, every run draws on the team's Copilot plan. JetBrains specifically recommends starting with a weekly dependency-update automation, since it's easy to review and keeps usage predictable — and warns that an automation set to review every pull request "can drain your credits much faster," especially on an active repository. Critically, Air does not warn users when Copilot credits run out; failed runs are the only signal, so teams are expected to track consumption on GitHub's own usage dashboard rather than inside Air.

What JetBrains Air Actually Is

For developers unfamiliar with it, Air is JetBrains' umbrella product for agentic development — not a single feature inside an existing IDE, but what the company calls "an open system of products for agentic development" spanning JetBrains IDEs, a web app, a CLI, and a mobile app JetBrains says is "coming soon." It first reached public preview in March 2026, gained Windows support that June, picked up more agents and local-model support in July, added a multiproject view in August, launched the team-focused "Air Teams" tier in September, and opened an Early Access Program for Air inside JetBrains IDEs — built on the 2026.3 EAP builds — in October, ahead of this month's Copilot integration.

JetBrains is explicit that Air itself is not an AI provider: the plugin "ships with no agents installed," and it only detects agents a developer already has installed or signed into, similar to how an IDE detects an available terminal. If an organization doesn't permit AI agents, JetBrains says there's simply nothing for Air to run and nothing for it to send anywhere.

How Billing Works — and Where It Doesn't

Air's broader pricing model runs on JetBrains AI credits for agents that use JetBrains' own backend, with the sample usage meter on JetBrains' product page showing a pool of credits that renews on a monthly cycle. Copilot sits outside that system entirely: because the Copilot CLI checks a developer's plan and credit balance directly with GitHub when a task starts, Air has no visibility into Copilot usage and, per JetBrains' own FAQ for the feature, "can't limit it." Developers have to track Copilot consumption on GitHub itself, not inside Air's interface.

JetBrains is upfront about the rough edges this creates. Per the company's published FAQ for the integration: Air doesn't show Copilot usage anywhere in its UI; it can't set a spending cap on Copilot the way it can for JetBrains-billed agents; it can't distinguish between a personal and an organizational Copilot plan on a per-task basis; and if a task fails almost immediately, the most likely cause is a Copilot plan with no credits left — something Air checks for a valid subscription on but can't actually see the remaining balance of. Administrators can still disable Copilot as an option entirely through Air's governance policy, even though they can't cap how much of it a team uses.

Which IDEs and Agents Are Covered

JetBrains lists IntelliJ IDEA, PyCharm, WebStorm, CLion, RustRover, PhpStorm, GoLand, RubyMine, Rider, and DataGrip among the IDEs that can run the Air plugin, provided they're on version 2026.2 or later (natively on 2026.3 EAP builds). Inside Air's agent picker, GitHub Copilot now joins Anthropic's Claude Agent, OpenAI's Codex, and JetBrains' own Junie as a first-party option, with OpenCode and any other ACP-compatible agent connectable as well. Notably, Air requires no JetBrains AI subscription at all to use externally-provided agents like Copilot — a point JetBrains has repeated across multiple Air launch posts, positioning the product as agent-agnostic infrastructure rather than a vehicle to sell JetBrains' own AI credits.

Why This Matters for the AI Coding Agent Race

Air's Copilot integration lands in the middle of an unusually crowded fight over where developers run AI coding agents. Anthropic's Claude Code and Cursor have spent much of 2026 pulling developers toward terminal- and IDE-native agent workflows, while GitHub has pushed Copilot itself from an autocomplete tool into a full agent with its own cloud sandboxes and coding-agent features. By making Air agent-agnostic — happy to run Copilot, Claude, Codex, or Junie side by side in one task list — JetBrains is betting that developers want a neutral IDE-level control plane rather than a single vendor's agent locked into a single editor.

It also extends a pattern already visible elsewhere in the Copilot ecosystem this month. Copilot arrived inside Apple's Xcode as a native coding assistant option just a day before the Air announcement, and it has been steadily expanding its footprint across JetBrains' own traditional AI Assistant plugin for months already. Air is a different surface from that AI Assistant integration — it's built around parallel, delegated agent sessions rather than chat — but it gives GitHub another distribution channel into JetBrains' large install base without requiring GitHub to build anything beyond ACP support in its CLI.

What's Missing or Still Rough

A few limitations are worth flagging for teams considering the integration today. Air's IDE plugin is still labeled alpha, and Air Teams' cloud execution is, in JetBrains' words, "already available for some customers" and rolling out to everyone else "gradually over the coming months" — so cloud Copilot tasks may not yet be available to every JetBrains business customer. The mobile app for following cloud agent progress remotely is listed as "coming soon," not yet shipped. And as noted above, Air's complete lack of Copilot usage visibility means teams automating Copilot runs against every pull request have no safety net inside Air itself if usage spikes — only GitHub's own dashboard shows the real number.

What's Next

JetBrains hasn't given a firm timeline for moving Air out of alpha or for Air Teams' remaining rollout, beyond "gradually over the coming months." For now, the practical takeaway is narrow but useful: any developer with a JetBrains IDE and an active GitHub Copilot subscription can install the Air plugin today and run Copilot as a delegated agent at no additional cost, while teams on JetBrains business plans with Air Teams enabled can start experimenting with scheduled or pull-request-triggered Copilot automations. Expect JetBrains to keep adding ACP-compatible agents to Air's picker — the company has shipped a new agent or platform expansion roughly every month since March — and expect GitHub to keep highlighting Copilot's presence in third-party agent hubs like Air as part of its broader push to make the Copilot CLI usable anywhere a developer already works.

Bottom Line

GitHub Copilot in JetBrains Air isn't a new product so much as a new place to run an agent developers may already pay for. The integration adds no extra cost, uses the real Copilot CLI rather than a clone, and works whether a developer wants Copilot running quietly in the background on their own laptop or dispatched to a sandboxed cloud machine while they're away from their desk. The catch is visibility: until JetBrains adds Copilot usage tracking to Air, developers automating Copilot tasks will need to keep one eye on GitHub's own billing page.

Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Felix MoreauAll Software & Guides coverage