What Model Does Copilot Use? A Complete Guide To Copilot's AI Models

Here is something that surprises most people: Copilot is not one AI model. It is a doorway to dozens of them. When you ask what model does Copilot use, the honest answer changes depending on which Copilot you opened, which button you clicked, and sometimes even what you typed. Microsoft and GitHub have both built model-switching directly into their products, so the same chat box might route your question to an OpenAI model one minute and an Anthropic model the next.

That flexibility is great for results but confusing for users. If you do not know which engine is running under the hood, you cannot explain why one answer feels sharp and the next feels shallow, why a coding suggestion appears instantly in one file and lags in another, or why your company pays different prices for different requests. This guide clears all of that up. You will learn which models power GitHub Copilot, Microsoft 365 Copilot, Copilot in Windows, and the free consumer app, how model routing actually works behind the scenes, how to switch models yourself, what each model is best at, the mistakes people make when choosing, and where all of this is heading next.

The Short Answer: Copilot Runs on a Mix of OpenAI, Anthropic, Google, and Microsoft Models

Copilot does not use a single AI model; it uses a rotating family of large language models, mainly OpenAI’s GPT series (including GPT-4o, GPT-4.1, GPT-5, and the o-series reasoning models), Anthropic’s Claude models, Google’s Gemini models, and Microsoft’s own in-house MAI models, with the specific model chosen by the product you are using, the plan you pay for, and the picker you select. That single sentence covers about ninety percent of what people actually want to know.

The reason for the mix is simple. Microsoft invested billions into OpenAI and gained deep access to its models, so OpenAI technology formed the original backbone of every Copilot product. But no single lab wins at everything. Anthropic’s Claude models earned a strong reputation for careful code editing and long, structured reasoning. Google’s Gemini models handle huge context windows and multimodal input well. Microsoft, meanwhile, started training its own MAI models to reduce dependence on any outside supplier and to cut costs on high-volume, low-difficulty requests.

So Copilot became a platform rather than a product tied to one brand. GitHub added a model picker to Copilot Chat. Microsoft 365 Copilot began routing certain agent tasks to Anthropic models. The consumer Copilot app quietly started using Microsoft’s own models for some responses. The result is a system where the answer to what model does Copilot use is best given as a short list rather than a single name.

Here is the quick map of which model families show up where:

GitHub Copilot – OpenAI GPT and o-series models, Anthropic Claude Sonnet and Opus, Google Gemini, plus a custom lightweight completion model for inline suggestions.
Microsoft 365 Copilot – primarily OpenAI models through Azure OpenAI Service, with Anthropic models available for some agent and Researcher scenarios.
Copilot consumer app and Copilot in Windows – OpenAI GPT models blended with Microsoft’s own MAI models, chosen automatically.
Copilot Studio (custom agents) – a selectable catalog of models you configure yourself.
Security Copilot – OpenAI models fine-tuned and grounded on Microsoft’s threat intelligence data.

Why Copilot Uses Several Models Instead of Just One

At first glance, running four or five model families looks like extra work. Wouldn’t one great model be simpler? In practice, the multi-model approach solves three real problems that a single model cannot.

The first problem is cost. Every request to a frontier model burns compute, and compute costs real money. If someone asks Copilot to convert Celsius to Fahrenheit, sending that to a giant reasoning model wastes resources. Microsoft routes simple requests to smaller, cheaper models and saves the heavyweights for hard problems. Industry estimates suggest that smart routing can cut inference costs by half or more without users noticing a quality drop, which matters enormously when a service handles hundreds of millions of requests a day.

The second problem is specialization. Models genuinely differ in personality and skill. Some write cleaner code diffs. Some summarize long documents more faithfully. Some follow multi-step instructions without drifting. By keeping several options available, Copilot can play to each model’s strengths instead of forcing one model to be mediocre at everything.

The third problem is risk. Depending on a single supplier for a product used by millions of businesses is dangerous. If one provider has an outage, changes pricing, or deprecates a model, the whole product suffers. A multi-model architecture gives Microsoft and GitHub a fallback path and negotiating leverage.

A Practical Example of Why This Matters

Imagine a developer named Priya working on a payments service. She types a few characters and Copilot instantly completes the rest of a function. That inline suggestion came from a small, speed-optimized completion model that responds in well under a second, because anything slower would break her typing flow. Ten minutes later, she opens Copilot Chat, switches to a reasoning model, and asks it to trace a race condition across four files. That request takes thirty seconds and costs far more compute, but it saves her two hours of debugging. Same product, same session, completely different models, and each one chosen for the job at hand.

Which Models Power GitHub Copilot for Developers

GitHub Copilot is the most transparent Copilot when it comes to models, because it literally shows you a dropdown. Depending on your plan, you can pick from a catalog that spans multiple AI labs. This is the clearest place to see the multi-model strategy in action.

Under the hood, GitHub Copilot splits into two very different experiences. Inline code completion, the gray ghost text that appears as you type, runs on a specialized model tuned for low latency and short outputs. Copilot Chat, edits, and agent mode run on full frontier models that you can select yourself.

The Model Picker Catalog

The exact lineup shifts as new models launch, but the categories stay stable:

Model Family	Typical Members	Best For
OpenAI GPT series	GPT-4o, GPT-4.1, GPT-5 class models	General coding, fast chat, broad language coverage
OpenAI reasoning series	o3, o4-mini and successors	Algorithm design, tricky debugging, math-heavy logic
Anthropic Claude	Claude Sonnet and Claude Opus tiers	Multi-file refactors, careful edits, long code reviews
Google Gemini	Gemini Pro and Flash tiers	Very large context, mixed text and image input
Built-in completion model	GitHub’s tuned inline model	Instant autocomplete inside the editor

How Plans Affect Your Choices

Not everyone sees the same list. GitHub structures access roughly like this:

Free tier – a limited monthly allowance of chat requests and completions, with access to a base set of models.
Individual paid plans – the full picker, plus a monthly budget of premium requests that heavier models consume faster.
Business and Enterprise plans – the full picker plus admin controls, so an organization can disable specific models or providers for compliance reasons.

That premium request system is worth understanding. Each model carries a multiplier. A lightweight model might cost a fraction of a request, while a top-tier reasoning model might cost several. If you burn through your allowance in week two, that is usually because you left the picker on the most expensive option for every trivial question.

The Models Behind Microsoft 365 Copilot in Word, Excel, and Teams

Microsoft 365 Copilot works differently from the developer version. There is no big model picker sitting in the corner of Word. Instead, Microsoft handles model selection for you and focuses your attention on the data grounding layer instead.

The core engine has historically been OpenAI’s GPT models, served through Azure OpenAI Service inside Microsoft’s own data centers. That detail matters for enterprises: your prompts and documents stay within the Microsoft cloud boundary and do not train the public models. Microsoft has expanded this by adding Anthropic models as an option for certain agent workloads and research features, letting administrators or users pick a different engine for specific deep-work tasks.

Grounding Matters More Than the Raw Model

Here is the part people miss. In Microsoft 365, the model is only half the system. The other half is the orchestration layer, sometimes called the Copilot system, which pulls relevant content from your emails, chats, files, calendar, and SharePoint sites before the model ever writes a word. That retrieval step, powered by Microsoft Graph and semantic search, is what makes Copilot answer questions about your quarterly report instead of the general internet.

Because of that, two people using the exact same underlying model can get wildly different quality. Someone with well-organized files, clear permissions, and descriptive document names gets sharp answers. Someone with a chaotic drive full of files named “final_v3_REAL.docx” gets vague ones. The model did not change. The context did.

Consider a real scenario. A project manager asks Copilot in Teams to summarize a client relationship. The orchestrator finds twelve emails, three meeting transcripts, and a proposal document, ranks them, trims them to fit the context window, and hands that package to the language model. The model then writes the summary. If a key email sat in a personal folder the Copilot cannot access, the summary will have a hole in it, no matter how advanced the model is.

How Copilot Decides Which Model Handles Your Request

When you do not pick a model yourself, something called a model router or orchestrator makes the choice for you. This is one of the most interesting and least understood parts of the whole system.

The router acts like a receptionist at a busy clinic. It looks at your request, estimates how hard it is, and sends it to the right specialist. A short factual question goes to a fast, cheap model. A request that involves planning, tool use, or multi-step logic goes to a stronger model. A request involving an image goes to a multimodal model.

Signals the Router Considers

Prompt complexity – length, number of steps implied, and whether the task needs reasoning or just recall.
Input type – plain text, code, images, files, or a mix.
Latency needs – inline autocomplete demands speed; a research report can wait.
Tool requirements – does the task need web search, code execution, or a connected data source?
Cost and quota – your plan tier and remaining premium request budget.
Safety filters – some content categories route through additional checking layers.

The Step-by-Step Flow

You submit a prompt in a Copilot surface such as chat, an editor, or a document.
The system adds a hidden system prompt that sets rules, tone, and available tools.
A retrieval step pulls relevant context from your files, repository, or the web.
The router scores the request and selects a model.
The model generates a response, sometimes calling tools mid-generation.
Safety and grounding filters review the output.
You see the final answer, often with citations or code diffs attached.

This is why the same question can produce different results on different days. A model may have been updated, the router may have chosen differently, or the retrieval step may have surfaced different documents. None of that is random, but it is invisible from the outside.

Comparing the Main Model Families Inside Copilot

Once you know you can choose, the natural next question is which one to choose. There is no universal winner, but there are clear tendencies that experienced users notice.

OpenAI’s general GPT models are the safe default. They handle a huge range of tasks well, respond quickly, support images, and rarely surprise you in a bad way. If you are unsure, start here. The reasoning-focused o-series models trade speed for depth. They think longer before answering, which helps enormously on logic puzzles, algorithm design, and bugs that involve subtle state changes, but feels sluggish for simple questions.

Anthropic’s Claude models built their reputation on careful, structured work. Many developers report that Claude models produce cleaner multi-file edits, follow detailed instructions more literally, and write more readable explanations. Google’s Gemini models shine when you throw enormous amounts of context at them, such as an entire documentation set or a very long transcript.

Task Type	Strong Choice	Why
Quick code autocomplete	Built-in completion model	Sub-second latency keeps you in flow
Explaining unfamiliar code	General GPT model	Fast, clear, good at plain-language summaries
Refactoring across many files	Claude Sonnet or Opus tier	Holds structure well and edits precisely
Hard algorithmic bug	OpenAI reasoning model	Extended thinking catches subtle logic errors
Reading a 300-page manual	Gemini Pro tier	Very large context window
Drafting an email or summary	Whatever the default is	All frontier models handle this easily
Bulk, repetitive low-stakes tasks	Small or mini model	Cheap, fast, good enough

One caution: these rankings shift every few months. A model that leads today may sit in third place after the next release cycle. Treat the table as a starting point, then test with your own real work.

Common Misconceptions About Copilot’s AI Models

Plenty of confident-sounding claims about Copilot models are simply wrong. Clearing these up saves a lot of frustration.

“Copilot Is Just ChatGPT With a Microsoft Logo”

This one is half true and mostly misleading. Copilot often uses OpenAI models, yes, but the product wraps those models in a completely different system: enterprise data grounding, permission checks, tool integrations, custom system prompts, and safety layers. Ask ChatGPT about your company’s Q3 budget and it knows nothing. Ask Microsoft 365 Copilot and it reads the actual spreadsheet you have permission to see. The model may overlap; the product does not.

“The Newest Model Is Always the Best Pick”

Newer usually means smarter on benchmarks, but benchmarks are not your workflow. A heavyweight reasoning model can overthink a two-line fix, produce a lecture when you wanted a snippet, and drain your premium request budget in the process. Match the model to the task size.

“Copilot Trains on My Code and Documents”

For business and enterprise plans, Microsoft and GitHub state that customer prompts and content do not train the foundation models. Consumer free tiers can have different terms, so read the plan details rather than assuming. This distinction drives most enterprise adoption decisions.

“Switching Models Fixes Bad Answers”

Sometimes it helps. More often, the real problem is a vague prompt or missing context. Before you swap engines, try adding the file, the error message, the constraints, and the desired output format. A clear prompt to a mid-tier model usually beats a lazy prompt to the best model available.

Here are the misconceptions in short form:

Copilot is not one model, and its default model changes over time.
The model name is not always shown in every Copilot surface.
Bigger models are not automatically better for small tasks.
Model choice matters less than context quality in document-based work.
Free and paid tiers do not offer identical models or identical data terms.

How to Check and Change the Model Copilot Uses

You have more control than you might think, though the level of control depends on which Copilot you use.

In GitHub Copilot Chat, inside VS Code, Visual Studio, JetBrains IDEs, or on github.com, look for a small model name near the chat input box. Click it and a dropdown lists every model your plan allows. Your choice usually sticks for that conversation, and you can switch mid-thread if the first answer disappoints. Agent mode and edit mode each remember their own selection, so check both.

In the consumer Copilot app and Copilot in Windows, you generally cannot name a specific model. Instead, you toggle modes such as a quick answer mode versus a deeper thinking mode. Choosing the deeper mode signals the router to send your request to a stronger reasoning model.

In Microsoft 365 Copilot, most model selection happens behind the scenes, but administrators can enable or disable certain providers, and some features like the Researcher agent let you choose which engine handles the job. In Copilot Studio, where you build custom agents, you get an explicit model selector plus settings for tone, grounding sources, and knowledge connectors.

A Practical Routine for Picking Models

Start every task on the default or a mid-tier fast model.
If the answer is close but shallow, improve your prompt before changing models.
If the task involves multi-step logic or many files, switch to a reasoning or Claude-tier model.
If you hit a context limit, move to a large-context model and trim irrelevant files.
Watch your premium request meter and drop back to cheaper models for routine work.
Keep a short personal note of which model wins for your recurring task types.

Prompting Tips That Work Across Every Model

State the goal, the constraints, and the output format in one message.
Paste the actual error text instead of describing it.
Reference specific files or ranges so retrieval pulls the right context.
Ask for a plan first on big tasks, then approve it before generation.
Give feedback in the same thread rather than starting over.

Enterprise Concerns: Privacy, Compliance, and Model Governance

For businesses, the question of what model runs Copilot connects directly to legal and security questions. Where does the model run? Who sees the data? Can we turn off a provider we have not approved?

Microsoft’s answer centers on the Azure boundary. Enterprise Copilot requests run inside Microsoft-managed infrastructure, not on a third party’s public endpoint, even when the model comes from another lab. Prompts and responses stay inside the tenant’s compliance boundary, honor existing permissions, and inherit data loss prevention and retention policies. Content from paying business customers does not feed foundation model training.

Permission inheritance deserves special attention. Copilot can only surface content the signed-in user already has rights to open. That sounds reassuring, and it is, but it also exposes over-sharing that already existed. If a sensitive folder was accidentally shared with the whole company three years ago, Copilot will happily find it. Many organizations discover their permission mess only after rolling out Copilot.

A Governance Checklist Before Rollout

Audit sharing permissions and clean up over-shared sites and folders.
Apply sensitivity labels to confidential content so policies travel with files.
Decide which model providers your compliance team approves, then restrict the rest.
Set expectations about premium request budgets to control spend.
Log and review agent activity, especially for agents that take actions.
Train staff that Copilot output needs human review before it goes to customers.

Consider a mid-sized finance firm that enabled Copilot for two hundred employees. In the first month, usage data showed most requests were routine summarization, which the router handled with cheaper models. Only about one request in six needed a heavyweight model. By coaching staff on prompting and setting a default to a faster model, the firm kept quality steady while avoiding a spike in premium usage. The lesson is that governance and model strategy work together, not separately.

Where Copilot’s Model Strategy Is Heading Next

The direction of travel is clear even if the details keep moving. Three trends stand out.

First, Microsoft keeps building its own models. The MAI family exists so Microsoft can control cost, latency, and availability for high-volume features. Expect in-house models to handle more everyday requests while frontier partner models take the hard cases. Users will mostly not notice the swap, which is the point.

Second, routing gets smarter. Instead of you choosing a model, the system will increasingly choose for you, sometimes splitting a single task across several models: a cheap model to plan, a strong model to write, a fast model to verify. Model choice becomes an implementation detail rather than a user setting, similar to how you no longer think about which server handles your web search.

Third, agents change the math. As Copilot moves from answering questions to completing multi-step work, one user request might trigger dozens of model calls. That makes efficient routing essential and pushes vendors toward specialized small models for narrow steps like classification, extraction, or validation.

What to Watch For

Model transparency features – clearer labels showing which model produced a given answer.
Bring-your-own-model options – enterprises plugging in approved models through Azure AI Foundry.
Longer context windows – full repositories and document libraries fitting in a single request.
On-device models – small models running locally on Copilot+ PCs for privacy and speed.
Cheaper reasoning – deep thinking becoming affordable enough to use by default.

The practical takeaway is that you should not build your workflow around one specific model name. Build it around clear prompts, good context, and a habit of testing. Those skills survive every model release.

Quick Answers to Common Questions

People tend to ask the same handful of follow-up questions once they understand the basics. Here are direct answers.

Does Copilot use GPT-4 or something newer?

Copilot has moved well past the original GPT-4. Current surfaces use newer GPT-generation models plus reasoning models, and the exact version rolls forward as OpenAI ships updates. If you need certainty, check the model picker in GitHub Copilot or your admin center in Microsoft 365.

Can Copilot use Claude or Gemini?

Yes. GitHub Copilot offers Anthropic Claude and Google Gemini models in its picker on eligible plans, and Microsoft 365 Copilot has added Anthropic models for certain agent and research scenarios.

Is the free version of Copilot using a weaker model?

Usually the free tier limits how many premium requests you get and how often you can reach the strongest models, rather than permanently locking you to a weak one. You still get capable models, just with tighter caps.

Why do I get different answers to the same question?

Three reasons: language models sample outputs probabilistically, the router may pick a different model, and the retrieval step may pull different context. Ask for the same output format each time to reduce variation.

Which model should I use for writing code?

Start with a fast general model for everyday work, switch to a Claude-tier model for large refactors, and reach for a reasoning model when a bug resists normal debugging.

Does model choice affect data privacy?

For enterprise plans, the privacy commitments apply across the supported models because requests run inside the Microsoft or GitHub service boundary. Still, some organizations restrict specific providers for policy reasons, so check with your admin.

So what model does Copilot use? It uses whichever one fits the moment. OpenAI’s GPT and reasoning models form the backbone, Anthropic’s Claude handles careful code and structured work, Google’s Gemini brings huge context, and Microsoft’s own MAI models quietly handle high-volume requests. GitHub Copilot lets you choose directly, Microsoft 365 Copilot chooses for you while focusing on grounding your data, and the consumer app hides the details behind simple mode toggles. Understanding that layout explains almost every quirk you will run into, from uneven answer quality to premium request limits.

The bigger lesson is that the model name matters less than how you use it. Clear prompts, good context, and the discipline to match the tool to the task will beat blindly selecting the biggest model every time. Models will keep changing, sometimes monthly, but those habits keep paying off. Start paying attention to which engine handles your work, run a few side-by-side tests on tasks you repeat often, and you will get noticeably better results from Copilot no matter what sits under the hood next year.