JSCC AI Notes banner

Category: AI Tools

  • Cursor Pricing Breakdown 2026: Hidden API Costs for 4 Monthly Users

    Cursor Pricing Breakdown 2026: Hidden API Costs for 4 Monthly Users

    Developers evaluating Cursor after the October 12, 2026 shift to The X Subscription need the current rates, not the old Pro numbers. Plus costs $8 a month and runs only Cursor models (Grok 4.7, 4.6, 4.5, and Composer 2.5). Premium starts at $30 a month, opens third-party models such as Claude Opus 5.5 and Sonnet 5.5 at their API list prices paid from prepaid credit, and multiplies the weekly pool. For four users who mix Grok with Claude on agent work, the difference between staying on Plus and moving to Premium or Teams is the prepaid credit burn plus the Cursor Token Rate on Teams.

    This pricing breakdown walks the live plan table, the model rate cards inside Cursor, and an illustrative four-user monthly bill. Every dollar figure below comes from cursor.com/pricing or Models & Pricing, checked November 5, 2026. Where we multiply those rates into a monthly total, the result is labeled illustrative — not a measured usage sample.

    Infocard for Cursor Pricing Breakdown 2026: Plus $8 Grok-only, Premium $30 with third-party at API list, Cursor Token Rate $0.25 per million on Teams, illustrative costs for 4 monthly users
    Four numbers that frame Cursor costs in 2026: Plus $8, Premium $30, Token Rate $0.25/M on Teams, and a 4-user bill.

    Current Plans and What They Include

    The X Subscription is the only product new customers can buy. Existing legacy Pro ($20), Pro+, and Ultra ($200) plans continue unless the subscriber switches. Annual billing is available: Plus $80, Premium $300, Super $1,000, Ultra $2,000. All paid plans share a weekly usage pool for Cursor models across Grok and Cursor. Plus locks those models to fixed settings (Fast off, medium effort) and excludes third-party models, Auto, Cloud Agents, Automations, Bugbot, and Origin. Premium and higher add those features and open third-party models.

    PlanPriceIncluded usageCursor modelsThird-party models
    Free$0LimitedLimitedNo
    Plus$8/mo ($80/yr)Base weekly poolGrok 4.7/4.6/4.5 + Composer 2.5 onlyNo
    Premium$30/mo ($300/yr)4x PlusSame, higher volumeAPI list from prepaid credit
    Super$100/mo ($1,000/yr)15x PlusSameAPI list from prepaid credit
    Ultra$200/mo ($2,000/yr)50x PlusSameAPI list from prepaid credit
    Teams$30/$100/$200 per seatMatches seat tierSameAPI list + $0.25/M Token Rate on eligible
    Compiled from cursor.com/pricing and cursor.com/docs/models-and-pricing, checked November 5, 2026.

    Individual plans do not pay the Cursor Token Rate. Teams and Enterprise do on eligible third-party requests (input, output, and cached tokens), as documented on the Token Rate help page. Models whose cache-read price is strictly below $0.10 per million tokens across every tier are exempt, as are Cursor models and Cost mode.

    Bar chart of Cursor monthly plan prices in 2026: Free $0, Plus $8, Premium $30, Super $100, Ultra $200
    Seat prices alone: Plus $8, Premium $30, Super $100, Ultra $200 per month before any third-party prepaid credit.
    Bar chart of Cursor weekly usage pool multipliers: Plus 1x, Premium 4x, Super 15x, Ultra 50x
    The weekly Cursor-model pool scales 1x → 4x → 15x → 50x from Plus to Ultra; third-party tokens stay outside the pool.

    Methodology / What We Checked

    We read the live Cursor pricing page, the Models & Pricing documentation, the Cursor Token Rate help page, and the official rate cards for the models that appear in Cursor. Claude Opus 5.5 lists at $4 input / $20 output / $0.20 cache-read per million tokens on Cursor’s third-party table (matching Anthropic’s published Opus pricing). Claude Sonnet 5.5 is $2 / $10 / $0.10. Grok 4.7 is $2 input / $6 output / $0.50 cache-read per million tokens on Cursor’s model table (standard context; long-context and Fast modes bill higher multipliers on the same page). Composer 2.5 standard is $0.50 / $2.50 / $0.20 (Composer 2.5 docs).

    No hands-on token measurements were run; every rate is taken from the linked official page. Illustrative monthly totals below use a fixed roughly 2 million tokens per user per month (about 500,000 tokens a week) and are labeled as such. A broken xAI developer pricing URL that returned HTTP 404 was dropped; Grok rates in this post come from Cursor’s own model table, with docs.x.ai/docs/models kept only as an alternate model hub link.

    Model Rates That Drive the Hidden Bill

    The seat price is only the floor. Once a team leaves Plus, every Claude, GPT or Google ($GOOGL) Gemini token is prepaid credit at list price. Teams also add $0.25 per million tokens on eligible third-party requests. The rates that matter for the scenarios below:

    Model / feeInput / 1MOutput / 1MCache read / 1MNotes
    Composer 2.5 (Cursor)$0.50$2.50$0.20Draws from weekly pool first; top-ups at these rates
    Grok 4.7 (Cursor)$2.00$6.00$0.50Standard context; Fast / long-context multiply
    Claude Opus 5.5$4.00$20.00$0.20Third-party; prepaid credit from first request
    Claude Sonnet 5.5$2.00$10.00$0.10Third-party; at the $0.10 cache-read floor
    Cursor Token Rate (Teams)$0.25 on eligible tokensInput + output + cached; Cursor models / Cost mode exempt
    Per-million-token rates from cursor.com/docs/models-and-pricing and the Token Rate help page, checked November 5, 2026.

    Sonnet 5.5’s $0.10 cache-read sits exactly at the exemption threshold language (“strictly below $0.10”), so treat Token Rate eligibility for that model as something to confirm in your admin bill rather than assume away. Opus 5.5 at $0.20 cache-read clearly pays the rate on Teams.

    Detailed Cost Scenarios for 4 Users

    A team of four can stay on Plus if they accept only Cursor models. At $8 each that is $32 a month plus any top-ups once the base weekly pool is exhausted. Top-ups are prepaid credit valid 365 days and are charged at the Cursor model rates (for example Composer 2.5 $0.50 input / $2.50 output).

    If any of the four needs Claude Opus 5.5 for long-horizon agent work, the account must be Premium or higher. The weekly pool still covers Cursor models; every Claude token comes out of prepaid credit at list price. An illustrative 500,000-token week per user that is half Composer 2.5 and half Claude Opus 5.5 looks like this (numbers are arithmetic on official rates, not measured usage):

    • Composer portion (250k input + 50k output): roughly $0.25–$0.40 depending on cache hit rate.
    • Claude Opus 5.5 portion (250k input + 50k output, modest cache): roughly $1.50–$2.00.
    • Across four users that is an extra $6–$10 a week in prepaid credit on top of the $120 Premium seats ($30 × 4).
    • Super and Ultra simply enlarge the Cursor-model pool; they do not change the third-party rate.

    Teams seats add the Cursor Token Rate of $0.25 per million tokens on eligible third-party requests. On the same Claude volume that is another $0.075–$0.10 per user per week. Cost mode and Cursor models remain exempt.

    # Illustrative monthly estimate for one user (not a measured result)
    # Assumes 2M tokens/month, 60% Composer / 40% Claude Opus 5.5, 30% cache hits
    composer_in = 1_200_000 * 0.50 / 1_000_000  # $0.60
    composer_out = 200_000 * 2.50 / 1_000_000   # $0.50
    claude_in = 800_000 * (0.7 * 4.00 + 0.3 * 0.20) / 1_000_000  # ~$2.30
    claude_out = 200_000 * 20.00 / 1_000_000    # $4.00
    print(f"Prepaid credit burn: ${composer_in + composer_out + claude_in + claude_out:.2f}")
    # Output: ~$7.40 before any Token Rate

    Scale that illustrative $7.40 by four users and you get about $30 of prepaid credit on top of $120 in Premium seats — roughly $150 a month before tax. The same seats on Teams add a small Token Rate line on the Claude share only. Plus stays near $32 if nobody leaves the Grok/Composer lane.

    Stacked bar chart of illustrative monthly cost for 4 Cursor users: Plus seats $32, Premium seats $120 plus about $30 Claude prepaid credit, Teams Premium $120 plus credit plus Token Rate
    Illustrative 4-user month: Plus ~$32 seats; Premium ~$150 with Claude prepaid credit; Teams adds a small $0.25/M Token Rate line.

    Who Should Pick Which?

    • Plus: choose it if the team is content with Grok 4.7 and Composer 2.5 and wants the lowest fixed cost. The $8 price is real only while the work stays inside those models.
    • Premium: choose it when any user needs Claude, GPT, or Gemini inside Cursor. Budget the prepaid credit separately; the $30 seat does not include those tokens.
    • Super or Ultra: make sense only if the Cursor-model weekly pool is the bottleneck (15x or 50x Plus). They do not discount Claude or GPT.
    • Teams: choose it when you need shared administration, SSO, or pooled usage. Factor the $0.25/M Token Rate on eligible third-party traffic; it is small on light Claude use and material on heavy agent loops.
    • Legacy Pro holders: compare the exact remaining Other Models allowance before switching, because the switch to an X Subscription tier is permanent and may include a prorated refund (account and billing help).
    Decision tree diagram for choosing a Cursor plan for 4 users in 2026: need third-party models leads to Premium plus prepaid credit; Grok and Composer only leads to Plus; pool bottleneck leads to Super or Ultra; team admin adds Teams Token Rate check
    Start with third-party need, then pool size, then team admin — three questions route a 4-user team to Plus, Premium+, Super/Ultra or Teams.

    A practical test for four seats: run one real backlog task for a week on Plus with Composer only, then the same task on Premium with Opus 5.5, and compare the prepaid-credit line in the dashboard to the illustrative $7.40 math above.

    FAQ

    Does Plus include Claude or GPT?

    No. Plus is limited to Cursor models (Grok family and Composer 2.5) at fixed settings. Third-party models require Premium or higher and are billed at API list price from prepaid credit.

    What is the Cursor Token Rate?

    $0.25 per million tokens on eligible third-party model requests for Teams and Enterprise only. It applies to input, output, and cached tokens. Individual plans and Cursor models are exempt. Models with cache-read prices strictly below $0.10/M across every tier are also exempt.

    How do annual prices compare?

    Plus is $80/year, Premium $300, Super $1,000, Ultra $2,000. That is roughly 17% off the monthly rate. Prices exclude tax.

    Can I still buy the old $20 Pro plan?

    Not as a new customer. Legacy Pro, Pro+, and Ultra continue for existing subscribers. Switching to an X Subscription tier is permanent and may include a prorated refund.

    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 5, 2026 and may change.

    © 2026 JSCC AI Notes

  • 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