Here is something that surprises most people: there is no single answer to the question of what LLM does Copilot use. Microsoft’s Copilot family runs on a rotating cast of large language models from at least four different companies, and the model answering your question right now might be completely different from the one that answered it last month. That is not a bug or a marketing trick. It is a deliberate engineering strategy that lets Microsoft pick the sharpest tool for each specific job.
If you have ever wondered why GitHub Copilot suggests code so fast but Microsoft 365 Copilot takes a few seconds to summarize an email thread, the answer sits inside those model choices. In this guide, you will learn exactly which language models power each Copilot product, how the routing and orchestration layers decide what runs where, how Copilot compares to ChatGPT and Claude, which model you should pick for coding versus writing versus research, the myths that trip people up, and where Microsoft’s in-house models fit into the picture. By the end, you will understand the machinery well enough to get noticeably better results from whichever Copilot you use.
The Real Answer: Copilot Runs on a Rotating Fleet of Models
Copilot does not use one LLM. It uses a fleet of them, including OpenAI’s GPT-4o, GPT-4.1, GPT-5, and o-series reasoning models, Anthropic’s Claude Sonnet and Opus families, Google’s Gemini models inside GitHub Copilot, and Microsoft’s own in-house MAI and Phi models, with an orchestration layer choosing which one handles each request. Microsoft treats the underlying model as a swappable component rather than a fixed ingredient.
This makes sense once you look at how differently the Copilot products behave. GitHub Copilot’s inline code completions need to respond in a few hundred milliseconds, so they run on a small, heavily optimized model fine-tuned specifically on code. Meanwhile, a Microsoft 365 Copilot request that pulls together three documents, a chat thread, and a calendar entry needs deep reasoning and a large context window, so it routes to a frontier-class model. Using the same LLM for both tasks would either make completions painfully slow or make document analysis painfully shallow.
The other reason for the fleet approach is business risk. Microsoft invested heavily in OpenAI, but relying on a single supplier for a product line used by hundreds of thousands of companies creates leverage problems. Adding Anthropic and Google models to GitHub Copilot in 2024 and 2025, then bringing Anthropic models into Microsoft 365 Copilot and Copilot Studio, gave Microsoft negotiating room, redundancy, and a genuine quality advantage in areas where rival labs pulled ahead.
So when someone asks what LLM does Copilot use, the honest response is a question back: which Copilot, doing which task, on which subscription tier? The sections below break that down product by product.
GitHub Copilot: From Codex to a Multi-Model Marketplace
GitHub Copilot has the most transparent and most frequently updated model story of any Copilot product, largely because developers demanded that transparency. It also has the longest history, since it launched in preview back in 2021.
The early years: Codex and the first custom models
The original GitHub Copilot ran on OpenAI Codex, a descendant of GPT-3 fine-tuned on billions of lines of public code. Codex was remarkable for its time but limited: it had a small context window, no real chat interface, and it often lost the thread on anything longer than a single function. In 2023, GitHub moved completions to a custom-tuned model in the GPT-3.5 family that cut latency roughly in half while improving suggestion acceptance rates. Copilot Chat, launched around the same time, ran on GPT-4.
Today: pick your own model
The modern GitHub Copilot lets you choose your model from a dropdown in Visual Studio Code, Visual Studio, JetBrains IDEs, and github.com. The exact roster shifts as new models ship and old ones retire, but the categories stay stable:
- OpenAI general models — GPT-4o, GPT-4.1, GPT-5 and its mini variants. These handle the widest range of tasks and serve as the default for most users.
- OpenAI reasoning models — the o-series, including o3 and o4-mini. These think longer before answering and excel at algorithm design, debugging tricky logic, and multi-step refactors.
- Anthropic Claude models — Claude Sonnet 3.5, 3.7, and 4 plus Opus tiers. Developers frequently rate Claude highest for large refactors, following detailed instructions, and writing clean, idiomatic code.
- Google Gemini models — Gemini 2.0 Flash and Gemini 2.5 Pro. Gemini’s very large context window makes it useful for reasoning across sprawling codebases.
- Purpose-built completion models — a fine-tuned model marketed as GPT-4o Copilot powers the gray inline suggestions. It trades raw intelligence for speed, because a completion that arrives after you have already typed the line is worthless.
Here is a practical scenario. Imagine you are migrating a 4,000-line Python service from Flask to FastAPI. You might start with a reasoning model to plan the migration order and flag risky endpoints, switch to Claude Sonnet for the actual file-by-file rewrites because it follows long instruction lists reliably, and then lean on the fast completion model as you hand-polish the result. Three different LLMs, one task, and each one earns its place.
One important detail: premium models consume “premium requests” on paid GitHub Copilot plans. Each model carries a multiplier, so a heavyweight reasoning model burns through your monthly allowance faster than a lightweight one. That pricing structure quietly nudges people toward matching model power to task difficulty, which is exactly the right habit anyway.
Microsoft 365 Copilot and the Azure OpenAI Backbone
Microsoft 365 Copilot, the version living inside Word, Excel, PowerPoint, Outlook, and Teams, tells a different story. Microsoft has historically been vaguer here, describing the engine as “the latest OpenAI models” rather than naming versions, because enterprise customers care more about consistency and compliance than about model version numbers.
What we do know is that Microsoft 365 Copilot runs OpenAI models hosted on Azure OpenAI Service inside Microsoft’s own tenant boundary. Your prompts and your company data never travel to OpenAI’s consumer infrastructure, and Microsoft does not use your business data to train the foundation models. That hosting arrangement matters more to a CIO than whether the underlying weights come from GPT-4o or GPT-5.
The bigger shift came when Microsoft began adding Anthropic models to the mix. The Researcher agent in Microsoft 365 Copilot gained the option to run on Anthropic models, and Copilot Studio, the low-code tool for building custom agents, opened up model selection so builders can choose between OpenAI and Anthropic models for their own bots. Microsoft framed this as giving customers choice, but it also signaled the end of exclusive OpenAI dependence across the Office suite.
Just as important as the model is everything wrapped around it. Microsoft 365 Copilot combines:
- The LLM itself — the reasoning and language generation engine.
- Microsoft Graph — the index of your emails, files, meetings, chats, and contacts.
- The semantic index — a vector representation of your organization’s content that lets Copilot find conceptually relevant material, not just keyword matches.
- The orchestrator — the layer that interprets your prompt, decides what data to retrieve, builds the final prompt, and post-processes the response.
- Responsible AI filters — content classifiers and permission checks that run before and after generation.
That architecture explains a common complaint. People sometimes say Microsoft 365 Copilot feels less capable than ChatGPT even though it runs comparable models. Often the model is fine, and the retrieval step simply failed to surface the right document. Understanding this distinction saves enormous frustration, because the fix is usually a more specific prompt or a directly referenced file rather than a different model.
Consumer Copilot, Security Copilot, and the Rest of the Family
Beyond GitHub and Microsoft 365, Copilot branches into half a dozen other products, and each one makes its own model choices.
Microsoft Copilot for consumers
The free Copilot at copilot.microsoft.com, in the Edge sidebar, and in the Windows taskbar started life as Bing Chat, powered by GPT-4 and an internal orchestration system Microsoft called Prometheus. Prometheus paired the model with Bing’s live search index, which is why consumer Copilot could answer questions about current events long before ChatGPT could browse.
The consumer product has since moved through GPT-4 Turbo, GPT-4o, and GPT-5, and it now uses real-time routing. When you leave it on the default setting, a lightweight classifier decides in a fraction of a second whether your question needs a fast, cheap model or a slower reasoning model. Ask for a joke and you get the quick path. Ask it to compare two mortgage structures and it escalates to deeper reasoning. Some interfaces expose this as a “Think Deeper” or smart mode toggle so you can force the heavier path.
Security Copilot
Microsoft Security Copilot combines a frontier OpenAI model with a Microsoft security-specific model trained on threat intelligence signals. Microsoft has said it processes an enormous volume of security signals daily, and that domain data feeds the specialized layer. A general LLM can explain what a PowerShell command does; the security-tuned layer knows whether that exact command matches known attacker behavior in your environment.
Windows, Copilot+ PCs, and on-device models
Copilot+ PCs introduced something genuinely different: small language models running locally on the device’s neural processing unit. Microsoft’s Phi Silica, a compact model derived from the Phi research family, powers features like Recall’s semantic search, Click to Do, and live captions with translation. These never touch the cloud. So on a Copilot+ PC, some Copilot features run on a model measured in billions of parameters sitting on your laptop, while others still call out to a cloud model hundreds of times larger.
Other family members follow similar patterns. Copilot in Dynamics 365, Copilot for Sales, Copilot for Service, and GitHub Copilot Workspace all layer domain-specific retrieval and tooling on top of general-purpose LLMs. The pattern repeats: a strong base model plus domain data plus guardrails.
How Copilot Decides Which Model Answers Your Question
The routing layer is the least visible and most interesting part of the system. Here is the general sequence a request follows, simplified but accurate enough to be useful.
- Intent classification. A small, fast model reads your prompt and categorizes it. Is this a code completion, a factual lookup, a creative writing task, a multi-step reasoning problem, or a request to take an action?
- Grounding and retrieval. If the request needs external information, the orchestrator queries the relevant source: Bing for web results, Microsoft Graph for work data, the open files and repository for code.
- Permission trimming. In enterprise contexts, the system filters retrieved results against your actual access rights. Copilot cannot show you a document you could not open yourself.
- Prompt construction. The orchestrator assembles a final prompt combining your words, the retrieved context, system instructions, and conversation history.
- Model selection. Based on complexity, latency budget, cost, and any manual override you set, the system routes to a specific LLM.
- Generation and post-processing. The model produces a response, which then passes through safety classifiers, citation attachment, and formatting before it reaches your screen.
Latency budgets drive much of this. Inline code completions target well under a second, which rules out large reasoning models entirely. A Word document summary can take five or ten seconds without anyone complaining. An agent researching a topic across dozens of sources might run for minutes. Each budget maps to a different class of model.
Cost matters just as much. Running a frontier reasoning model on every trivial request would be financially ruinous at Microsoft’s scale, where Copilot handles enormous request volumes across Windows, Office, Bing, and GitHub. Routing cheap requests to cheap models is what makes free tiers possible at all.
Consider a real example. You type “summarize this thread and draft a reply” in Outlook. The classifier tags it as summarization plus generation. Graph pulls the thread and any linked attachments. Permission trimming confirms you can see everything. The orchestrator builds a prompt containing the thread plus your writing style signals. A mid-tier model generates the draft in about four seconds. Nothing about that flow requires a reasoning model that deliberates for thirty seconds, and using one would only annoy you.
Comparing Copilot’s Models: Which One Fits Which Job
Once you can pick your model, the obvious next question is which to pick. Model rankings shift constantly, but the general strengths of each family have stayed fairly consistent, and knowing them helps far more than chasing benchmark scores.
| Model family | Best at | Weaker at | Typical Copilot use |
|---|---|---|---|
| GPT-4o / GPT-4.1 | Balanced speed and quality, broad general knowledge, multimodal input | Very long deliberate reasoning chains | Default for chat, Office tasks, everyday coding questions |
| GPT-5 family | Stronger reasoning, better instruction following, fewer hallucinations | Higher cost and slightly slower on complex prompts | Default across newer Copilot surfaces and premium tiers |
| OpenAI o-series (o3, o4-mini) | Math, algorithms, debugging, multi-step planning | Speed, casual conversation, simple edits | Hard engineering problems in GitHub Copilot |
| Claude Sonnet / Opus | Long-context code work, careful instruction following, natural prose | Availability varies by plan and region | Large refactors, agent mode, Researcher agent |
| Gemini 2.5 Pro | Huge context windows, cross-file reasoning | Less consistent on niche frameworks | Whole-repository analysis in GitHub Copilot |
| Phi Silica and other SLMs | Instant local response, full privacy, zero network cost | Depth, general knowledge, complex reasoning | On-device Windows features on Copilot+ PCs |
A useful rule of thumb: match model weight to task ambiguity. If you know exactly what you want and just need it typed out, a fast model wins. If the problem is fuzzy, multi-step, or you genuinely do not know the answer yourself, spend the premium request on a reasoning model.
Developers who track this closely often report that the differences between top models on simple tasks are small enough to be invisible, while the differences on hard tasks are dramatic. That asymmetry is worth internalizing. Do not agonize over model choice for a docstring. Do think carefully before pointing a model at a 20-file refactor.
Also remember that model quality is not the only variable. Prompt clarity, the quality of the context you provide, and whether you are using agent mode versus simple chat can each swing results more than a model swap does.
Myths and Mistakes People Make About Copilot’s LLMs
Because Microsoft rarely publishes exact model version numbers for every surface, misconceptions spread quickly. Clearing these up will save you time and prevent bad decisions.
- “Copilot is just ChatGPT with a Microsoft logo.” The models overlap, but the products differ enormously. Copilot adds enterprise data grounding, permission enforcement, web search integration, IDE context, and compliance guarantees that ChatGPT’s consumer product does not provide in the same way.
- “Copilot always uses the newest OpenAI model.” Microsoft rolls out new models gradually across surfaces and regions. GitHub Copilot often gets new models first; enterprise Office deployments lag because stability matters more there.
- “Copilot trains on my company documents.” For Microsoft 365 Copilot and GitHub Copilot Business and Enterprise, Microsoft states that customer prompts and content do not train the foundation models. Consumer free tiers have different terms, so read those separately.
- “Picking the biggest model always gives the best answer.” Larger reasoning models can overthink simple requests, produce longer output than you wanted, and burn premium requests for no benefit.
- “All Copilot products share the same model.” They do not, and they never have. Security Copilot, GitHub Copilot completions, and Word’s rewrite feature run on entirely different engines.
- “If Copilot gets something wrong, the model is bad.” Often the retrieval step failed. The model can only reason over what the orchestrator handed it.
Another frequent mistake involves comparing Copilot output to a raw API call and concluding Copilot is weaker. Copilot layers system prompts, safety filters, and context injection on top of the base model. Those layers improve safety and relevance but do change the flavor of responses. That is a design choice, not a defect.
Finally, people sometimes assume the model dropdown in GitHub Copilot changes the inline completions too. In most implementations it does not. The dropdown controls chat and agent interactions, while completions continue to run on the dedicated low-latency completion model.
Getting Better Results From Whichever Model Copilot Uses
Knowing the model roster is only valuable if it changes how you work. These practices consistently produce better output regardless of which LLM sits underneath.
Feed the model better context
In GitHub Copilot, open the files you want considered, or reference them explicitly with the file picker. In Microsoft 365 Copilot, reference documents by name with the slash command instead of hoping semantic search finds them. Retrieval failures cause more bad answers than model limitations do.
Match the model to the task
Use fast models for boilerplate, renaming, formatting, and quick explanations. Escalate to reasoning models for architecture decisions, subtle bugs, performance analysis, and anything where being wrong costs you real time. This habit also stretches your premium request allowance across the month.
Write prompts that constrain the output
Specify format, length, audience, and constraints up front. “Rewrite this 600-word update as five bullet points for a non-technical executive, keeping the two budget figures exactly as written” beats “make this shorter” every single time, on every model.
Verify anything that matters
Every model in the Copilot fleet can hallucinate. Check generated code against tests. Check cited facts against the linked source. Check numbers in Excel against the underlying data. Treat Copilot as a fast, confident junior colleague whose work you always review.
One more tip that pays off immediately: when a model gives you a mediocre answer, do not simply retry with a bigger model. Instead, tell it what was wrong with the first attempt. A targeted correction on a mid-tier model usually beats a fresh attempt on a frontier model, and it costs less.
Where Copilot’s Model Strategy Is Heading
The most significant trend is Microsoft building its own frontier models. The Microsoft AI division, formed to unify consumer AI efforts, has shipped in-house models including a text model in the MAI family and MAI-Voice-1 for speech generation. Microsoft leadership has been open about wanting a self-sufficient in-house model capability rather than permanent dependence on a single partner.
Expect that to show up gradually inside Copilot rather than all at once. The most likely path is that Microsoft’s own models take over high-volume, lower-complexity workloads first, where cost savings are enormous and quality requirements are modest, while frontier partner models keep handling the hardest reasoning tasks. Voice features are an obvious early candidate, since Microsoft controls that stack end to end.
The second trend is intelligent routing becoming invisible. Rather than asking users to pick models, systems will increasingly decide automatically and correctly. GPT-5’s real-time router in consumer Copilot points in that direction. Manual model pickers will likely survive longest in developer tools, where users want explicit control and can judge results precisely.
The third trend is the continued rise of small on-device models. As NPUs get faster and small models get smarter, more Copilot features will run locally. That means lower latency, better privacy, offline capability, and dramatically lower cost per interaction. A realistic near-future setup has a local model handling roughly half of everyday requests and silently escalating the rest to the cloud.
Finally, agents change the equation. When Copilot runs a multi-step task autonomously, it may call several models within a single job: a planner model to break down the work, a coding model to execute, and a review model to check the output. In that world, asking which single LLM Copilot uses becomes almost as odd as asking which single employee runs a company.
Frequently Asked Questions About Copilot’s Language Models
These are the questions people ask most often once they start digging into Copilot’s architecture.
Does Copilot use GPT-4 or GPT-5?
Both, depending on the surface, your subscription, and the rollout schedule in your region. Newer Copilot surfaces default to the GPT-5 family, while some enterprise deployments and lightweight features still run GPT-4-class models for stability and cost reasons.
Does Copilot use Claude?
Yes. GitHub Copilot offers multiple Anthropic Claude models in its model picker, Copilot Studio lets agent builders select Claude models, and the Researcher agent in Microsoft 365 Copilot can run on Anthropic models. Availability depends on your plan and whether your admin has enabled it.
Can I see which model answered my question?
In GitHub Copilot, yes. The model picker shows your current selection, and responses indicate the model used. In consumer and Microsoft 365 Copilot, Microsoft generally does not surface the exact model version for each response.
Is Copilot’s model the same as the one in the OpenAI API?
The base weights are the same family, but Copilot wraps them in system prompts, retrieval, safety filters, and sometimes fine-tuning. Identical prompts can produce different results in Copilot versus a direct API call.
Does the model choice affect my data privacy?
Within enterprise Copilot products, Microsoft applies the same data protection commitments across models, including when third-party models are involved. Still, if your organization has strict requirements, ask your administrator which models are enabled and where they run, since some third-party models may be hosted outside Microsoft’s own infrastructure.
Which model should a beginner use?
Leave the default alone at first. The defaults are tuned to be a strong balance of speed, cost, and quality. Once you notice a specific weakness, like struggling with a complex refactor, switch to a reasoning or Claude model for that task and compare.
The question of what LLM does Copilot use turns out to be a doorway into how modern AI products actually work. Copilot is not a single model with a friendly interface. It is a system: an orchestrator that classifies your intent, retrieval layers that pull in the right context, permission checks that keep your data safe, and a fleet of language models from OpenAI, Anthropic, Google, and Microsoft that each handle the jobs they do best. GitHub Copilot exposes that fleet directly through a model picker; Microsoft 365 Copilot and consumer Copilot hide it behind automatic routing; Copilot+ PCs run some of it locally on your own hardware.
Understanding this changes how you use the tool. You stop blaming “the AI” when something goes wrong and start asking better questions: did it get the right context, did it use the right model, did I give it clear enough instructions? Those questions lead to real improvements. And as Microsoft keeps expanding its in-house models, sharpening its routing, and pushing more work onto devices, the fleet will only grow more varied and more capable. Stay curious about what is running under the hood, experiment with the models you can control, and you will get consistently more out of Copilot than people who never look past the chat box.
