GitHub Copilot Local Models: Offline Setup and Limits

Updated 5 November 2026 · Standard formula, shown below

GitHub Copilot can use a local language model in some supported editor integrations, but local-model support is not a general offline mode for every Copilot feature. Whether it works depends on the editor, extension, model provider and Copilot plan; chat, code completion and account-dependent features may still require an internet connection.

What “local model” means for Copilot

A local model runs on your computer or on a server you control, rather than sending each prompt to a cloud model provider. Some Copilot integrations can connect to models exposed through compatible local runtimes or providers. That does not mean the entire GitHub Copilot service is installed on your computer: the editor extension and the model connection are separate pieces, and Copilot features can rely on GitHub services for authentication, entitlement checks, model selection or other functionality.

It is also important to distinguish “use a local model” from “use Copilot completely offline.” A local model may generate a response without contacting a cloud model, while the extension may still need a working connection to sign in, verify access, retrieve settings or use a feature. Support can change as GitHub updates Copilot and editor integrations, so check the current documentation for the exact editor and feature you intend to use.

How the setup works

In a supported setup, the editor sends the conversation or coding context to a model provider configured for that integration. If the provider points to a local runtime, the model inference happens on your machine; the extension presents the response in the editor. The local runtime must already be installed, running and configured to offer a model the integration can reach. The precise steps and supported providers vary, so there is no single setup sequence that applies to every editor.

A practical setup usually involves these checks:

Confirm the current Copilot documentation lists local-model support for your editor and the specific feature, such as chat or completions.
Install and start a compatible local model runtime, then download a model that fits your computer’s memory and performance limits.
Configure the editor’s Copilot model or provider settings to use the local endpoint or provider, following the documented names and connection details.
Test a small, self-contained prompt and verify that the selected model shown in the editor is the intended local model.
Test again with the network disconnected only if you need to establish offline behavior; note which parts still fail or prompt for sign-in.

Do not assume that merely installing a local model changes Copilot’s default provider. If the editor still shows a cloud model, requests may continue to be handled remotely. Similarly, a model downloaded in one application is not automatically available to another; the editor must be configured to connect to its runtime.

What works offline—and what may not

When a compatible local model is already installed and running, generating text from that model can work without an internet connection. This is useful for drafting code suggestions or asking questions about text you provide locally. Offline use is most dependable after setup is complete, because initial downloads, extension installation and account authentication commonly require connectivity.

Other Copilot functions may not work offline, or may have different behavior. For example, cloud-hosted model choices need network access, and features that depend on GitHub-hosted context, remote repositories or online services cannot be presumed to work locally. Even if a local chat response works, that does not establish that inline completions, agent-like workflows, repository-wide context or every editor feature will work without a connection. Test each feature you depend on rather than treating “Copilot works offline” as a single all-or-nothing claim.

Also distinguish a computer with no internet access from a computer that can reach a local network. A model runtime may listen on a local address, but organizational network rules, firewalls or editor restrictions can affect whether the extension can connect to it. Follow your organization’s configuration policies.

Limits of local models

Local models can offer privacy and connectivity advantages, but their quality and speed depend on the model and hardware. Smaller models may be less capable at complex coding tasks than larger hosted models; large models can require substantial memory and may run slowly on ordinary laptops. Local inference also uses your machine’s processor, graphics hardware, memory and battery.

Other practical limits include:

Feature coverage: Local-model support may apply only to particular editor features, not every Copilot capability.
Context size: A model has a finite context window. Large files or long conversations may exceed it or be truncated.
Model compatibility: The integration may support only particular providers, model identifiers or connection methods.
Maintenance: You are responsible for obtaining, updating and storing the local model and keeping the runtime available.
Licensing and policy: Model licenses and workplace rules still matter. Local execution does not automatically grant permission to use model output or process sensitive code.

Local execution can reduce the need to send prompt content to a cloud model, but it is not a blanket privacy guarantee. The editor, extension, operating system and runtime may each handle data differently. Review the applicable product documentation and your organization’s rules before using confidential material.

Choosing between local and cloud models

Choose a local model when offline access, local control or limiting cloud-model processing is a priority and your hardware can run a suitable model. A hosted model may be more convenient when you need broader feature support, strong performance on difficult tasks or minimal setup. Some editors allow you to choose among providers or models, making a hybrid workflow possible: use local inference for appropriate tasks and a hosted option when the local model is not adequate.

Compare options by checking the specific feature you use, the model’s hardware requirements, context limits, response quality, data handling and whether the setup must work with the network disconnected. For work projects, include IT or security requirements in that decision. Copilot’s plan and organizational settings can affect access to features, but they do not by themselves make a local model run offline.

Common setup problems

The local model is unavailable: Check that its runtime is running, the model is downloaded and the configured endpoint matches the runtime’s current settings.
Copilot keeps using a hosted model: Recheck the selected model or provider in the editor and confirm that local-model selection is supported for that feature.
It works online but not offline: Authentication, entitlement checks, initial setup or a cloud-dependent feature may still need a connection. Identify the failing feature separately.
Responses are slow or weak: Try a model suited to your hardware and task, and reduce unnecessary context. A larger model is not automatically faster or better on a constrained computer.
The instructions do not match your editor: Copilot capabilities and settings change over time. Use current documentation for your editor and extension rather than copying steps for another integration.

Frequently Asked Questions

Can GitHub Copilot work with no internet?
Some supported configurations can use a local model for inference without internet access after setup. Sign-in, feature access and other Copilot functions may still need connectivity, so complete offline operation is not guaranteed.

Do I need a Copilot subscription to use a local model?
Requirements depend on the current editor integration and the Copilot feature. Check GitHub’s current plan and feature documentation; installing a local model alone does not establish Copilot access or entitlement.

Does using a local model mean my code never leaves my computer?
Not necessarily. The model inference may be local, but other extension or service functions can involve network requests. Check the data-handling documentation and confirm which model is selected before sharing sensitive code.

Can I use any model I have downloaded?
No. The model must be exposed through a provider or runtime supported by the specific Copilot integration, and it must fit your computer’s resources.

Will local models provide the same answers as Copilot’s cloud models?
No. Outputs vary with the model, its size, context window and hardware. A local model can be useful for routine tasks, but its performance and feature coverage may differ from hosted models.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.