JSCC AI Notes banner

Tag: VS Code

  • 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