Copilot Stops Being a VS Code Thing: JetBrains Air and Xcode in 48 Hours
In 48 hours, GitHub put Copilot in two new homes: JetBrains Air on Nov 3, 2026, where it becomes a selectable agent over the Agent Client Protocol, and Xcode's built-in coding assistant on Nov 4, in public preview from Xcode 27.3 beta. The same subscription now covers VS Code, JetBrains, and Xcode — but the fine print on billing and admin controls deserves a close read.

On November 3 and 4, 2026, GitHub published two changelog entries within 48 hours: GitHub Copilot first arrived in JetBrains Air as a selectable agent, and a day later it arrived in Xcode's built-in coding assistant, in public preview starting with Xcode 27.3 beta. The November 6 weekly roundup pinned the two together with a single line: this week, Copilot comes to JetBrains Air and Xcode's coding assistant. For people who write code with AI every day, the significance is not one more entry point — it is a turning point. Copilot is no longer a VS Code accessory. It is becoming a “subscribe once, use everywhere” pass: wherever you write code, it follows.
For years, competition among AI coding assistants looked like an editor war: Cursor had its own editor, Windsurf had its own editor, Copilot was most at home in VS Code, and Claude Code was most at home in the terminal. Switching editors meant switching assistants, and switching assistants meant switching workflows — the migration cost was high enough that most people simply did not bother. GitHub's two moves run in the opposite direction: instead of forcing you to change editors, it puts Copilot inside the editors you already use. JetBrains users do not need another plugin or another tool to learn; Xcode users do not need a bolt-on extension. The editor stays the same; the assistant becomes the one you already pay for.
JetBrains Air: the agent becomes an option you pick
Start with JetBrains Air, announced November 3. Air is JetBrains' agentic coding environment, built around one idea: choice. For each task, you pick which agent does the work in an agent picker. Copilot is now one of the options in that picker — select it, connect your GitHub Copilot account, and delegate tasks using the subscription you already have. Tasks can run locally inside your JetBrains IDE or in the cloud through Air Teams.
The technical foundation is worth a closer look: the Agent Client Protocol, or ACP. It is an open protocol whose job is to let an IDE treat an AI agent as a swappable component rather than a built-in, fixed feature. Previously, every IDE shipped its own assistant, and changing assistants meant changing IDEs. With ACP, an IDE only needs to implement one integration surface, and any ACP-compatible agent can plug in. For developers, that moves the power of choice from vendors back to users: use Copilot today, try another agent tomorrow — what changes is an option in a dropdown, not the whole working environment. GitHub's willingness to put Copilot into this open system signals its bet: the contest will not be won by “locking in the editor” but by “how good the agent itself is.”
Copilot in Air has two modes, and the difference matters. Local tasks are simple: install Air in your JetBrains IDE, select GitHub Copilot, connect your account, and go. You can track multiple agent sessions in parallel and review changes alongside your code. Cloud tasks go through Air Teams: the work runs in an isolated cloud environment — specifically, a Docker container on a fresh virtual machine, with all traffic passing through a proxy and no state carried over between tasks. Copilot can build, test, and install packages there without touching your local environment. The bar for cloud tasks is higher: you need a JetBrains account in an Air Teams-enabled business organization, a GitHub Copilot subscription, and Copilot enabled by your Air administrator. You can open Air in the browser, pick a repository and remote branch, and send a task — or use the Air plugin in your IDE and switch the environment selector to Cloud.
The billing rule is the most practical sentence in the announcement: cloud tasks use your Copilot plan rather than JetBrains AI credits. Organizations do not need a second AI budget to try Copilot in Air. But GitHub also puts the caveats up front, all four of them. First, connecting Copilot to Air does not request GitHub Copilot permissions; Air may only verify subscription or credit availability when the cloud environment starts, and if the subscription or credits are unavailable, the task fails with an error in the session. Second, you cannot choose whether an individual task uses your personal plan or your organization's plan. Third, Air's governance and analytics features do not include Copilot usage. Fourth, Air administrators can disable Copilot through a governance policy but cannot set Copilot spending limits within Air. In plain language: money is GitHub's side of the fence — Air can neither see it nor control it. Teams adopting cloud tasks should set budgets and permissions on the GitHub side before opening the Air door.
Xcode: inside Apple's own house, but on strict terms
The November 4 Xcode move is a different story — and the more surprising one. GitHub Copilot now runs directly in Xcode's built-in coding assistant, in public preview starting with Xcode 27.3 beta. Setup takes one line: in Xcode, open Xcode > Settings > Intelligence and set up GitHub Copilot in the coding assistant. No extension to install, no separate download — it is part of the editor.
The requirements need to be recorded word for word, because every one of them is mandatory: Xcode 27.3 beta or later, downloaded from Apple Developer Downloads, on a Mac running macOS Tahoe 26.6 or later. All Copilot plans are supported. The Xcode 27.3 beta landed on November 3, in the same batch as Swift 6.4. Neither GitHub nor Apple gives a date for the stable release in their announcements — some reports point to December, but that is press reporting, not an official commitment, so do not plan around it.
Two confusions need clearing up. First, this is not the existing GitHub Copilot for Xcode extension. That extension is a separate, long-standing product, and GitHub is explicit that it remains available as a separate option — the two paths coexist, and you pick the workflow that works best for you. Existing extension users do not need to change anything; people who want the native integration can install the beta. Second, Xcode's built-in coding assistant already offered Claude and ChatGPT, according to Apple's setup documentation and contemporaneous reporting — Copilot is the third option joining the queue. For Apple, that hands the “which assistant” decision to the user; for GitHub, it means a seat at the same table as Claude and ChatGPT on Apple's home turf.
The feedback channels are also telling: GitHub asks users to share feedback in the GitHub Copilot for Xcode repository or through Apple's Feedback Assistant. Two separate inboxes means this is a joint product, and when something breaks you need to know whose side it is on. And a public preview on a beta IDE is two layers of “not stable yet” stacked together — try it on a side project for a few rounds before pointing it at the codebase that pays your rent.
More from the same week: not just two new doors
The November 6 weekly roundup shows the Copilot team did more than open new doors this week — it also fixed workflows. The headline item is Agent Merge: you can now set it up directly from a pull request so Copilot merges the PR when it is ready, and the setting stays enabled while required checks or rules are pending. You can also check reviewer status, request additional reviews, and select comment text to quote it or discuss it with Copilot. For anyone who processes a pile of AI-generated PRs every day, this turns “merge” from a manual watch into a rule-driven action.
Two other fixes address real pain. When a conversation hits its context limit, you can now compact the conversation or review what is using the available space directly from the error, instead of throwing the whole conversation away and starting over. And “personal instructions for assisted approval” let you tell Copilot which tool requests it may approve without asking you — but the feature is opt-in and applies to local sessions only. GitHub is being deliberately cautious here: auto-approving tool calls is an efficiency tool and a security hole at the same time, so it is opening up locally first. Smaller items round out the week: drag files onto “New” in the sidebar to start a session, CSV and TSV files open as tables with sticky headers, and VS Code 1.145 adds experimental chat view modes that collapse or expand reasoning and tool calls.
Read together, the week's work has a clear through-line: turning Copilot from “a good chat assistant” into “an agent system that can enter production workflows.” New editors are breadth; Agent Merge and approval instructions are depth; context compaction is endurance. Each addresses one of the three old problems of agent adoption: where to use it, whether it can be trusted with the job, and whether it survives a long run without falling over.
Why now: the IDE is becoming an agent picker
Taken together, the two launches point to a change bigger than either announcement: the IDE is turning from “the shell of one AI assistant” into “a picker for many agents.” The JetBrains Air agent picker is the most literal expression of the trend; Xcode's Intelligence settings page is Apple's version of the same idea — the provider can change while the editor stays put. That is good for users: you no longer switch your whole working environment to switch assistants, and you no longer buy a separate subscription per editor. For vendors, it is a new kind of competition: agents no longer win by “owning the editor” but by how well they actually do the work.
For GitHub, the strategy has an extra layer of arithmetic. Copilot's business model charges per person, not per editor. Once a subscription covers every editor a user works in, the case for renewing gets much stronger; conversely, if some editor lacks Copilot, users may try another assistant there — and eventually question the subscription itself. So GitHub's expansion logic is simple: wherever users write code, Copilot has to show up. This week fills the two biggest remaining gaps — JetBrains, the stronghold of backend and enterprise development, and Xcode, the only official doorway into the Apple ecosystem.
That is also why open protocols like ACP deserve attention. Once a protocol becomes the de facto standard, the negotiation table changes: IDE vendors no longer need to negotiate exclusive integrations one by one, and agent vendors no longer need to write a separate adapter for every IDE. The eventual winners are small teams and indie developers — no more agonizing over “does my editor support this assistant,” just judge the agent on capability and price. Vibe coders feel this most directly: one person is the whole team, and the lighter the toolchain and the lower the switching cost, the faster the experimentation.
What the picker really means: agents have to queue up too
The most interesting thing about JetBrains Air is not that it adopted Copilot but the product shape itself: for each task, the user picks who does it in the picker. That design is a public admission that no single agent is best at everything. One may be faster at boilerplate, another steadier at legacy code, a third sharper at performance work. Previously, comparing them meant switching tools — a cost so high nobody bothered to compare seriously. Now the cost of comparing has fallen to “change an option in a dropdown,” and users will vote with their feet, quickly.
For Copilot, joining the picker is both an opportunity and a test. The opportunity: it can finally appear in workflows that would never have considered it — a JetBrains backend team can try Copilot without changing editors. The test: it competes head-to-head with the other agents in the picker, and every task is a job interview — do the work badly and the user picks someone else next time. Part of Copilot's old moat was “it is just there by default in VS Code.” That part no longer exists. What remains is pure capability: understanding a codebase, accuracy of changes, and the ability to correct its own mistakes.
That is good for the whole industry. Once agent competition becomes “the same task, the same interface, compare the results directly,” progress will be faster than each vendor building features in isolation. Users no longer have to bet on a single vendor: keep the subscription for the one you use most, swap in another option for the occasional task — the toolchain is no longer a one-time bet. In the long run, if “picker-style” products become the norm, agent vendors will spend their energy on “doing the work better” instead of “locking users into our editor” — which is exactly the competition users want to see.
Before you celebrate: four pitfalls to see clearly
The first pitfall is Xcode billing. GitHub's announcement does not say how Copilot usage inside Xcode's coding assistant is billed — whether it counts against the same premium-request allowance as the editor plugin is left entirely unsaid. Until GitHub says so explicitly, do not assume it draws from the same budget as Copilot in VS Code. Check your usage page regularly; it beats arguing after the bill arrives.
The second is the management blind spot in Air. The four limits above are worth repeating: no per-task choice between personal and organization plans, no Copilot usage inside Air's analytics, and administrators who can disable Copilot but cannot cap its spending. For individual users, the impact is small. For teams, cost control for cloud tasks has to happen on the GitHub side — the switch inside Air only controls “on or off,” not “how much.” If your team's Copilot is paid for centrally, set budgets and alerts on GitHub first, then have the admin open the Air door. Do not reverse the order.
The third is maturity. The Xcode side is a public preview running on a beta IDE; the Air side is not a preview, but cloud tasks pass through two gates — an enterprise organization and an administrator. For production code, the steadier path is: JetBrains users should start with local tasks and consider cloud only once that feels solid; Xcode users should try the native integration on a side project rather than migrating the project that pays the bills. Decide on a full switch after the stable release and the first wave of user feedback.
The fourth pitfall is the easiest to miss: the model. GitHub's announcements do not spell out which models Copilot can call from each entry point, whether MCP servers are supported, or whether there is an agent mode. The official JetBrains Air screenshot shows GPT-6.1 Sol as the selected model, but that is one example in one screenshot — do not read it as “Air can only use this model.” What matters is what your own workflow needs: if you depend heavily on a particular model or MCP tooling, test it in the target entry point first and confirm the capabilities are there before migrating.
A practical checklist for vibe coders
If you use JetBrains, the path is shortest: install Air in your IDE, pick GitHub Copilot in the agent picker, connect your existing account, and start with local tasks. Parallel sessions and reviewing changes right next to your code are especially friendly to vibe coding's multi-tasking style — one session can fix a bug while another writes tests, and you review each diff in turn instead of switching windows. Once that feels solid, if your team has Air Teams, evaluate cloud tasks: their value is throwing builds and tests into an isolated environment while your local machine only reviews results — ideal for projects with heavy dependencies that are painful to run locally.
If you use Xcode, first ask yourself: am I on the stable release, or willing to install a beta? If the latter, download the Xcode 27.3 beta from Apple Developer Downloads, confirm your Mac runs macOS Tahoe 26.6 or later, then go to Xcode > Settings > Intelligence and select GitHub Copilot as the provider. Keep the original extension as a fallback — GitHub says the two coexist, so there is no reason not to keep the escape route. If your main project still lives on stable Xcode, do not upgrade your whole toolchain just to try this out. Wait for the 27.3 stable release.
If you use VS Code, this week's news most directly means “your subscription is worth more now”: the same subscription covers more editors. The next time you need to edit backend code in JetBrains or tweak an iOS interface in Xcode, there is no new payment and no new tool to learn for the assistant's sake. The subscription's value is shifting from “an assistant in one editor” to “an assistant in every editor” — exactly the change GitHub wants you to feel.
Back to the opening line: Copilot is no longer VS Code's thing. For GitHub that is strategy; for users it is a bargain; for the industry it is a signal — the next stage of the AI coding-assistant race will not be decided by whose editor looks better, but by whose agent does beautiful work inside any editor. JetBrains Air and Xcode are only the first stops. What comes next is who else follows, and how far open protocols like ACP can go. For people who write code every day, the cost of switching sides is falling — and that, by itself, is the best news.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.