# Qwen3.8-27B Local GitHub Copilot: Can It Replace the Cloud?

[News](https://mindoxai.com/category/news/)
**
Published: November 17, 2026
**
8 min read
**
[Pravesh Garcia](https://mindoxai.com/author/pravesh/)

![Qwen3.8-27B Local GitHub Copilot: Can It Replace the Cloud?](https://d1p58i0iwq4isz.cloudfront.net/mindoxai/wp-content/uploads/2026/11/17160201/qwen3-8-27b-local-github-copilot-can-it-replace-the-cloud.webp)

Every time a cloud coding assistant suggests a fix, a piece of someone’s work travels to a server they’ll never see. Most developers accept that trade without a second thought. Microsoft’s new walkthrough for a Qwen3.8-27B local GitHub Copilot setup raises a quieter possibility: what if the model lived on your own desk instead?
As of this month, the answer is a partial yes. You can now point GitHub Copilot at an open-weight coding model running on a single consumer graphics card. But “local” covers less ground than the word suggests. And nearly every performance number in circulation comes from one source, the company that built the tooling.
That’s worth untangling. The real story isn’t a spec sheet. It’s about who gets to see your code, and who controls the tools people increasingly think with.

## What Microsoft shipped on November 5

On November 5, 2026, Microsoft’s Foundry team published a post titled [“Bring Agentic Coding On-Device with Foundry Local.”](https://devblogs.microsoft.com/foundry/foundry-local-agentic-coding-qwen3-8-27b/) It names Qwen3.8-27B, a model from Alibaba’s Qwen line, as its primary target for local agentic coding.
Foundry Local is Microsoft’s runtime for running models on your own hardware. It pairs ONNX Runtime with a speculative-decoding technique called DFlash, and for now it targets NVIDIA GPUs.
The walkthrough wires a local Qwen3.8-27B model into GitHub Copilot in a handful of steps:

Install the Foundry Local CLI, version 0.13.0 or later, through WinGet.
- Install NVIDIA’s CUDA and cuDNN separately.
- Load the model with the Foundry CLI, then check the server status to find its local endpoint.
- In the GitHub Copilot app, open **Settings > Model providers**, add Foundry Local with that endpoint as the Base URL, add Qwen3.8-27B, and pick it in the model picker.

GitHub’s own documentation [lists Foundry Local as a supported bring-your-own-key (BYOK) provider](https://docs.github.com/en/copilot/how-tos/github-copilot-app/add-llm-models) in the Copilot app. The same page calls the feature a public preview, “subject to change.” It doesn’t mention Qwen3.8-27B anywhere. So the model works as a custom provider choice, not as one GitHub formally vouches for.

“Agentic coding” means a model that plans and carries out multi-step tasks rather than answering one question at a time. If that distinction feels slippery, our explainer on [what an AI agent actually is](https://mindoxai.com/blog/artificial-intelligence/what-is-an-ai-agent/) lays it out.

## How Qwen3.8-27B fits on a 24 GB GPU

A model this size would normally swamp a home PC. Microsoft’s answer is 4-bit quantization, which stores each of the model’s internal numbers with far less precision. That shrinks Qwen3.8-27B to about 18 GB. An NVIDIA card with 24 GB of video memory (VRAM) can hold it.

Think of it like compressing a photo. You keep the picture and lose some fine detail. Whether that detail mattered for coding is one of the open questions here.

Microsoft tested the setup on an RTX 5090 and on NVIDIA’s DGX Spark, which carries 128 GB of unified memory according to AI Weekly’s recap. The company also says Foundry Local ran faster than llama.cpp, a popular open-source alternative, at every prompt length it tried. No one outside Microsoft has checked that claim yet.

### The context-window catch

Context is the model’s working memory: how much code and conversation it can hold at once. On a 24 GB card you get up to 64K tokens. The full 262K context needs a GPU with 32 GB or more.

For a single script, 64K is roomy. For a sprawling codebase, where an agent has to read dozens of files, that ceiling will likely arrive sooner. (If tokens and context windows feel abstract, our guide to [how large language models work](https://mindoxai.com/blog/artificial-intelligence/how-do-large-language-models-work/) walks through them.)

## What the benchmark numbers do and don’t tell you

Microsoft published four scores for the model:
- **SWE-bench Pro:** 61.7
- **Terminal Bench 2.1:** 73.0
- **NL2Repo-Bench:** 42.3
- **DeepSWE 1.1:** 42.2

Those look strong for something that fits on one graphics card. But they’re vendor-reported. We found no independent replication, and the trade coverage so far mostly repeats Microsoft’s figures.

The bigger gap is comparative. We couldn’t find a single test that pits this setup against a cloud coding assistant on the same tasks. Any claim that local AI now “matches” the cloud is a guess dressed up as a finding.

Even trustworthy benchmarks measure curated tasks. They can’t tell you how a local Qwen3.8-27B behaves inside GitHub Copilot on your own repository, with its odd conventions and neglected corners. Only use will tell you that.

## Does a Qwen3.8-27B local GitHub Copilot setup keep your code private?

This is the question that matters most. The honest answer: largely, for some features.

Microsoft’s pitch, as AI Weekly relays it, is that local inference keeps your code and context on the machine in front of you. For chat and agent tasks, a Qwen3.8-27B local GitHub Copilot setup does what it promises. The model runs on your GPU, and those prompts don’t go to a remote model.

The fine print lives in Microsoft’s [VS Code documentation on language models](https://code.visualstudio.com/docs/copilot/customization/language-models). It says BYOK “applies to the chat experience and utility tasks only.” It adds that “you cannot connect to a local model for inline suggestions,” the autocomplete that fills in code as you type. Features such as semantic search and inline suggestions still require a GitHub account.

There’s a caveat on the caveat. Those are VS Code docs, while Microsoft’s walkthrough uses the standalone Copilot app. We couldn’t confirm that the same limits apply there.

The same docs say BYOK local models work without a GitHub account, a Copilot plan, or an internet connection. GitHub’s page adds that you don’t need a Copilot plan if you only use your own provider. The Copilot app also keeps provider credentials in your system’s credential store.

At least one third-party blog claims that code review and pull-request summaries stay on GitHub’s servers as well. We couldn’t verify that report, so treat it as unconfirmed.

The practical lesson? If you need a genuinely offline setup, turn off whatever still calls home. Check each feature yourself rather than trusting the word “local” on the box.

## Local vs cloud coding assistants: what you trade

Even Microsoft doesn’t sell this as a full replacement. Its post recommends a hybrid workflow: the local model for everyday tasks and subtasks, a cloud model for complex reasoning. That’s a telling admission from the company that built the local path.

Running Qwen3.8-27B as a local model in GitHub Copilot shifts the costs around:
- **Hardware.** You need an NVIDIA GPU with at least 24 GB of VRAM. That’s a high-end consumer card, not a typical laptop chip.
- **Memory ceiling.** You get 64K tokens of context on that card, against 262K at 32 GB and up.
- **Reasoning depth.** By Microsoft’s own advice, the hardest problems still belong in the cloud.
- **Control.** Your chat and agent prompts stay on your machine. No subscription is needed if you only use your own provider.
- **Setup effort.** CUDA, cuDNN, a command-line tool and an endpoint URL. Routine for a developer, but hardly one click.

There’s a softer cost too. A coding assistant becomes part of how a developer reasons through problems, a habit we’ve examined in our piece on [cognitive offloading to AI](https://mindoxai.com/blog/cognitive-augmentation/ai-co-processing-basic-skill-or-crutch/). Who runs that assistant, and who can change it without asking you, isn’t a trivial question.

## Who this is for, and what it signals about open-weight AI

For now the audience is narrow. Think of Windows developers with a serious NVIDIA card, or teams handling code they can’t send to a third party. Tinkerers curious about how far one GPU stretches belong here too.

For everyone else, the signal matters more than the setup. Microsoft’s roadmap lists Mac support, AMD GPU support, more coding-optimized local models and deeper Copilot integration. All of that is planned, and none of it has shipped. If it lands, the assumption that serious AI help requires a data center starts to weaken.

Open weights move control toward the person at the keyboard. They also move responsibility, a tension we explored when [Kimi K3.1 Pro released its weights](https://mindoxai.com/news/kimi-k3-1-pro-open-weights/). Owning the model means owning its blind spots.

## So, can it replace your cloud assistant?

Not yet, and Microsoft more or less says so. A Qwen3.8-27B local GitHub Copilot setup can take over routine work and keep that slice of your thinking on hardware you own.

Our read: treat the benchmarks with suspicion until someone outside Microsoft runs them. The privacy shift is real, though narrower than the marketing implies. If you have the GPU, try it on a side project before you trust it with anything sensitive, and confirm exactly which features still talk to GitHub.

The more interesting question is the one this release only begins to answer. Does serious AI assistance have to live in somebody else’s building?

Author & Contributor

### Pravesh Garcia

Writes explainers and analysis for Mindox AI on AGI, artificial intelligence, neural technology and cognitive augmentation. Articles are based on primary sources such as research papers, company releases and regulatory documents, and follow the [Editorial Policy](https://mindoxai.com/editorial-policy/).

[Follow](https://mindoxai.com/author/pravesh/)

## Frequently Asked Questions

**Q:** Can Qwen3.8-27B run locally with GitHub Copilot?

**A:** Yes. Microsoft's November 5, 2026 walkthrough loads Qwen3.8-27B in Foundry Local, then adds Foundry Local as a model provider in the GitHub Copilot app. GitHub's documentation lists Foundry Local as a bring-your-own-key provider in public preview, but it does not name Qwen3.8-27B as an officially supported model. It works as a custom provider choice.

**Q:** How much VRAM does Qwen3.8-27B need?

**A:** With 4-bit quantization the model takes about 18 GB, so Microsoft calls for an NVIDIA GPU with at least 24 GB of VRAM. At 24 GB you get up to 64K tokens of context. The full 262K-token context needs a GPU with 32 GB or more.

**Q:** Is a local coding model as good as a cloud coding assistant?

**A:** Nobody has published an independent head-to-head test yet. Microsoft's scores, such as 61.7 on SWE-bench Pro, are vendor-reported. Microsoft itself recommends a hybrid workflow: the local model for everyday tasks and subtasks, a cloud model for complex reasoning.

**Q:** Does running Copilot with a local model keep my code private?

**A:** Partly. Chat and agent requests you send to the local model run on your own GPU. Microsoft's VS Code documentation says bring-your-own-key covers chat and utility tasks only, and that you cannot connect a local model for inline suggestions. Those docs describe VS Code rather than the Copilot app, so check each feature before you assume a fully offline setup.

**Q:** What is Microsoft Foundry Local?

**A:** Foundry Local is Microsoft's tool for running AI models on your own hardware. It uses ONNX Runtime with DFlash speculative decoding on NVIDIA GPUs. The Qwen3.8-27B setup needs Foundry Local CLI version 0.13.0 or later, installed through WinGet, plus CUDA and cuDNN installed separately.

**Q:** What is GitHub Copilot BYOK?

**A:** BYOK means bring your own key: you connect your own model provider instead of using GitHub's hosted models. GitHub's docs say you don't need a Copilot plan if you only use your own provider, and the app keeps provider credentials in your system's credential store. The feature is in public preview and subject to change.

**Q:** Does Foundry Local work on Mac or AMD GPUs?

**A:** Not yet for this setup. Mac support and AMD GPU support are on Microsoft's roadmap as planned features. The current release targets NVIDIA GPUs with CUDA and cuDNN.