For years, GitHub Copilot has been, in most developers’ heads, a VS Code thing. Sure, there were plugins for other editors, but Copilot lived in VS Code. This week that stopped being true. On November 3, GitHub made Copilot a selectable agent in JetBrains Air. On November 4, it landed inside Xcode’s own built-in coding assistant. Two IDEs that don’t belong to Microsoft, two days apart, same message: the agent is portable now, and the editor is just where it happens to run.
Xcode: Copilot moves into the built-in assistant
The Xcode news is the bigger surprise of the two, at least for Apple-platform developers. GitHub Copilot is now available directly in Xcode’s coding assistant — no extension to install, no separate app running alongside the editor. It’s in public preview starting with the Xcode 27.3 beta, which Apple released on November 3 and which also includes Swift 6.4.
The requirements are strict for now: you need the Xcode 27.3 beta from Apple Developer Downloads, and your Mac has to be running macOS Tahoe 26.6 or later. Setup lives in Xcode > Settings > Intelligence, where you pick GitHub Copilot as the provider. GitHub says all Copilot plans are supported.
One thing worth knowing before you switch: the existing GitHub Copilot for Xcode extension isn’t going away. GitHub is explicit that it remains a separate option, so you can keep your current workflow or try the native route. If you’ve been running the extension for years and it works, there’s no forced migration here — just a second door into the same room.
A caveat, and an honest one: I haven’t run this hands-on yet. It’s a public preview in a beta IDE, so treat it as something to try on a side project, not a reason to move your daily driver to a beta toolchain. GitHub’s changelog is also silent on whether usage in Xcode’s assistant bills against the same premium-request allowance as other Copilot surfaces, so check your usage page before assuming it behaves like your editor plugin.
JetBrains Air: Copilot becomes an agent you pick
The JetBrains move is different in kind, and arguably more interesting. JetBrains Air is JetBrains’ agentic development environment — a place where you hand coding tasks to an agent and review the results next to your code. Copilot now shows up in Air’s agent picker as a default agent, built on the Agent Client Protocol (ACP), the open protocol that lets an editor treat an AI agent as a swappable component rather than a built-in feature. Pick Copilot, sign in with your existing subscription, delegate a task.
It works in two modes. Local runs happen inside your JetBrains IDE, the way you’d expect. Cloud runs go through Air Teams, where each task runs in an isolated Docker container on a fresh virtual machine, with traffic routed through a proxy and no state carried between tasks. You can kick those off from the IDE or from a browser.
The billing rule is the one to get right before you click anything: cloud tasks bill against your Copilot plan, not your JetBrains AI credits. That’s a genuinely good deal if you already pay for Copilot and want to try agent-driven cloud sessions without opening a second AI budget.
There are governance gaps worth knowing about, though. You can’t choose a personal versus organization Copilot plan per task, Air’s analytics don’t include Copilot usage, and Air admins can disable Copilot but can’t set spending limits on it from the Air side. If your org cares about any of that, the controls live on GitHub’s side, not JetBrains’.
In a related change, starting with JetBrains IDEs 2026.2.4, Copilot can also be selected as the provider for Next Edit Suggestions — the inline, next-edit completions inside the editor. So Copilot is showing up in JetBrains tooling at two levels: the agent you delegate to, and the completions engine underneath your cursor.
The pattern underneath
Step back and the pattern is hard to miss. A week ago I wrote about the IDE becoming an agent host — VS Code separating agent sessions from editor windows, Android Studio doing the same. This week’s news is the other half of that story: once the host is open, agents become interchangeable parts. ACP is doing for coding agents what LSP did for language servers — turning a proprietary integration into a protocol, so the agent you already pay for follows you into whatever editor the project demands.
That’s a good deal for developers. It means the choice of editor and the choice of agent stop being the same decision. An iOS developer who lives in Xcode and a backend developer who lives in IntelliJ can both use the same Copilot subscription, the same memory, the same model access — and a team standardizing on Copilot doesn’t have to standardize on one editor to get it.
The open question is what happens to the edges. Billing, usage analytics, and spending controls don’t travel as cleanly as the agent itself — as the Air integration’s fine print shows. And every new surface is another place where “which plan pays for this?” needs an answer. But the direction of travel is clear: the agent is the product now, and the IDE is the place it shows up.
If you’re already on a Copilot plan, both of these are free to try — the Xcode preview needs the 27.3 beta and Tahoe 26.6, and the Air integration needs a JetBrains IDE with Air enabled. I’d start with whichever editor you already live in. The interesting part isn’t either integration on its own; it’s that, for the first time, switching editors no longer means switching agents.