Inter-office memo
- To
- Everyone whose GitHub Copilot AI credits run out too soon
- From
- Mo, Chief Executive
- Date
- November 16, 2026, 1:41 PM CST
- Re
- Making Copilot’s AI credits last
How to make GitHub Copilot’s AI credits last longer in 2026: 12 ways compared
Check the AI usage page, then match the model to the job: GitHub lists GPT-6 Luna at $0.10 per million input tokens and Claude Opus 5.5 at $4, and Fusion takes 30% off on paid plans through November 30, 2026. A new chat per task, one model per session and a session limit do most of the rest. If you pay for Claude or ChatGPT too, Claude Code or Codex can take the agent work; Enjoy runs both, not Copilot.
Disclosure: Enjoy is our product, and it runs Claude Code and Codex, not GitHub Copilot. We checked every price, limit and command below against GitHub’s, Microsoft’s, Anthropic’s and OpenAI’s own pages on November 16, 2026, and we say where another way is the better pick, including the free ones that don’t need Enjoy.
The ways to make Copilot’s credits last, compared
Copilot bills chat and agents by the token. Each model has its own price, “and the total is converted into AI credits, where 1 AI credit = $0.01 USD,” says GitHub’s price list. Your plan’s allowance resets “at 00:00:00 UTC on the first day of each calendar month,” and “Included AI credits do not carry over between months,” says its billing page. Suggestions as you type are the exception: “Code completions and next edit suggestions are not billed in AI credits and remain unlimited for all paid plans.” So making credits last means spending fewer tokens on chat and agents, or sending that work somewhere else.
| Way | Cost, checked November 16, 2026 | What it cuts | Best for |
|---|---|---|---|
| See where they go: AI usage, /context and /chronicle | Free | Nothing by itself: it shows which models and sessions cost most | Not knowing where the month went |
| Match the model to the task | Free | The price per token: $0.10 per million input tokens for GPT-6 Luna, $4 for Claude Opus 5.5 | Routine, well-scoped changes |
| Copilot Fusion or Auto | Free; 30% off model costs with Fusion through November 30, 10% with Auto | The model bill, by the discount | Not wanting to pick a model each time |
| A new chat for each task, compacted when long | Free | History sent with every request | Sessions that run all day or wander |
| One model, effort and tool set per session | Free | Cache rebuilds billed as fresh input | Switching models or effort mid-task |
| Trim what loads with every request | Free | Tools, MCP servers, search noise and instructions | Many MCP servers, big repositories |
| Scope the task, and plan the big ones | Free | Retries, drift and redone work | Vague or wide changes |
| Cap each session, and get warned | Free | A runaway task, a surprise at month’s end | Long agent runs in Copilot CLI |
| Turn code review down to Lite | Free | About $0.25 a Lite review on average, against $1.50 Balanced and $10 Max | Automatic reviews on every pull request |
| A local model | Free, on hardware you own | Requests move off GitHub’s hosted models | Ollama users, and Windows PCs with big NVIDIA GPUs |
| Claude Code or Codex, on their own plans | Claude Pro $20 a month, or $17 billed yearly; ChatGPT Plus $20 | Agent work moves off your credits | A Claude or ChatGPT plan you already pay for |
| Enjoy | A monthly subscription, free for 7 days, with your phone and one computer (pricing) | Runs Claude Code and Codex on their own plans side by side, with every account’s limits in view | Spreading agent work across labs |
Prices are each company’s US list prices, before tax. The first ten ways are settings and habits in Copilot itself, and cost nothing extra.
Why Copilot’s credits run out so fast
GitHub’s billing page names three things: “Conversation length and complexity,” “Agentic features,” and “Model choice.” Agents are the big one: “A complex agentic session working across a large codebase will consume significantly more usage than a quick question in chat.” In June, one student reported that “around 10 to 20 requests” in Agent Mode used a month’s 200 credits, and the thread has more than 140 comments.
Pro is $10 a month for 1,500 credits, Pro+ $39 for 7,000, and Max $100 for 20,000. Each is base credits that “match with your subscription price and they never change,” plus a flex allotment, which “is designed to adapt as the economics of AI evolve.” Copilot Free and Student get “an allowance of AI credits,” which GitHub doesn’t size, and models “through auto model selection only.” Business and Enterprise seats have per-user allowances, pooled across the company.
See where they go: AI usage, /context and /chronicle
Best for: finding out which models, sessions and habits are spending the month.
On an individual plan, open github.com/settings/billing and choose AI usage. It shows “A chart showing which models you’ve used” and “A breakdown of the models used, the credits consumed per model, and the cost.” On a company seat, Copilot settings under your profile picture shows Usage this cycle.
Closer in, VS Code shows what each reply cost when you point to it, the session’s total in the context window control, and the month’s share in the Copilot status dashboard in the Status Bar. Its Agent Debug Logs include a Cache Explorer with “prompt cache hit rates.” In Copilot CLI, /context checks your current usage at any time, and GitHub’s guide suggests /chronicle tips and /chronicle cost-tips “to understand your token usage patterns and get insights into how to reduce cost.” In VS Code chat, the command is /chronicle:cost-tips.
Price: free.
Watch for: old clients can mislead you. GitHub says versions before VS Code 1.120 or Copilot CLI 1.0.48 “may display incorrect model pricing, inaccurate usage information, or outdated billing terminology.” The AI usage page “is only available to users on a Copilot Individual plan.”
Match the model to the task
Best for: routine, well-scoped work that doesn’t need a frontier model.
GitHub’s guide calls model choice “one of the fastest ways to improve cost efficiency,” and warns that defaulting “to the most capable model for every task” often “increases token usage without improving the outcome.” It sorts the work: reasoning models for “architecture decisions, complex debugging, system design,” mid-tier ones “when the plan is already clear,” and lighter ones for “refactoring, formatting, documentation updates, and other routine, well-scoped changes.”
The gap is wide. Per million tokens, GitHub’s price list has GPT-6 Luna at $0.10 in and $0.50 out, and Claude Haiku 5.5 the same up to 100,000 input tokens. GPT-6.1 Terra is $1 and $5, Claude Sonnet 5.5 and GPT-6.1 Sol $2 and $10, Claude Opus 5.5 $4 and $20, and GPT-6 Astra $10 and $50. VS Code’s model picker shows each model’s cost per token type and a tier, “Low, Medium, High,” when you point to it.
Leave reasoning at its default too. Higher reasoning “consumes more tokens, and therefore more credits, so you should use the regular level by default and raise it only for harder tasks,” GitHub says, and VS Code adds that “For most tasks, the defaults are sufficient.” If you use subagents, GitHub suggests you “Run subagents on cheaper models.”
Price: free.
Watch for: cheap isn’t always cheaper. VS Code warns that “A model that needs retries or creates rework can cost more than a capable model that completes the task reliably.” Several models cost more past a size: GPT-6 Astra doubles to $20 in once a prompt passes 272,000 tokens. And on Copilot Free and Student, there’s no model to choose.
Copilot Fusion or Auto, for the discount
Best for: letting Copilot pick the model, at a lower price than picking it yourself.
Copilot Fusion is “an intelligent runtime model router and orchestrator,” in VS Code, Copilot CLI, the Copilot app and JetBrains IDEs. GitHub’s guide says “Use Copilot Fusion as your default,” and Fusion Standard “Balances cost, quality, and latency.” It also “keeps your main conversation on the same model whenever possible,” so the cache holds. Where your client shows Auto instead, auto model selection routes each prompt, and its Efficiency tier sends prompts “to the most cost-efficient and appropriately capable model for the task.”
Price: free, and cheaper than the same models picked by hand. “Through November 30, 2026, users on paid Copilot plans receive a 30% discount on model costs when using Copilot Fusion.” Auto takes “a 10% discount on model costs” on paid plans, in Copilot Chat or the cloud agent.
Watch for: you still pay “for each model it uses, at that model’s standard rate,” and “Because Fusion High and Fusion Max can use more than one model for a task, a task may consume more AI credits than it would with Fusion Standard.” Fusion’s 30% has an end date. And “If Copilot Fusion discards a draft, changes that the draft already made in your workspace, such as file edits, aren’t undone automatically.”
A new chat for each task, compacted when long
Best for: sessions that run all day, or drift from one job to the next.
Every request carries the conversation with it. “Longer threads can require more context to be processed for each new prompt,” GitHub’s chat guide says, so start a new conversation “when your next prompt is about a different problem,” and keep one going while the next prompt “depends on earlier messages.”
In Copilot CLI, /new or /clear starts over, and /compact summarizes a long session you want to keep, optionally with a focus, as in “/compact focus on the auth module.” In VS Code, ⌘N on a Mac or Ctrl+N elsewhere starts a new session, /compact works there too, and /fork branches a conversation for a side question “so you don’t need to re-establish context.”
Price: free.
Watch for: coming back to an old session isn’t free. “Caches expire after a period of inactivity (24 hours for OpenAI models and 1 hour for most others),” GitHub says, so after a break, start a new session or run /compact first, “so what gets rebuilt is a short summary rather than the full history.”
One model, effort and tool set per session
Best for: anyone who switches models, effort or tools in the middle of a task.
Agents send the same large context over and over, and Copilot reuses what it can: “cached tokens are typically billed at 10% of the normal input price,” GitHub’s guide says. Three things throw that away. “A different model can’t reuse another model’s cache, so the next request rebuilds it from scratch.” So does coming back after the cache expires. And “Changing the reasoning effort level, context size, or the set of enabled tools and MCP servers during a session invalidates the cache.”
Rebuilding can cost more than the input itself. GitHub’s price list adds a cache write charge for Anthropic’s models and OpenAI’s newer ones: Claude Opus 5.5 is $4 per million input tokens, $5 to write them to the cache and $0.20 to read them back.
Price: free.
Watch for: it means deciding before you start. GitHub’s advice is “Configure these settings before you start and leave them unchanged for the session,” so when a task needs a different model, start a new session for it rather than switching. A subagent on a cheaper model is the exception: it “doesn’t affect the main agent’s cache the way a mid-session model switch would.”
Trim what loads with every request
Best for: big repositories and setups with many MCP servers.
Tools cost tokens before they do anything. “Large tool sets (for example, a full MCP server’s worth of tools) add to the context on every request,” GitHub’s guide says, so enable “only the toolsets relevant to the task.” In VS Code, the Configure Tools button in the chat input picks the tools and MCP servers for a request, and a custom agent’s tools property gives it a narrow set.
Searches cost tokens too: “Search match snippets count toward the context window even when the agent doesn’t open the matched file.” VS Code leaves .gitignore’d files out of agent search, and the files.exclude and search.exclude settings hide build output and logs. A short map of the project in AGENTS.md or .github/copilot-instructions.md saves agents reading “large numbers of files just to orient themselves,” and for repeated queries, VS Code suggests a script that “runs the query batch and produces a concise summary.”
Price: free.
Watch for: instructions load on every run as well, so keep them “short, specific, and grounded in real observed agent behavior,” GitHub says, not “Long, generic documentation.” And set the tools before the session starts: changing them mid-session breaks the cache.
Scope the task, and plan the big ones
Best for: vague or wide changes, where the agent would otherwise go looking.
GitHub’s guide asks for three things in a prompt: “A clear task definition,” “Relevant context provided upfront,” and “A clear stopping condition.” Without the last, “agents can continue beyond the goal by adding extra commits, refactoring unrelated code, or expanding scope.”
For bigger work, it splits research, planning and building into separate sessions: “always plan with a strong reasoning model, then implement the work with a cheaper model.” That’s /plan in Copilot CLI, or the Plan agent in VS Code. Tests and linters help too, because an agent that checks its work avoids “long chains of incorrect changes, which are one of the biggest drivers of token waste.”
Price: free.
Watch for: splitting has a cost of its own. VS Code notes that “Delegation itself uses tokens, so keep small tasks in the primary session when isolation and a cheaper model would not offset the orchestration overhead.”
Cap each session, and get warned
Best for: long agent runs, and anyone who’s been surprised at the end of a month.
Copilot CLI can stop a task at a set spend. Type /limits set max-ai-credits and a number, or pass --max-ai-credits to copilot -p, and “Copilot stops when it hits the limit and gives you the option to reset or adjust it,” says its session limit page. The limit has to be “at least 30 AI credits.”
For the month, GitHub’s budgets page can email you “when the included usage for your plan reaches 90% and 100%,” under Budgets and alerts in your billing settings. A Bundled AI credits budget covers “all features that use AI credits,” and Stop usage when budget limit is reached makes it a hard stop.
Price: free.
Watch for: session limits are “in public preview and subject to change,” they’re for Copilot CLI and the Copilot SDK, and they’re soft: “If a response is in progress when the limit is reached, that response completes before the session stops.” A budget without the stop box ticked only warns you: “usage will not be stopped.”
Turn code review down to Lite
Best for: repositories where Copilot reviews every pull request.
Copilot code review bills in credits, plus GitHub Actions minutes, and its default effort is Balanced. GitHub’s price list estimates an average of about $0.25 a review at Lite, $1.50 at Balanced and $10 at Max, where the typical range runs to $25. To change yours, open Copilot settings, then Code review, and pick a Review effort level; a repository can also cap it with Maximum review effort. The Review new pushes and Review draft pull requests options add reviews, so leave them off unless you want them.
Price: free.
Watch for: Lite is the lighter review. Balanced adds “Deeper analysis of complex logic, security-sensitive code, and cross-service changes,” and your effort level applies “to automatic reviews and to reviews you request manually.” The model “is selected automatically and is not disclosed,” and GitHub says consumption “generally increases with pull request size and repository custom instructions.”
A local model
Best for: routine work on a model your own computer runs, with no credits at all.
Copilot CLI “automatically discovers models served by Ollama running on your machine”: type /model and add one under “Local and self-hosted.” On a Windows PC with an NVIDIA GPU, it can also install MAI Code 1.1 Flash, with which “you can use Copilot offline and avoid consuming GitHub AI Credits,” and Fusion Standard then uses it “on appropriate tasks.” In VS Code, bring-your-own-key local models such as Ollama “work without a GitHub account, a Copilot plan, or an internet connection,” and its experimental on-device models show “0 credits” per response.
Price: free, on hardware you already own.
Watch for: the hardware. MAI Code 1.1 Flash needs 96 GB of combined memory and 60 GB of storage, and Flint NVFP4 48 GB; AMD isn’t supported. Copilot CLI’s models must support tool calling and streaming, and for an unknown model it “can default to a limit of 128,000 prompt tokens, which can exceed the model’s actual capacity.” In VS Code, bring-your-own-key models skip the Copilot plan in Local harness sessions, “The Local harness is deprecated and will be removed in February 2027,” and in the newer Copilot harness they’re experimental. On a company seat, BYOK in IDEs “can be disabled by an enterprise or organization policy.” Our local model guide covers which models are worth running.
Claude Code or Codex, on their own plans
Best for: a Claude or ChatGPT plan you already pay for, with Copilot’s suggestions still running.
Anthropic’s Claude Code extension runs in VS Code next to Copilot, and “any paid Claude subscription (Pro, Max, Ultra, Team, or Enterprise) or a Claude Console account works, and no API key is required.” OpenAI’s Codex extension serves VS Code and compatible editors, while “Xcode and JetBrains IDEs provide their own integrations.” Signed in with those accounts, VS Code says, “that provider’s usage limits, billing, and data-handling terms apply,” not GitHub’s.
Price: Claude Pro is $20 a month, or $17 a month billed yearly, Max $100 and Ultra $200. Codex is in the IDE extension from ChatGPT Plus, $20 a month, and Pro starts at $100. Copilot Pro and either one comes to $30 a month, $9 less than Pro+.
Watch for: which Claude or Codex you start. Copilot’s own third-party agents bill to Copilot: “Each agent session consumes AI credits based on the model used and the number of tokens processed.” These plans have limits too: Claude Pro has “More usage than Free, every 5 hours and every week,” and Codex on Plus is for “a few focused coding sessions each week.” The work starts as a new conversation, and on a company seat, VS Code warns that “Organization policies can restrict the available routes, even when you have separate credentials.”
Enjoy
Best for: running Claude Code and Codex on their own plans side by side, so agent work stops drawing on Copilot’s credits.
Enjoy runs Claude Code, Codex, Grok Build, Antigravity, Muse Code, and local models through OpenCode, on Mac, Windows and Linux, on the plans you already have. It doesn’t run Copilot, so it won’t make your credits go further; it’s a place to move agent work to plans with limits of their own. What it adds:
- Every account’s limits. The agent settings show each limit, such as 5 hours and Weekly, with when it resets, and the account menu shows the same for every signed-in account (how).
- Another agent, mid-conversation. Start a job on Codex and hand it to Claude Code: “The new agent gets the conversation so far, including replies from other agents, before it works on your message” (how).
- Limits handled. When an agent runs out, Enjoy switches to another of your accounts with usage left, or waits for the reset and carries on.
- Local models too. OpenCode in Enjoy uses models from the providers you set up, “which can include free models, models on your own computer” (how).
Price: Enjoy is one monthly subscription, and the first seven days are free, with a card to start. It includes your phone and any browser and one computer; each other computer is $9.99 a month, and each teammate you invite needs a subscription of their own. See pricing. The agents are billed separately: Claude Code needs a paid Claude plan, and Codex in Enjoy needs ChatGPT Plus or above.
Watch for: Enjoy isn’t an editor in Copilot’s sense. Its code editor doesn’t suggest code as you type, and it doesn’t plug into VS Code or JetBrains IDEs: the agents write the code, so Copilot’s unlimited suggestions are a reason to keep Copilot. Work you move from Copilot starts as a new conversation. Waiting out a limit needs “Your computer must be on, with Enjoy open, when the usage resets,” and scheduled workflows also run only while it’s awake with Enjoy open. Enjoy isn’t open source, and it’s a monthly subscription on top of your AI plans once the free week ends. If you only want Claude Code or Codex beside Copilot, the two extensions above don’t need Enjoy at all.
When to stay with the defaults, or upgrade
The defaults are a fair start. GitHub’s own advice is Fusion as your default, and VS Code’s is that “For most tasks, the defaults are sufficient.” Keep the strongest models, and higher effort, for planning and hard bugs, and save on the routine work around them.
If you’ve done all this and still run out most months, the plan is too small. “If you regularly approach your monthly limit, a higher plan may be more economical than paying for additional usage,” GitHub’s guide says, and you pay only the difference for the rest of the month. Going from Pro to Pro+ costs $29 and adds 5,500 credits, where $29 of additional usage buys 2,900. If your credits go on agent work rather than chat, Claude Pro or ChatGPT Plus beside Copilot Pro is $9 a month less than Pro+. For the month it’s already happened, our guide to what to do when Copilot runs out of AI credits covers budgets, upgrades and the reset.
How we compared
We read GitHub’s optimization, chat, billing, price list, usage, budgets, session limit, Fusion, auto model selection, code review, bring-your-own-key, Copilot CLI model and third-party agent pages; VS Code’s optimization, language model and agent harness docs; GitHub’s community discussion; Anthropic’s pricing and Claude Code docs; and OpenAI’s Codex pricing and IDE pages, all on November 16, 2026, and every one is linked below. We quote each company’s own words for its limits and leave out what it hasn’t documented, including other sites’ estimates of how much each habit saves. The student’s report is that developer’s own account. Plans and prices change often, so we recheck this guide against its sources at least once a month, and the date at the foot of the page says when we last did.
17.Questions.
Why do my Copilot AI credits run out so fast?
- Mostly agent work, long conversations and the model. GitHub names “Conversation length and complexity,” “Agentic features” and “Model choice,” and says an agent session across a large codebase “will consume significantly more usage than a quick question in chat.” Per token, Claude Opus 5.5 costs 40 times GPT-6 Luna in GitHub’s price list.
Which Copilot model uses the fewest AI credits?
- GPT-6 Luna, and Claude Haiku 5.5 for prompts up to 100,000 tokens, both at $0.10 per million input tokens and $0.50 per million output. GitHub suggests lighter models for “refactoring, formatting, documentation updates, and other routine, well-scoped changes.” Copilot Free and Student get models through auto model selection only.
Is Copilot Fusion or Auto cheaper?
- Through November 30, 2026, Fusion, with a 30% discount on model costs on paid plans, against 10% for Auto in Copilot Chat and the cloud agent. Both bill each model at its own rate. Fusion High and Max can use more than one model for a task, so they can cost more than Fusion Standard.
Does switching models in the middle of a chat cost more?
- Yes. GitHub says “A different model can’t reuse another model’s cache,” so the whole context is billed again as fresh input, where cached tokens are “typically billed at 10% of the normal input price.” Changing the reasoning effort or the set of tools mid-session does the same.
Do code completions use AI credits?
- No. “Code completions and next edit suggestions are not billed in AI credits and remain unlimited for all paid plans.” Copilot Free includes 2,000 completions a month.
Can I use my Claude or ChatGPT plan instead of Copilot’s credits?
- Yes, through Anthropic’s and OpenAI’s own extensions, which sign in with those plans. Copilot’s own Claude and Codex agents draw on your AI credits. Enjoy runs Claude Code and Codex side by side, but it doesn’t run Copilot.