GitHub Copilot Local Models: Hybrid Inference (2026)

On 7 October 2026, Microsoft announced something that would have sounded absurd two years ago: GitHub Copilot will soon run AI models locally on your machine, choosing on its own whether each coding task runs on your PC or in the cloud. If you’re searching for github copilot local models, this is the plain-English breakdown of what was actually announced, how it will work, what hardware you need, and what Microsoft has not told us yet.

This is a moving target — the feature lands as an experimental preview later in October 2026 — so every claim below is tied to a source, and I’ve flagged the open questions explicitly.

Table of Contents

What Microsoft actually announced

At its Windows and Surface event on 7 October 2026, Microsoft unveiled a strategy it calls “hybrid intelligence”: local processing for workloads where it makes sense, cloud models for everything else, with Windows acting as the routing and policy layer in between. The developer-facing half of that story is GitHub Copilot.

Specifically, Microsoft is extending Project HydraFusion — GitHub’s multi-model orchestration technology, which currently routes tasks between cloud-based models — so it can also route to models running locally on Windows devices. The experimental preview is expected to cover the GitHub Copilot app, GitHub Copilot CLI, and Visual Studio Code, arriving “by the end of the month” in Microsoft’s own wording. So: late October 2026, not a general release.

Alongside routing, Microsoft announced a model built for exactly this job: MAI Code 1.1 Flash, an on-device coding model optimised to run on a PC rather than in a datacentre. We’ll get to its specs in a moment — but first, you need to understand HydraFusion, because it is the whole mechanism.

HydraFusion in plain English

GitHub introduced Project HydraFusion on 4 September 2026 as a research preview in Copilot CLI. The idea is deceptively simple: instead of you picking one model for everything, you pick HydraFusion in the model picker (the way you’d pick Claude or GPT), and the orchestration layer builds an execution plan from multiple models.

For each request, HydraFusion currently chooses one of three execution patterns:

Single: one selected model solves the task directly.
Cascade: an efficient model drafts a solution, and a quality gate decides whether to accept it or escalate to a stronger model.
Critique: one model drafts a result, an independent read-only critic from a different model family reviews it, and the drafting model revises once.

Why bother? Because a coding task doesn’t need the same amount of intelligence all the way through. GitHub’s own testing claimed costs 36% to 67% lower than its estimates for Opus 5 across three benchmark tests — worth treating as a vendor-supplied number, not a law of nature, but the direction is what matters: the router is becoming the product, not the model.

To try the cloud-only version today, GitHub’s community discussion gives the recipe: in Copilot CLI run /update, then /experimental on, then /model and select HydraFusion (Research Preview). The October announcement simply adds a new destination for that router: your own machine.

How GitHub Copilot local models will work: two modes

Microsoft describes two ways to use local inference, and the distinction matters:

1. Auto orchestration

Copilot decides per request whether it should be handled locally or in the cloud. GitHub’s announcement gives concrete examples of where local models win:

Simple tasks like explaining how a codebase works or how to run a project.
Planning with a large frontier model (the announcement name-checks “Astra”) and then handing off to a local model to implement while you sleep.
Automations that run on a schedule in the background — long-running tasks where a local model costs, in GitHub’s words, zero AI credits.
Going completely offline and still having Copilot access to local models.

The stated benefit is that inference is completely free for you — no cloud tokens burned for work your machine can do itself. That’s GitHub’s claim about the preview, and it’s the economic heart of the pitch.

2. Explicit local-model selection

If you don’t trust the router (or your compliance team won’t let you), you pick the model yourself: select MAI Code 1.1 Flash through the Windows ML provider, or connect Copilot to an OpenAI-compatible local endpoint and choose from the models that endpoint exposes. Microsoft explicitly says this supports workflows that need a specific provider, model, or endpoint — which is corporate-speak for “regulated industries can pin this down”.

There’s also a discovery win: you won’t have to configure local models inside Copilot at all. Any models you have installed with supported providers — Microsoft Foundry Local or Ollama — will be automatically discovered and appear in Copilot’s model picker.

Meet MAI Code 1.1 Flash

The model Microsoft built for this is MAI Code 1.1 Flash — a mixture-of-experts coding model Microsoft introduced earlier in the year and expanded across Copilot surfaces in June 2026. The local-optimised version carries serious specs:

137 billion total parameters, 6.8 billion active parameters — the MoE design means only a fraction of the model fires per token, which is why it fits on a PC at all.
3-bit quantisation, which Microsoft says reduces the model’s size by nearly 80% while preserving coding quality.
A 256K local context window, plus speculative decoding to improve responsiveness and reduce the on-device footprint.

It ships first on the new Surface Laptop Ultra, which Microsoft positioned at $2,599 and which runs on NVIDIA’s RTX Spark hardware. Microsoft also said an upcoming NVIDIA Nemotron model with over 70 billion parameters — quantised to 2 bits, needing just over 20GB of memory — and DeepSeek V4 Flash, a 284-billion-parameter model, are being fitted to run locally on RTX Spark machines. A year ago, Microsoft noted, that class of capability was exclusive to cloud models.

The hardware catch (read this before buying anything)

Here’s where the announcement gets less casual. Local inference is not coming to every laptop you own.

NVIDIA’s RTX Spark platform — a Blackwell RTX GPU combined with a Grace CPU, supporting up to 128GB of unified memory and one petaflop of theoretical FP4 AI performance (using sparsity, per NVIDIA) — is the reference hardware. RTX Spark systems from ASUS, Dell, HP, Lenovo, MSI, and Microsoft began shipping on 16 October 2026.

On the software side, Windows ML is the runtime spreading models across GPU, NPU, and CPU, and Microsoft announced llama.cpp support in Windows ML — which opens the door to running open-source models locally from day one.

The practical takeaway: Microsoft’s performance observations come from the Surface Laptop Ultra, and it has not published requirements for other devices. One outlet covering the event put it bluntly: don’t buy a PC on the strength of the announcement alone. If you’re a regular dev with a mid-range laptop, treat local MAI Code 1.1 Flash as something to test later, not something to budget for now.

Sandboxing: Microsoft Execution Containers (MXC)

Local inference raises an obvious question: if a model is now running on your machine and using tools there, what stops it from touching everything? Microsoft’s answer is Microsoft Execution Containers (MXC), which is now generally available on Windows 11.

MXC translates account policies into OS-native controls: the BaseContainer tier of the ProcessContainer backend on Windows, bubblewrap on Linux, and Seatbelt on macOS. Organisations define which files and networks an agent may access, with policies enforced at runtime. Codex, GitHub Copilot, and OpenClaw already support MXC; Claude Code, Perplexity, and Raycast are due to follow. Microsoft also says it plans to add separate VM or container images as options in future.

The pragmatic view: a sandbox reduces blast radius, but it isn’t a reason to hand an agent your credentials. Enable sandboxing before running agents on local repositories, whichever model is selected.

What Microsoft hasn’t told you yet

Honesty section. The announcement is real and specific, but several things remain undisclosed or deliberately vague:

Pricing. Microsoft has not disclosed pricing or subscription treatment for local inference. GitHub says local inference will be free for you and automations on local models will cost zero AI credits — but how this interacts with Copilot plan tiers is unknown.
Timing. Microsoft’s own wording is “experimental preview later in October”, not a firm launch date. Don’t plan a rollout around a specific day, and don’t assume everyone gets it at once.
Hardware requirements beyond the flagship. No published minimums for other devices.
Benchmarks. The headline numbers (peak memory improvements, token utilisation, the HydraFusion cost claims) are company-supplied, from Microsoft-commissioned or NVIDIA tests on preproduction hardware. Real-world numbers will come from developers actually using it.

Microsoft framed the whole push around cost, stating that customers’ AI needs are outpacing what their cloud budgets can support. The intent is to stretch those budgets while preserving access to frontier capabilities — Microsoft claims more than 2 trillion inferences are already run locally each month across Copilot+ PCs. Whether hybrid routing delivers that stretch in daily coding is something only real-world use will show.

What to do about it right now

Try HydraFusion today. If you use Copilot CLI, run /update, /experimental on, then /model and pick HydraFusion (Research Preview). Compare accepted changes, time taken, and token cost against a single trusted model — that’s the only benchmark that matters to you.
Install Foundry Local or Ollama. Models you install with supported providers will auto-appear in Copilot’s model picker when local routing arrives, so having a working local setup means you’re ready on day one.
Watch for the preview later this month in the Copilot app, Copilot CLI, and VS Code. Enable it when it lands; treat it as an experiment, not a dependency.
IT admins: decide your policy on local models and OpenAI-compatible endpoints before developers start asking. Preview-feature toggles are expected in Copilot Business and Enterprise.
Hardware buyers: don’t buy for this announcement yet. Wait for independent benchmarks on non-flagship hardware.

GitHub Copilot Local Models: How Hybrid Inference Will Actually Work (2026)