JSCC AI Notes banner

Tag: GitHub Copilot

  • 6 Best Free AI Coding Agents in 2026: Feature Limits & Local Model Support Compared

    6 Best Free AI Coding Agents in 2026: Feature Limits & Local Model Support Compared

    Developers who want AI coding help without a monthly subscription in 2026 can start with open-source agents that run free models or point at a local model on their own hardware. OpenCode and Goose give the most flexible zero-cost routes because the tools themselves cost nothing and both accept local models through Ollama. GitHub Copilot Free, from Microsoft ($MSFT)-owned GitHub, supplies 2,000 completions a month with limited chat and agent use under automatic model selection. Google ($GOOGL) Antigravity offers a weekly quota with unlimited Tab completions and Command requests. Claude Code has no free tier and starts on the Pro plan.

    These six agents, plus a fully local Ollama setup that works with four of them, cover the main free paths available as of November 4, 2026. All prices, limits and feature descriptions come from the vendors’ own documentation or pricing pages, linked at the end.

    Infocard for the 6 best free AI coding agents in 2026: 6 agents compared, $0 tool cost for OpenCode, Goose, Cline and Aider, 2,000 Copilot Free completions per month, unlimited local use with Ollama
    Four numbers that frame a zero-cost AI coding setup in 2026: six agents, $0 tools, 2,000 Copilot Free completions, unlimited local runs.

    Free AI Coding Agents Compared

    Here is how the six agents stack up on what each one gives you for free, whether it can run a local model, and what the tool itself costs.

    ToolFree limits (official)Local model supportLicense / cost of toolKey notes
    OpenCodeFree models included, no account needed; rotating limited-time free models (e.g. DeepSeek V4.1 Flash Free, GLM-5.3-Flash Free, Flint 40B Free); usage cap not publishedYes (auto-discovers Ollama, LM Studio and vLLM; any OpenAI-compatible server)MIT, $075+ providers; free-model data terms vary (some zero-retention, some used for improvement)
    GooseFully free; no tool-level quotaYes (Ollama and 15+ other providers)Apache-2.0, $0 (Agentic AI Foundation at the Linux Foundation)Desktop, CLI and API; 70+ documented MCP extensions
    ClineRotating free model promotions with a limited quota (Cline account required); tool itself freeYes (Ollama, LM Studio, Atomic Chat)Apache-2.0, $0Optional ClinePass $9.99/month for 2-5x rate limits on selected open models
    AiderTool free; no quota on the softwareYes (Ollama, LM Studio, OpenAI-compatible APIs)Apache-2.0, $0Strong git integration; commits each change automatically
    GitHub Copilot Free2,000 completions per month; limited AI Credits for chat and agent use (amount not published); auto model selection onlyNot documented for the Free planFree plan, no credit cardNo Copilot in the cloud (cloud agent) on Free; Copilot CLI included
    Google AntigravityWeekly quota (size not published); unlimited Tab completions and Command requestsNo (no bring-your-own-key or custom endpoint)Free individual planGemini 3.8 Flash on every plan; some third-party models on Free are removed Nov 18, 2026
    Compiled by JSCC AI Notes from each vendor’s docs and pricing pages, checked November 4, 2026.

    Read the table from left to right as a cost question. Four of the six (OpenCode, Goose, Cline, Aider) cost $0 as software, so your only bill is whatever model you connect, and that can be $0 with a local model. The two commercial free plans trade that flexibility for a hosted model with a cap: Copilot Free’s 2,000 completions are roughly 65 completions a day over a 31-day month, while Antigravity doesn’t publish its weekly number at all.

    Chart of published free-tier limits for AI coding agents in 2026: GitHub Copilot Free shows 2,000 completions per month, while Antigravity, OpenCode free models and Cline promotions are marked as not published and Ollama local use as unlimited
    Only GitHub publishes a hard number (2,000 completions a month); every other free cap is either unpublished or set by the model you connect.

    Methodology / What We Checked

    We reviewed the official websites, documentation and pricing pages for each tool on November 4, 2026. Primary sources include opencode.ai, goose-docs.ai, docs.cline.bot, aider.chat, github.com/features/copilot and docs.github.com, antigravity.google documentation, claude.com and ollama.com. We recorded only limits and features that appear on those pages. Free model lists rotate, so the specific free models available inside OpenCode or Cline can change without notice.

    We did not run hands-on coding sessions or independent benchmarks for this guide; any speed or quality claims in the wider market are vendor-reported and are not repeated here as measured results. Hardware guidance for local models is taken from Cline’s local models documentation, not from our own tests. Where a vendor does not publish a number, we say so instead of estimating one.

    Detailed Setup Steps for Zero-Cost Paths

    OpenCode with Free Models or Local Ollama

    OpenCode states it is 100% free to use and includes a set of free models that work without creating an account. Install with:

    curl -fsSL https://opencode.ai/v2/install | bash

    After installation, run opencode and type /models to see available models, then pick one labeled free. Free models are described as available “for a limited time.” Some free models (for example DeepSeek V4.1 Flash Free and GLM-5.3-Flash Free) follow a zero-retention policy according to OpenCode’s console models documentation; others, such as Flint 40B Free, note that data may be used to improve the model and is kept for 30 days. OpenCode does not publish a usage cap for its free models, and you can hide them entirely with OPENCODE_DISABLE_FREE_MODELS=1.

    To switch to a local model, start Ollama and pull a coding model that fits your hardware. OpenCode’s model docs say it automatically discovers models from Ollama at http://127.0.0.1:11434 (and from LM Studio and vLLM at their defaults), so you select it with the ollama provider ID:

    {
      "$schema": "https://opencode.ai/config.json",
      "model": "ollama/gemma3:4b"
    }

    The tool remains free; you pay only for electricity and hardware. Swap gemma3:4b for whichever coding model you pulled.

    Goose with Local Models

    Goose is Apache-2.0 licensed and governed under the Agentic AI Foundation at the Linux Foundation. The desktop app (macOS, Linux and Windows) and CLI cost nothing. Install the CLI with the one-liner published on the goose site:

    curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash

    Point Goose at an Ollama model. Because the agent runs on your machine, prompts and code stay local when you use a local model. Goose supports more than 70 documented MCP extensions for additional tools, and it can also act as an ACP server for Zed, JetBrains or VS Code.

    Cline in an Editor

    Cline’s extension and CLI are free under Apache-2.0. After installing the extension in VS Code or another supported editor, sign in if you want access to Cline’s rotating free model promotions; Cline’s free models page says they are available to any user with a Cline account. Free models carry a limited usage quota, and free usage may be used to improve the models. Once the quota ends you can continue with your own API key, pay-as-you-go Cline credits, or the optional ClinePass subscription at $9.99 per month for 2-5x the rate limits on selected open models. For a pure local path, configure Cline to use Ollama, LM Studio or Atomic Chat.

    Aider for Git-Centric Workflows

    Install Aider with:

    python -m pip install aider-install
    aider-install

    Then run aider inside a git repository. Aider is free and model-agnostic. Supply an API key for a free-tier provider or point it at a local Ollama server, as described in Aider’s Ollama guide. Every change is committed to git, so you can review and revert with standard git tools.

    Copilot Free and Antigravity

    GitHub Copilot Free is available without a credit card. Official documentation lists 2,000 inline completions per month plus a limited allowance of GitHub AI Credits for chat and agent use; the exact credit amount for Free is not published. Model selection is automatic only, and Copilot in the cloud requires a paid plan. Antigravity’s individual free plan provides a weekly quota (number not published) with unlimited Tab completions and Command requests. Check the current model list because Claude Sonnet 4.6, Claude Opus 4.6 and GPT-OSS-120b are scheduled for removal on November 18, 2026.

    What It Costs If You Outgrow Free

    Free tiers run out. Here is the nearest paid step for each path, from the official pricing pages, so you know the ceiling before you commit to a workflow.

    PathNearest paid optionPriceWhat the upgrade adds
    GooseNone listed$0Nothing to buy; you only pay for any hosted model you connect
    ClineClinePass$9.99/month2-5x rate limits on curated open coding models
    OpenCodeOpenCode Go$10/monthLower-cost access to a set of hosted models, with 5-hour, weekly and monthly limits
    GitHub CopilotCopilot Pro$10/month1,500 monthly AI credits, model selection, unlimited completions
    Claude CodeClaude Pro$20/month ($17/month billed yearly)Claude Code access; Claude’s Free plan does not include it
    Prices from claude.com/pricing, github.com/features/copilot/plans, opencode.ai and docs.cline.bot, checked November 4, 2026.

    Every paid option except Claude Pro lands at about $10 a month, so the cheapest upgrade is roughly $120 a year. Claude Pro at $20 is double that, and the yearly $17 rate still adds up to $204. If you already own hardware that runs a local model well, the $0 Goose or Ollama row is the only one that never grows.

    Bar chart of the nearest paid upgrade for each free AI coding path in 2026: Goose $0, ClinePass $9.99, OpenCode Go $10, GitHub Copilot Pro $10 and Claude Pro $20 per month
    Most upgrades sit at about $10 a month; Claude Pro, the entry point for Claude Code, costs $20.

    Going Fully Local: How Much RAM You Need

    A local model removes per-token billing and vendor quotas. Ollama’s pricing FAQ states that running models on your own hardware is always unlimited, and the local runtime itself is free. The catch is memory. Cline publishes a simple RAM guide that applies whichever agent you point at Ollama:

    System RAMTypical local setup (Cline docs)
    16-32 GBSmall or quantized models
    32-64 GBMid-size coding models
    64 GB+Larger models and bigger context windows
    Source: Cline, Local models documentation, checked November 4, 2026.

    In practice, a 16 GB laptop keeps you in Cline’s small or quantized tier. Moving to 32-64 GB opens up mid-size coding models, and 64 GB+ is where longer contexts become comfortable. Cline also recommends enabling its compact prompt and keeping tasks focused, since a smaller context means faster local responses.

    Range chart of RAM needed for local coding models according to Cline's docs: 16 to 32 GB for small or quantized models, 32 to 64 GB for mid-size coding models, and 64 GB or more for larger models with bigger context
    RAM decides how far a $0 local setup can go: 16-32 GB for small models, 32-64 GB for mid-size coding models, 64 GB+ for larger ones.

    Who Should Pick Which?

    • OpenCode: choose it if you want a free terminal, desktop or IDE agent with rotating free models and easy local model support. It is the lowest-friction start for many developers.
    • Goose: pick it when you prefer a vendor-neutral, foundation-governed agent with strong MCP extensibility and you plan to run local models for privacy.
    • Cline: use it inside your existing editor when you want approval steps before every file edit and terminal command, and you are comfortable with a free rotating quota or your own keys.
    • Aider: select it for git-native pair programming where every AI edit becomes a normal commit you can review and revert.
    • Copilot Free: stay on it if you already live in VS Code and mainly need inline completions; the 2,000 monthly limit is published and predictable for light use.
    • Antigravity: try it if you want an agent-first interface with a free weekly quota and unlimited Tab completions.
    • Fully local with Ollama: pair Ollama with OpenCode, Goose, Cline or Aider when privacy or unlimited offline use matters more than frontier model quality. Size the model to your RAM using the table above.
    Decision flow diagram for choosing a free AI coding agent in 2026: offline or private leads to Ollama with OpenCode, Goose, Cline or Aider; free hosted models lead to OpenCode or Cline; light VS Code use leads to GitHub Copilot Free; agent-first app leads to Google Antigravity; git-first terminal work leads to Aider
    Four yes-or-no questions route you to the right $0 path, from fully local Ollama to Copilot Free’s 2,000 completions.

    If you start on Copilot Free and later move to a paid plan, model choice starts to drive the bill, which is where routing tools come in. The quick test: run one real task from your backlog on two of these paths for a week each, and keep the one whose free limit you didn’t hit.

    FAQ

    Is Claude Code free?

    No. Anthropic’s pricing page lists Claude Code under the Pro plan, not the Free plan. Pro costs $20 per month, or $17 per month when billed yearly.

    Can I run a coding agent fully offline?

    Yes. Install Ollama, pull an open coding model that fits your hardware, and point OpenCode, Goose, Cline or Aider at the local endpoint. The software is free and there is no per-token charge.

    Do the free models inside OpenCode stay free forever?

    No guarantee. OpenCode documents that free models are available “for a limited time” and the list rotates. Some carry specific data-retention or training terms. Check /models inside the tool for the current set.

    What happens when I hit a free limit?

    Copilot Free’s 2,000 completions are a monthly allowance. OpenCode doesn’t publish a cap for its free models. When Cline’s free quota runs out, you can switch to ClinePass, Cline credits or your own API key. Local Ollama use has no vendor-imposed token limit.

    Official Sources

    Related Posts

    About the author: JSCC writes about AI tools, developer software and the costs behind them, with a focus on turning pricing pages and docs into numbers readers can act on.

    This article was drafted with AI assistance and fact-checked against official documentation by the author. Prices and features were checked on November 4, 2026 and may change.

    © 2026 JSCC AI Notes

  • GitHub Copilot Fusion vs Picking a Model Yourself (2026): What 1 Agent Task Costs on 11 Models

    GitHub Copilot Fusion vs Picking a Model Yourself (2026): What 1 Agent Task Costs on 11 Models

    If you pay for GitHub Copilot and keep hopping between Claude, GPT and Gemini models in the picker, this comparison is for you. GitHub, owned by Microsoft ($MSFT), made Copilot Fusion generally available on October 28, 2026, and it now chooses and combines models for you at three effort levels. Working only from GitHub’s published per-token rates, one mid-size agent task in our cost model ranges from 2.1 AI credits on the cheapest lightweight model to 212 on GPT-6 Astra, roughly a 100x spread. The short version: Fusion Standard is the sensible default for most people, while picking a model yourself still wins when you know exactly which one a job needs and want a predictable bill.

    Infocard comparing GitHub Copilot Fusion with manual model picking in 2026: 3 effort levels, 30% discount through November 30, about 100x cost spread per agent task, 1 AI credit equals $0.01
    Four numbers that frame the choice between Copilot Fusion and a fixed model pick.

    Copilot Fusion vs Manual Model Picking: Side-by-Side

    Here is how the two approaches differ on the points that affect your bill and workflow, based on GitHub’s documentation and changelog.

    What mattersCopilot FusionPicking a model yourself
    Who chooses the modelFusion routes each prompt and may chain several modelsYou do, and it stays fixed until you switch
    Effort settingsStandard, High, Max (Fast is internal to VS Code inline chat)Per-model reasoning level where the model supports it
    How it’s billedEach model it calls, at that model’s standard rate; no Fusion surchargeThe one model you picked, at its standard rate
    Current promo30% off model costs on paid plans through Nov 30, 2026None
    Cache behaviorTries to keep the main thread on one model so cached tokens keep workingCache resets whenever you switch models mid-session
    Local modelsStandard tier can route to MAI-Code-1.1-Flash or Qwen3.8 Flash Next (experimental)You can select a local model directly
    Cost predictabilityLower on High/Max, since extra review calls are added when Fusion thinks they helpHigh: one rate card, one model
    Where it worksVS Code, Copilot CLI, GitHub Copilot app, JetBrains IDEsEvery Copilot surface with a model picker
    Compiled by JSCC AI Notes from GitHub Docs and the October 28, 2026 changelog.

    Methodology: How We Compared Them

    We did not run hands-on benchmarks for this piece, so you won’t find any speed or accuracy scores we measured ourselves. This is a spec, pricing and documentation comparison. We read the About GitHub Copilot Fusion page, the Models and pricing for GitHub Copilot rate tables, the individual billing and organization billing pages, and the launch changelog, all checked on November 3, 2026.

    To turn per-million-token prices into something you can picture, we defined one illustrative agent task: a bug fix spread over about ten turns in a mid-size repository. We assumed 80K fresh input tokens, 320K cached input tokens (context the model reuses from earlier turns) and 20K output tokens. Each model’s cost is simple arithmetic on GitHub’s list rates, converted at 1 AI credit = $0.01. We left out cache-write fees, which some OpenAI and Anthropic models charge on top, so real numbers on those models will run slightly higher.

    One limit matters a lot: GitHub does not publish which models Fusion will pick for a given prompt. The Fusion figures further down are therefore hypothetical routes we built from the documented patterns, not readings from a real session. Your own usage dashboard is the only place to see true numbers.

    What One Agent Task Costs on Each Model

    Applying the same token profile to eleven models in the Copilot pool gives the spread below. Prices are GitHub’s default tier (shorter contexts); several models charge more past 200K or 272K input tokens per request.

    ModelInput / 1MCached input / 1MOutput / 1MCredits for our task
    GPT-6 Luna$0.10$0.01$0.502.1
    Claude Haiku 5.5$0.10$0.01$0.502.1
    MAI-Code-1.1-Flash$0.20$0.02$1.204.6
    Gemini 3.8 Flash$0.75$0.075$3.7515.9
    GPT-6.1 Terra$1.00$0.05$5.0019.6
    Claude Sonnet 5.5$2.00$0.10$10.0039.2
    GPT-6.1 Sol$2.00$0.10$10.0039.2
    Gemini 4 Argon$2.00$0.10$10.0039.2
    Claude Opus 5.5$4.00$0.20$20.0078.4
    Claude Fable 5.1$10.00$0.25$50.00188.0
    GPT-6 Astra$10.00$1.00$50.00212.0
    Rates from GitHub’s Models and pricing page (default tier). Task: 80K fresh input, 320K cached input, 20K output.
    Horizontal bar chart of estimated GitHub Copilot AI credits for one agent task across 11 models, from 2.1 credits on GPT-6 Luna and Claude Haiku 5.5 to 212 credits on GPT-6 Astra
    Same work, very different bills: our illustrative task costs about 2 credits on lightweight models and over 180 on the top frontier tier.

    The lightweight group (GPT-6 Luna, Claude Haiku 5.5, MAI-Code-1.1-Flash) stays under 5 credits, so even a heavy month barely dents an allowance. The versatile and powerful middle, where Claude Sonnet 5.5, GPT-6.1 Sol and Gemini 4 Argon from Google ($GOOGL) all share a $2 input and $10 output rate, lands at 39.2 credits. GPT-6.1 Terra sits at half that, 19.6. At the top, Claude Opus 5.5 doubles the middle tier, and Fable 5.1 or GPT-6 Astra run about five times the middle tier.

    Output tokens drive more of the bill than most people expect. On Sonnet 5.5, our 20K output tokens cost 20 credits, more than the 80K fresh input tokens (16 credits). Agents that write long explanations or rewrite whole files burn credits fast. Anthropic’s pricing choices here tie into the wider economics of frontier labs we looked at in our breakdown of the Anthropic S-1 filing.

    The hidden cost of switching models mid-session

    GitHub’s cost optimization guide warns that a different model can’t reuse another model’s cache, and it notes cached tokens are typically billed at about 10% of the normal input price. Say your context has grown to 40K tokens and you jump to Sonnet 5.5 halfway through. That next turn re-sends the full 40K as fresh input: 8 credits instead of the 0.4 credits it would cost as a cache hit. Repeat that often and switching can cost more than the model choice itself. Fusion is designed to route along cache boundaries, which is one of the quieter reasons it can come out cheaper.

    How Fusion’s Three Patterns Change the Bill

    Fusion doesn’t just pick one model. Per prompt, it uses one of three execution patterns, and only the first behaves like a normal single-model request.

    • Single: one model handles the prompt. Fusion Standard picks one model per task, so this is what you’ll see most at that level.
    • Cascade: an efficient model writes a draft, a judge reviews it, and the work is either accepted or escalated to a stronger model.
    • Critique: one model drafts while several others critique it in parallel; their notes are merged and the original model revises.
    Flow diagram of GitHub Copilot Fusion execution patterns: Single with one model, Cascade with a draft, judge and optional escalation, and Critique with three parallel critics and a revision step
    Every box in this diagram is a separate model call, and each one is billed at its own model’s rate.

    Because cascade and critique add calls, the docs say a task on Fusion High or Max may use more AI credits than it would on Standard. To show what that can look like, we priced four hypothetical routes using the same task profile, with the 30% launch discount applied. The judge reads 20K tokens and writes 1K on Sonnet 5.5; each critic reads 30K and writes 2K on GPT-6.1 Terra; the revision turn is small.

    Hypothetical routeCredits (after 30% off)vs manual Sonnet 5.5 (39.2)
    Single on GPT-6.1 Terra13.7-65%
    Cascade, draft accepted17.2-56%
    Critique with two critics36.8-6%
    Cascade, escalated to Sonnet 5.544.7+14%
    Hypothetical routes built by JSCC AI Notes from GitHub’s documented patterns and list rates. Not measured.
    Bar chart of hypothetical GitHub Copilot Fusion route costs with the 30 percent discount: 13.7 credits single, 17.2 cascade accepted, 36.8 critique, 44.7 cascade escalated, versus 39.2 for manual Claude Sonnet 5.5 and 78.4 for manual Claude Opus 5.5
    With the launch discount, most hypothetical Fusion routes undercut a fixed Sonnet 5.5 pick; an escalated cascade is the one case that costs more.

    When Fusion settles a prompt with a mid-priced model, it beats a fixed Sonnet 5.5 pick by a wide margin. When it escalates, you pay for the discarded draft plus the stronger model, which edges past a straight Sonnet run even with the discount. After November 30 the discount ends, and an escalated cascade in our model would cost 63.8 credits. GitHub’s own claim is more upbeat: it says Fusion Max scored 60 on the Artificial Analysis Coding Agent Index, within two points of Claude Code with Opus 5.5 Max, at about half the average API cost per task (changelog). That’s GitHub’s figure, not ours, but it matches our math: the savings come from keeping routine work off frontier models.

    How to Turn On Copilot Fusion

    Update your client first, since older builds won’t list Fusion.

    1. VS Code or JetBrains: open the Copilot Chat model picker, choose Copilot Fusion, then pick Standard, High or Max.
    2. GitHub Copilot app: click the model name under the prompt box, switch the Copilot Fusion toggle on and choose an effort level (app docs).
    3. Copilot CLI: type /model in a session and select Copilot Fusion, or pass it as a flag for one-off prompts (CLI docs). Use /config model to make it your default.

    For scripted runs, the documented flags look like this (the prompt text is our own example):

    copilot --model fusion --fusion-tier standard -p "Add input validation to src/signup.ts and update its tests"

    To sanity-check a bill before committing to a model, this short snippet of ours does the math; plug in GitHub’s rates and token counts from your usage dashboard.

    def copilot_credits(fresh, cached, output, rate_in, rate_cached, rate_out, discount=0.0):
        """Estimate GitHub AI credits (1 credit = $0.01). Rates are USD per 1M tokens."""
        usd = (fresh * rate_in + cached * rate_cached + output * rate_out) / 1_000_000
        return round(usd * 100 * (1 - discount), 1)
    # Claude Sonnet 5.5 at list rates: 39.2 credits for our sample task
    print(copilot_credits(80_000, 320_000, 20_000, 2.00, 0.10, 10.00))

    Local routing is a separate, experimental option. According to the local models changelog, on supported Windows machines you can install MAI-Code-1.1-Flash, and Fusion Standard may then send suitable work to it without using AI credits.

    How Far Each Plan’s AI Credits Go

    Since June 1, 2026, Copilot bills by usage. Each plan includes a monthly AI credit allowance that resets at 00:00 UTC on the first of the month, and unused credits don’t roll over. Code completions and next edit suggestions are not billed in credits and stay unlimited on paid plans.

    PlanPriceMonthly AI creditsTasks on TerraTasks on Sonnet 5.5Tasks on Opus 5.5
    Copilot Pro$10/mo1,500763819
    Copilot Businessper user1,900964824
    Copilot Enterpriseper user3,9001989949
    Copilot Pro+$39/mo7,00035717889
    Copilot Max$100/mo20,0001020510255
    Allowances from GitHub Docs. Pro, Pro+ and Max totals include base credits plus a flex allotment. Business and Enterprise credits are per user and pooled across the organization.
    Grouped bar chart showing how many illustrative agent tasks each GitHub Copilot plan's monthly AI credits cover on GPT-6.1 Terra, Claude Sonnet 5.5 and Claude Opus 5.5, from 19 Opus tasks on Pro to 1,020 Terra tasks on Max
    A $10 Pro plan covers about 38 Sonnet-class agent tasks a month in our model; the same credits stretch twice as far on GPT-6.1 Terra.

    Pro users feel model choice the most. Running every agent task on Opus 5.5 empties a Pro allowance in about 19 tasks, while routine work on Terra stretches it to 76. Copilot Free and Student plans only reach models through automatic selection, so the manual-versus-Fusion question mostly applies to paid tiers. If you hit the ceiling often, GitHub suggests that a bigger plan can work out cheaper than buying extra usage, and a $0 budget with a hard stop prevents surprise charges. Budget-conscious users can also look at the best free AI coding agents in 2026 if you want a free option.

    Who Should Pick Which?

    • Copilot Pro on a tight budget: use Fusion Standard as your default. It keeps the main thread on one model and can route to cheaper ones without you thinking about it.
    • You already know the right model: pick it manually and stay on it for the whole session. A fixed Sonnet 5.5 or Terra run gives you a predictable, easy-to-audit bill.
    • Hard bugs or multi-file refactors: try Fusion High for those sessions only. The review calls cost extra, but they’re cheaper than defaulting to a frontier model all day.
    • Architecture or deep debugging: Fusion Max or a manual Opus 5.5 pick. Plan with the strong model, then start a fresh session on a cheaper one to implement.
    • Team admins: set Fusion as the managed default and limit its model pool through policy. Fusion only uses models your org has enabled.
    • Windows developers with plenty of RAM: experiment with local routing on Fusion Standard. Check the hardware requirements first.

    Spending on AI tools rides on a much bigger buildout of chips and data centers, which we’ve tracked in our pieces on AI infrastructure debt and AI debt concerns in semiconductors. Falling list prices, such as Opus 5.5 pricing below Opus 5, help make routers like Fusion worthwhile.

    FAQ

    Does Copilot Fusion cost extra?

    No. GitHub says there is no separate charge for Fusion. You pay for each model it calls at that model’s standard rate, and through November 30, 2026, paid plans get 30% off those model costs.

    Is Fusion always cheaper than picking a model?

    Not always. Fusion Standard usually is for routine work, but Fusion High and Max can add judge or critic calls, so an escalated task can cost more than one run on a single mid-tier model.

    Can I see which models Fusion used?

    Yes. After a response, hover over the effort level name under it to see the list of models used. You can also follow each step’s model while it works.

    Do code completions use AI credits?

    No. Code completions and next edit suggestions are not billed in AI credits and remain unlimited on paid Copilot plans.

    Which effort level should I start with?

    Start with Fusion Standard for everyday prompts. Move to High for well-scoped but difficult tasks, and save Max for the hardest reasoning work.

    Official Sources

    Related Posts

    About the author: JSCC writes about AI tools, developer software and the costs behind them, with a focus on turning pricing pages and docs into numbers readers can act on.

    This article was drafted with AI assistance and fact-checked against official documentation by the author. Prices and features were checked on November 3, 2026 and may change.

    © 2026 JSCC AI Notes