GitHub Copilot is now available in JetBrains Air, and this guide to the GitHub Copilot JetBrains Air integration explains exactly what that means for developers who work in a JetBrains IDE. Announced by GitHub on 3 November 2026, the integration puts Copilot in Air’s agent picker, so you can delegate coding tasks to it, guide it while it runs, and review its changes next to your code, either on your own machine or in an isolated cloud environment. The work runs on your existing Copilot subscription, not on JetBrains AI credits.
What the GitHub Copilot JetBrains Air integration is
JetBrains Air is JetBrains’ agentic coding environment: a place to hand coding tasks to AI agents, run several of them in parallel, and review their changes in one place. GitHub Copilot now appears in Air’s agent picker as an agent you can select for a coding task.
The integration is built on the Agent Client Protocol, or ACP. ACP is an open standard for communication between code editors and AI coding agents, originally published by Zed Industries in August 2025. It works like the Language Server Protocol, but for agents instead of language servers: the editor and the agent exchange JSON-RPC 2.0 messages, the editor spawns the agent as a subprocess, and work is organised into sessions. Because Air speaks ACP, it can run the official GitHub Copilot CLI as its agent, which means Air runs the real Copilot agent, not a reimplementation.
That matters because the integration is not a thin wrapper. Air runs the official Copilot CLI over ACP, so Copilot takes a task, works through it with access to project context and IDE tools, and reports back with changes you can review alongside your code.
How Copilot works inside Air
The workflow starts in Air’s agent picker. You select GitHub Copilot and sign in with your existing Copilot subscription; there is no separate Air-specific Copilot plan to buy. Once selected, Copilot accepts a task in plain language, just as it would in any agent interface.
Air lets you track multiple agent sessions at once. You can run several Copilot sessions in parallel, each with access to project context and IDE tools, and follow their progress side by side. When a session produces changes, you review them alongside your code, in context, rather than in a separate chat window or a detached diff view.
The sessions are the unit of work. A session is a conversation with shared context: you give Copilot a task, it works, it reports back, and you steer it with follow-up prompts. ACP organises the work into sessions: the editor forwards a prompt, the agent can request file access, terminal execution and tool calls, and it can ask you for permission when it wants to do something risky. Changes are reviewed in context, alongside your code.
Running Copilot on local tasks
Local tasks are the straightforward path. Install Air in your JetBrains IDE, select GitHub Copilot in the agent picker, and connect your GitHub Copilot account. You need a Copilot subscription, but you do not need Air Teams, which is only required for cloud tasks.
A local task runs in your IDE through ACP, with access to your project and the IDE’s tools. Copilot can read your code, make edits, run builds and tests, and install packages as part of the task, using your local environment. That is the trade-off to understand: local execution works with the files and tooling you already have open and keeps you close to the work as it happens, but the agent is working on your machine, in your environment.
You can also keep using the GitHub Copilot plugin alongside Air. The two are complementary: the plugin gives you inline assistance inside the editor, while Air gives you delegated, multi-step task execution. GitHub’s own guidance is to use Copilot in Air alongside the plugin and choose the workflow that works best for you.
Running Copilot on cloud tasks
Cloud tasks are the distinctive part of the integration. With Air Teams, you can hand GitHub Copilot a task in the cloud, close your laptop, and let it keep working on its own sandboxed machine. Cloud work continues independently, and you review its changes when it is done.
There are two ways to start a cloud task. From a browser, open Air, connect GitHub under Settings and VCS Providers, create a task, choose your repository and remote branch, select GitHub Copilot, and send your prompt. From your IDE, use the Air plugin and select Cloud from the environment selector. Cloud agents work from a remote branch, so push your changes first.
Where the work runs is the point of the design. Each cloud task gets its own virtual machine, and Copilot runs inside a Docker container on that machine. All traffic passes through a proxy, and no state carries over between tasks. That isolation means Copilot can build, test, and install packages without touching your laptop: each task starts on a fresh machine, and no state carries over to the next task.
What Copilot can and cannot do in Air
The integration has real limits, and most of them sit on the cloud side. Connecting GitHub Copilot to Air does not request Copilot permissions up front. Air may only verify subscription or credit availability when the cloud environment starts, so if your subscription or credits are unavailable, the task fails and an error appears in the session. Check your plan before delegating a long task.
You also cannot choose which Copilot plan a task uses. If you have both a personal subscription and an organisation plan, there is no per-task switch: an individual task simply uses your Copilot plan, and you cannot direct it to one or the other. For teams, that is worth knowing before anyone starts delegating work that might burn through shared credits.
Visibility is limited too. Air’s governance and analytics features do not include Copilot usage, and Air does not track Copilot credits for local or cloud tasks. An Air administrator can disable GitHub Copilot through a governance policy, but cannot set Copilot spending limits within Air.
Local or cloud: which Copilot task mode to choose
The choice between local and cloud is the decision the integration is really asking you to make, so make it on the task, not on habit. Choose a local task when the work needs your local files, your local development environment, or immediate interactive review: debugging something you are looking at, refactoring a module you have open, or iterating quickly with the agent while you watch. Local tasks keep you in the loop.
Choose a cloud task when the work should not touch your local machine, when you want to delegate a multi-step job and walk away, or when you are working from a browser without your IDE. A cloud task is also the right call when the job is messy or long-running: it gets a fresh machine, it cannot disturb your local setup, and it keeps going after you close your laptop.
Access often decides for you. Cloud tasks require a JetBrains account in an Air Teams-enabled business organisation, an active Copilot subscription, and Copilot enabled by your Air administrator. Local tasks need only Air in your IDE and a connected Copilot account. If you are an individual developer without Air Teams, local is your only option.
The choices you make when you start a cloud task can be summarised like this (an illustration, not a documented configuration):
{
"repository": "your-org/your-repo",
"remote_branch": "main",
"agent": "github-copilot",
"environment": "cloud",
"prompt": "Fix the failing tests in the payments module and explain what was wrong."
}That is an illustrative summary of the selections involved: a repository and a remote branch, Copilot as the agent, cloud as the environment, and a prompt. The machine, the container, the proxy and the isolation are handled by Air.
Copilot in Air or the Copilot plugin: which to use
The other choice is between Air and the GitHub Copilot plugin, and it is a choice of workflow rather than of tool. Use Air when you are delegating: a multi-step task, several tasks in parallel, or work you want to run in the cloud while you do something else. Use the plugin when you want inline assistance inside the editor: completions, explanations, and small edits as you type.
Both can coexist. The plugin is for the moment-to-moment work of writing code; Air is for the tasks you can describe, hand off, and review afterwards. As a guide: consider Air for delegated, multi-step or parallel work, choosing local or cloud according to environment needs and access, and use the plugin for inline assistance while you write code yourself.
GitHub Copilot in JetBrains Air is a small announcement with a large implication. It puts a mainstream coding agent inside an environment built for delegated, parallel, reviewed agent work, and it does so on an open protocol rather than a one-off integration. The integration is worth trying for the cloud tasks alone, but its limits, the plan you cannot choose, the usage you cannot see, the spending you cannot cap in Air, are part of the decision too. Know them before you delegate.
