GitHub Copilot Free in 2026: Every Limit, AI Credits, Models (and the October 19 Retirements), Free Pro for Students, Your Data, and Free Local Models in VS Code

GitHub Copilot Free is a $0 plan for individual developers. It gives you up to 2,000 code completions a month and a small allowance of chat and agent requests (up to 50 chat requests a month), with the model chosen automatically for you. It works in VS Code, Visual Studio, JetBrains IDEs and more, includes agent mode, MCP and the Copilot CLI, and resets every month. It leaves out the cloud agent, pull request code review and picking premium models, which start with Copilot Pro at $10 a month. Verified students get a free student plan, and verified teachers and maintainers of popular open-source projects can get Pro free. Two things most guides miss: since April 24, 2026, your Copilot interactions on Free, Pro, Pro+ and Max may be used to train models unless you switch that off in your Copilot settings, and VS Code can run chat with local models through Ollama with no Copilot plan at all, so running out of free requests does not have to stop you. Below: every limit, the AI credit system, the models retired on October 19, setup in each editor, what to do when you hit the cap, and Free vs Pro.

Ethan writes the small programs that keep Jake's computer shop running: the inventory sheet importer, the repair-ready text messages, a script that renames photos of customers' laptops. He started using Copilot Free in VS Code in September and loved it, right up to the evening in mid-October when the chat panel told him he had used his monthly allowance. Jake's reaction was practical: "Do we pay ten dollars, or is there a free way?" There turned out to be both, and a setting about his code he had never seen. This page is what he found.

New to AI coding tools, or to running models on your own computer? Our free guide series covers the basics, and the cards below fill in the rest.

What GitHub Copilot Free is (and which Copilot this is)

GitHub Copilot is an AI assistant for writing code, made by GitHub. It suggests the next lines as you type (code completions), answers questions about your code in a chat panel, and in agent mode can make changes across several files, run commands and fix its own mistakes until a task is done. Copilot Free is the no-cost plan: the same tool, with monthly limits.

The name causes real confusion, so one clarification first. Microsoft also sells "Copilot": the assistant in Windows, Edge and Microsoft 365, and "Copilot+ PCs" with a special chip. Those are different products. GitHub Copilot is for programmers and lives in code editors. If you landed here looking for the Windows one, our Copilot+ PC explainer is the page you want.

Copilot Free is for individual developers. If your GitHub account already gets Copilot through a company or organization (Copilot Business or Enterprise), you use that instead, and Copilot Free is not offered to that account.

Jake: "So it's the same Copilot as the paid one, just with a meter?"

Ethan: "Same engine, smaller tank. And on Free it picks the model for you."

Copilot Free limits: completions, chat and the monthly reset

How far do 2,000 completions go? A completion is counted each time Copilot shows you a suggestion, not only when you accept it. Someone writing code for an hour or two a day can use 2,000 in two to three weeks; an occasional coder rarely reaches it.

And 50 chat requests? Each message you send in chat counts, and in agent mode one task can involve several requests behind the scenes. Fifty is enough to try everything and to ask for help a couple of times a working day. It is not enough to build a project mostly by conversation, which is where people like Ethan run out.

When does it reset? Monthly, counted from the day you first signed up for Copilot Free, not on the first of the month. In VS Code, hover over or click the Copilot icon in the status bar at the bottom of the window to see how much of each allowance is left.

The two limits are separate. Use up chat and completions keep working; use up completions and chat keeps working.

Copilot Free vs Pro vs Pro+ vs Max

For teams, Copilot Business is $19 per user per month with 1,900 credits each, and Copilot Enterprise is $39 per user per month with 3,900 credits each. Those plans add central billing, policies, and protection of company data under GitHub's data protection agreement, which matters for the training question below.

AI credits, explained without the jargon

Copilot now measures chat and agent use in AI credits, and one credit is worth one US cent ($0.01). Each plan includes a monthly amount: Pro's 1,500 credits are $15 worth of use, made of 1,000 base credits plus 500 "flex" credits. Pro+ includes 7,000 (3,900 plus 3,100 flex), and Max 20,000.

How many credits a request costs depends on two things: the model you choose and how much work the task is. A quick question to a lightweight model costs a fraction of a credit; a long agent task with a premium model can cost many. Two things never cost credits on paid plans: code completions and "next edit suggestions," which stay unlimited.

When the monthly credits run out, you choose: wait for the reset, set a dollar budget so extra use is billed at $0.01 a credit, or switch to a cheaper model for the rest of the month. Setting a budget is worth doing even if you never plan to use it, because a budget of $0 means nothing extra is ever charged by surprise.

On Copilot Free, the allowance is simply a fixed amount of use with no option to buy more on the Free plan itself; going further means upgrading.

Which models Copilot Free uses, and the October 19, 2026 retirements

On Free, Copilot uses Auto model selection: GitHub picks a model for each request from its current lineup, balancing speed and quality. You cannot pin a specific model on Free. The paid plans let you pick from models by OpenAI, Anthropic, Google, xAI, Kimi and Microsoft, with the most expensive "premium" models reserved for Pro+ and Max.

That lineup changes often. On October 19, 2026, GitHub retired six older models across every Copilot experience, including chat, inline edits, ask and agent modes, and code completions:

On Free this needs no action, because Auto simply stops choosing the retired models. On a paid plan, if you had picked one of them, select its replacement in the model picker. Business and Enterprise users get the replacements switched on automatically unless an administrator turned off the default.

Can you use Anthropic's models on Copilot Free? Not by choosing them. Auto may route a request to any model in the lineup, but picking a specific model, including Anthropic's Opus 5.5, needs a paid plan. If you want a particular model and do not want to pay for Copilot, the "bring your own key" option in VS Code (below) lets you connect that provider's API with your own account and pay the provider directly.

How to get Copilot Free in VS Code, Visual Studio, JetBrains and other editors

You need a free GitHub account. Then, in the editor you use:

• VS Code: Copilot is built in. Hover over the Copilot icon in the status bar at the bottom, choose Use AI Features, and sign in with GitHub. If you have no paid plan, Copilot Free is set up for you.
• Visual Studio (Windows): open the Copilot badge in the upper-right corner and follow the "Get started with Copilot Free" dialog, signing in with GitHub (or Google, which creates a GitHub account).
• JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm, Rider and the rest): install the GitHub Copilot plugin from Settings → Plugins, restart, and sign in to GitHub when prompted.
• Eclipse and Xcode: install GitHub's official Copilot extension for the editor and sign in the same way.
• Terminal: the Copilot CLI works on Free too, for asking questions and running agent tasks from the command line.
• GitHub.com: the Copilot chat on the website and in GitHub Mobile draws on the same allowance.

There is nothing to "download" separately for Free: it is the same Copilot extension or plugin, and the plan is attached to your GitHub account. The usage you see in one editor is shared across all of them.

Jake: "So if you use it at home on the laptop and here on the shop PC?"

Ethan: "Same account, same allowance. The meter follows me, not the computer."

The Copilot CLI on the Free plan

The Copilot CLI brings the agent into your terminal: you describe a task in plain English, and it reads files, proposes commands and edits, and asks before running anything. It works on Copilot Free, drawing on the same monthly allowance as chat. Install it with whichever tool you already use:

winget install GitHub.Copilot          # Windows
brew install copilot-cli               # macOS and Linux with Homebrew
npm install -g @github/copilot         # any system with Node.js 22 or later

Then run copilot in a project folder and sign in with your GitHub account when asked. On Windows, it needs PowerShell 6 or later, not the Windows PowerShell 5.1 that ships with Windows 11; install the current PowerShell with winget install Microsoft.PowerShell and run the CLI from that.

Because one terminal task can take several requests, the CLI is the fastest way to use up a Free allowance. It shines for jobs like "find why this script fails on files with spaces in the name and fix it," where it can run the script, read the error and try again. For quick one-line questions, chat in the editor costs less of the meter.

The GitHub Copilot app (desktop) on the Free plan

Since July 7, 2026, the GitHub Copilot app, a desktop app for running agent tasks outside your code editor, is available on every Copilot plan, including Copilot Free and GitHub Education. It runs on Windows, macOS and Linux; you download it from gh.io/app, sign in with your GitHub account, and start describing work for the agent to do in a project folder.

Three points matter on the Free plan:

• It uses your Copilot allowance like any other agent request. Agent tasks take several requests each, so on Free the app suits occasional, well-defined jobs rather than all-day use.
• Bring your own key works here too. You can point the app's sessions at your own model provider's account, which runs without a Copilot subscription and bills that provider instead.
• Work accounts may not see it. On Copilot Business and Enterprise, an administrator has to enable the Copilot CLI in the organization's policy settings before the app works, so "it does nothing after sign-in" on a work account is usually a policy, not a bug.

Which to use when? The editor is best while you are writing code yourself, the CLI when you already live in a terminal, and the desktop app when you want to hand over a task and look at the result afterwards. All three draw on the same account, so trying each costs nothing extra beyond the requests themselves.

What Copilot Free handles well: real examples

Limits are easier to judge with concrete jobs in mind. These are the kinds of tasks Ethan used Copilot Free for at the shop, and how they went:

• Writing a regular expression to pull the model number out of laptop listing titles. One chat request, with three example titles pasted in. Copilot wrote it and explained each part.
• Explaining an error message from a Python library he had never used. One request, with the full error text and the line that caused it.
• Converting a spreadsheet export from one CSV layout to another. Mostly completions: he wrote the first column mapping, and Copilot suggested the rest.
• Adding tests to the photo-renaming script. Two requests: one to write them, one to fix a test that assumed Windows paths.
• A bigger refactor across five files in agent mode. About a dozen requests in one evening, which is where his allowance went.

The pattern: Copilot Free covers small, frequent help almost indefinitely. Large agent tasks are what drain it, and those are exactly the jobs where deciding between a local model, waiting, and paying is worth a moment's thought.

Learning to code with Copilot Free without letting it think for you

Copilot Free is a wonderful tutor and a terrible crutch, and which one you get depends on how you use it. Beginners who accept every gray suggestion finish exercises quickly and learn very little. A few habits keep the learning in your head:

1. Turn completions off while you do exercises. Use the Copilot icon in the status bar to switch them off for the language you are practicing, and switch them back on for real projects.
2. Write your attempt first, then ask. Select your code and use /explain in chat, or ask "what is wrong with my approach?" rather than "write this for me."
3. Ask for hints, not answers. "Give me a hint, not the solution" works surprisingly well, and one hint costs one request instead of a full rewrite you would not understand.
4. Use /fix and then explain it back. When Copilot fixes a bug, write one sentence in a comment saying why the fix works. If you cannot, ask it to explain before moving on.
5. Let it write the boring parts. Tests (/tests), docstrings and repetitive data are fair game once you understand the code they belong to.

This also happens to be the cheapest way to use the Free allowance: a learner asking good questions spends a handful of requests a day, far below the limit. If you are a student, the free student plan below removes the limits altogether, but the habits are worth keeping either way.

Jake: "Could my nephew use it for his programming class?"

Ethan: "With the suggestions switched off for homework, yes. Otherwise Copilot passes the class and he doesn't."

Free Copilot Pro for students, teachers and open-source maintainers, and the Pro trial

Three groups can get more than Free without paying:

• Students: verified students on GitHub Education get the free Copilot Student plan. You apply through GitHub Education with proof of enrollment, such as a school email address or a student ID.
• Teachers: verified teachers on GitHub Education may get Copilot Pro free.
• Open-source maintainers: maintainers of popular open-source projects may qualify for free Copilot Pro.

GitHub rechecks eligibility every month, so access can end when you graduate or a project's status changes. If you qualify, a page titled "GitHub Copilot Pro" tells you so; open Copilot settings from your profile picture and choose to get access.

The Copilot Pro free trial. Anyone else can try Pro free for 30 days, once per account. You enter a payment method when you start, and the subscription begins charging when the trial ends unless you cancel before then. If you start a trial to test whether Pro is worth it, put a reminder in your calendar for day 28. If "start free trial" does not appear, the usual reason is that the account already had a trial, or already has Copilot through an organization.

Does Copilot Free use your code to train AI? How to opt out

Yes, by default, and this is the part of Copilot Free most people have not noticed. Starting April 24, 2026, GitHub may use your interactions with Copilot on the Free, Pro, Pro+ and Max plans to train and improve AI models. That covers what you type to Copilot, what it answers, code snippets, and the surrounding context it sees.

To switch it off:

1. On GitHub.com, click your profile picture in the upper-right corner.
2. Choose Copilot settings.
3. Find Allow GitHub to use my data for AI model training.
4. Set the dropdown to Disabled.

The setting applies to your account everywhere you use Copilot. Copilot Business and Enterprise do not show it, because company data on those plans is covered by GitHub's data protection agreement instead. If you write code for clients or an employer on a personal Free account, that difference is worth raising with them.

On the same settings page, Suggestions matching public code controls whether Copilot may suggest code that matches public code on GitHub. Set to Block, Copilot checks each suggestion (with about 150 characters around it) against public code and hides close matches, which reduces the chance of pasting someone else's licensed code into your project.

And if your code should never leave your computer at all, the local option in the next sections keeps it there.

Jake: "Wait, our customer database code went to train somebody's AI?"

Ethan: "Since April, unless I turned it off. I just did. And the customer-data scripts go to the local model from now on."

Make the free allowance last the whole month

Most people who run out of Copilot Free are not using it more than others; they are spending it on things that do not need it. Four habits stretch the same allowance much further.

1. Turn completions off where you do not need them. Every suggestion shown counts against the 2,000, including the ones Copilot offers while you write notes, README files or plain text. In VS Code, open your settings as JSON (Command Palette, Preferences: Open User Settings (JSON)) and list the languages to skip:

"github.copilot.enable": {
  "*": true,
  "markdown": false,
  "plaintext": false,
  "yaml": false
}

You can also switch completions off for the current language from the Copilot icon in the status bar, which is handy when you are writing documentation for an afternoon.

2. Give Copilot your context once, in a file. Much of a chat allowance goes on repeating the same background: "we use Python 3.12, keep functions short, our tests use pytest." Put that in a file named .github/copilot-instructions.md in your project, and Copilot Chat reads it with every request. Fewer follow-up messages means fewer requests. A short example:

# Project notes for Copilot
- Python 3.12, standard library first; ask before adding packages.
- Small functions with type hints. Tests use pytest in tests/.
- Customer phone numbers in logs: mask all but the last 4 digits.

3. Ask complete questions. "Fix this" followed by three rounds of "no, the other error" costs four requests. One message with the error text, the file (type # in chat to attach a file) and what you expected usually gets it in one.

4. Send long conversations to a local model. Brainstorming, explaining a library, drafting a script from scratch: these long back-and-forth sessions eat chat allowances fastest, and a local model handles them well. Save Copilot's requests for the hard bug where the strongest model matters. The local setup is below.

Jake: "So half the meter was going on your shopping-list notes?"

Ethan: "Markdown files, yes. Copilot was politely suggesting groceries. It doesn't anymore."

You hit the Copilot Free limit: your four options

When an allowance runs out, the chat panel or status bar tells you, and that part of Copilot stops until the reset. Your options, cheapest first:

1. Wait for the reset. Check the date in the Copilot status bar menu. If it is a few days away and the work can wait, this costs nothing.
2. Switch chat to a free local model in VS Code, using Ollama. No Copilot plan or request limits, and your code stays on your computer. Completions still come from Copilot until those run out. The setup.
3. Bring your own key for a provider you already pay for, such as OpenAI, Anthropic, Google or Azure, and use their models in Copilot Chat, billed by them.
4. Upgrade to Pro ($10 a month) for unlimited completions and 1,500 credits, or start the one-time 30-day trial.

"I upgraded, but it still says I'm out." This one confuses many people: you bought Pro, yet VS Code still shows the Free limit message. The editor is still using the sign-in it had before the upgrade. Click the Accounts icon at the bottom of the left sidebar, sign out of GitHub, sign back in, and run Developer: Reload Window from the Command Palette (Ctrl+Shift+P). If you have more than one GitHub account, make sure the one that holds the subscription is the one signed in.

Keep coding for free: local models in VS Code with Ollama

VS Code's chat can use models from providers other than GitHub, a feature called bring your own key (BYOK), and those models work without signing into GitHub and without any Copilot plan. The most useful version for a free setup is a model running on your own computer through Ollama: no request limits, no monthly bill, and nothing leaves your machine.

What you need: VS Code 1.127 or newer, Ollama installed and running (0.17.6 or newer; current versions are better, and our Ollama update guide covers that), and enough memory for a coding model. Our local AI tools comparison explains where Ollama fits if you have not used it.

1. Download a coding model in Ollama, for example: ollama pull qwen3.6. Pick a size that fits your memory; 16 GB of RAM or an 8 GB graphics card handles the smaller sizes comfortably.
2. Raise Ollama's context length. Coding chats need room for files. In the Ollama app's Settings, set the context length to at least 64K (on a server, OLLAMA_CONTEXT_LENGTH=65536). Larger contexts use more memory, so step down if the model slows to a crawl.
3. Install the Ollama extension in VS Code: open the chat panel, click the model picker at the bottom of the chat input, open the gear (or run Chat: Manage Language Models from the Command Palette), choose Install Model Providers, and install the extension published by Ollama. Older setups used a built-in Ollama provider, which is deprecated; if you configured that before, remove it.
4. Pick your model from the Ollama section of the model picker, and chat as usual. If the models do not appear, reload the window.

What works and what does not:

• Chat and questions about your code: yes.
• Agent mode: only with models that support tool calling. A model without it simply does not appear for agents.
• Inline completions (the gray suggestions as you type): no. VS Code cannot use a local model for those; they still come from your Copilot plan.
• Features that need GitHub's servers, such as semantic search across a repository, still need a GitHub account and plan.

If you also want local inline completions, the open-source Continue extension can use an Ollama model for tab completion, with a small, fast coding model (around 1.5 billion parameters) handling autocomplete. And if you prefer an agent in the terminal, our OpenCode guide shows a free open-source coding agent running on Ollama models.

The office version. A small team can share one stronger machine instead of each laptop running its own model: run Ollama on a PC with a good graphics card, and point everyone's editor at it. Our Ollama in Docker guide sets that up, including how to keep it private to your network.

Jake: "So the AI in the back room can help you write code too?"

Ethan: "Chat, yes, as much as I want. The quick suggestions while I type stay with Copilot. Between the two, I'm not paying anything this month."

Free local inline completions with Continue and Ollama

Copilot cannot use a local model for the gray suggestions that appear as you type. If you want those to be free, unlimited and private too, the open-source Continue extension fills exactly that gap. It works in VS Code and JetBrains IDEs and talks to Ollama.

1. Pull a small, fast code model made for completion. Autocomplete has to answer in a fraction of a second, so small beats clever here: ollama pull qwen2.5-coder:1.5b-base is about 1 GB and runs well even on a laptop processor.
2. Install Continue from the VS Code Extensions view (search "Continue") or JetBrains' plugin marketplace.
3. Tell Continue to use that model for autocomplete. Open Continue's settings and edit its config.yaml:

name: Local Assistant
version: 1.0.0
schema: v1
models:
  - name: Qwen2.5-Coder 1.5B
    provider: ollama
    model: qwen2.5-coder:1.5b-base
    roles:
      - autocomplete

4. Switch Copilot's completions off, so two engines are not competing to suggest the same line. In VS Code settings JSON: "github.copilot.enable": { "*": false }. Copilot Chat keeps working; only its inline suggestions stop.

Start typing in a code file, and suggestions now come from your own computer. The -base version of the model is used on purpose: base models are trained to continue code, which is exactly what autocomplete needs, while chat versions are tuned to answer questions.

Local completions are a little less clever than Copilot's on unusual code, and they are only as fast as your hardware. On a machine with a graphics card they feel instant; on an older laptop processor there can be a short pause before each suggestion. Try it for a day before deciding.

Which local coding model fits your computer

The model you can run depends on memory: graphics card memory (VRAM) if you have a dedicated card, or unified memory on Apple silicon Macs. A rough guide for coding chat:

Two things matter as much as the parameter count. First, the context length you give the model: a 64K context for coding takes several extra gigabytes, so a model that fits with a small context may not fit with a large one. Second, agent mode needs a model with tool calling, so check that the model's page in Ollama's library lists the "tools" capability. If you are thinking about new hardware for this, our local LLM laptop guide goes through what each price point buys; and if JetBrains is your editor, its own small local completion model is covered in our Mellum guide.

Using Copilot Free for work or a small business

Copilot Free is meant for individuals, but plenty of freelancers and one-person businesses use it for paid work, and nothing in the plan forbids that. Three things are worth weighing before you do:

• Your client's code and the training setting. On personal plans, Copilot interactions may be used for training unless you switch it off. If a client's contract says their code must not be shared with third parties, turn the setting off on day one, or keep their work on a local model entirely.
• Accounts that belong to the company. When a business has several people coding, Copilot Business ($19 per user per month) gives central billing, the ability to add and remove people, policies such as which models are allowed, and company data covered by GitHub's data protection agreement rather than the training opt-out.
• Who owns the account. If an employee uses a personal Free account for company work and then leaves, the account, its settings and its history leave with them.

For Jake's shop, with one part-time developer, Ethan's personal account with training switched off is reasonable. If the shop ever hires a second developer, Business is the cleaner setup.

Local model vs Copilot's cloud models: an honest comparison

The sensible mix for most people on a budget: Copilot Free for inline completions and the occasional hard question, a local model for everyday chat and anything private. If you later find yourself running out every month and the local model is not enough, that is the moment Pro pays for itself.

Copilot Free vs Pro: is $10 a month worth it?

Pro is worth it when any of these is true:

• You run out of completions before the month ends. Unlimited completions alone justify it for daily coders.
• You want to choose the model for a task, for example a stronger model for a tricky bug.
• You want the cloud agent: assign a GitHub issue to Copilot and get back a pull request.
• You want Copilot to review your pull requests.
• Your time is billed: ten dollars is less than ten minutes of most professionals' time.

Free is enough when you code a few hours a week, when you are learning, or when you pair it with a local model for chat as above. Many people stay on Free for months, upgrade during a big project, and drop back afterwards; there is no penalty for switching.

Pro+ at $39 makes sense for heavy agent use and premium models every day; Max at $100 for people who effectively run agents all day. If you are wondering whether you need those, you almost certainly do not yet.

Copilot Free not working: common causes and fixes

When the editor itself seems confused, the extension is usually out of date. In VS Code, open Extensions, check that GitHub Copilot Chat has no pending update, and restart. In JetBrains IDEs, update the plugin from Settings → Plugins.

The GitHub Copilot certification (GH-300)

If "GitHub Copilot certification" brought you here: GitHub offers a certification exam, GH-300: GitHub Copilot, delivered through Microsoft's certification system. It costs about $99 in the US (prices vary by country) and covers how Copilot works, its plans and features, how it handles data and privacy, content exclusions, responsible AI, and using it for development and testing. Recent updates added Copilot's agent mode, CLI and MCP.

Copilot Free is enough to practice most of what the exam asks about, because agent mode, MCP and the CLI are all included. For the plan comparisons and data-handling questions, the limits table and the training setting on this page are exactly the kind of detail it tests.

Frequently asked questions

Ethan's October ended without a bill. He switched the training setting off, moved chat to the back-room model for anything touching customer data, and kept Copilot Free for the gray suggestions as he typed, which lasted the month once chat was not eating into his time with it. "If the big project in November needs more," he told Jake, "I'll do the trial and decide." Jake wrote "day 28: cancel or keep" on the calendar before Ethan had finished the sentence.

Revision note. Written October 19, 2026, the day GitHub retired six older Copilot models. Free is the right price for trying almost anything; the trick is knowing exactly where it stops.