---
title: MAI Code 2 vs Flash — Copilot pricing and coding benchmarks
description: >-
  Compare Microsoft MAI Code 2 and MAI Code 2 Flash in GitHub Copilot. Check
  promo pricing, what 98% of GPT-6.1 Sol means, and when a fix warrants the
  larger model.
canonical_url: 'https://onevium.com/blog/mai-code-2-vs-flash-pricing-benchmarks'
language: en
published_at: '2026-11-18'
publisher: Onevium
---
# MAI Code 2 vs Flash — Copilot pricing and coding benchmarks

Compare Microsoft MAI Code 2 and MAI Code 2 Flash in GitHub Copilot. Check promo pricing, what 98% of GPT-6.1 Sol means, and when a fix warrants the larger model.

## Should you start with MAI Code 2 Flash or the larger model?

You click “price: low to high” and a $10 quote appears before a $9 one. If one comparison function needs changing and you can test the result immediately, I’d start with **MAI Code 2 Flash**. If the same ordering also drives a CSV export, a paginated list and a “restore import order” button, I’d write down the acceptance criteria and try **MAI Code 2** across those boundaries.

Microsoft launched both coding models at Ignite on November 17, 2026. It positions Code 2 for multi-file implementation and reasoning across a repository, and Flash for explanations, focused edits and quick iterations. Launch rates for uncached input and output differ tenfold in GitHub Copilot. The budget question is how you will discover a mistake. Can one test catch it, or will a reviewer have to walk the whole workflow again? [Microsoft’s release](https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/) · [GitHub availability announcement](https://github.blog/changelog/2026-11-17-mai-code-2-and-mai-code-2-flash-in-github-copilot/)

## Which GitHub Copilot plans include MAI Code 2 or Flash?

GitHub lists **Flash for Copilot Free and Student**. Pro, Pro+, Max, Business and Enterprise can select both models. Supported surfaces include VS Code, Visual Studio, Copilot CLI, github.com and JetBrains. If a team member cannot find a model in the picker, check the organization’s model policy, the client and the plan before changing a development setup. [GitHub’s list of plans, clients and administrator controls](https://github.blog/changelog/2026-11-17-mai-code-2-and-mai-code-2-flash-in-github-copilot/)

For application developers, Microsoft’s model-specific announcement identifies a **limited-access preview of MAI Code 2 Flash in Microsoft Foundry**. A Copilot seat gives you a model picker. A Foundry integration needs its own deployment, endpoint and credentials. If you have an approved endpoint to use with a custom Onevium connection, verify its upstream model ID, protocol and tool support with a small request first. [Microsoft’s deployment details](https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/) · [Onevium custom connections](https://onevium.com/docs/providers/custom)

## MAI Code 2 pricing vs Flash — what would 100 coding requests cost?

These are GitHub Copilot’s **usage-based** rates in US dollars per million tokens. The cached-input column applies to cache hits. GitHub’s pricing footnotes give May 17, 2027 as the changeover to regular rates. [GitHub model pricing and promotional footnotes](https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing)

| Model and period                      | Uncached input | Cached input | Output |
| ------------------------------------- | -------------: | -----------: | -----: |
| MAI Code 2, launch promotion          |          $0.50 |       $0.025 |  $2.50 |
| MAI Code 2 Flash, launch promotion    |          $0.05 |       $0.005 |  $0.25 |
| MAI Code 2, after the promotion       |          $1.00 |        $0.05 |  $5.00 |
| MAI Code 2 Flash, after the promotion |          $0.10 |        $0.01 |  $0.50 |

Suppose a change takes **40,000 uncached input tokens, 60,000 cached input tokens and 4,000 billed output tokens**. At launch pricing that is **$0.0315 on Code 2** and **$0.0033 on Flash**. Repeat that exact usage 100 times and the totals are **$3.15 and $0.33**. The gap depends on the mix. Uncached input and output are ten times as expensive on Code 2, while cache reads cost five times as much.

GitHub converts usage at **$0.01 per AI credit**. The estimate gives the value of the model tokens. Included allowances, retries and other services determine what reaches an invoice. Existing annual Pro and Pro+ customers who stayed on legacy request-based billing use a separate schedule. GitHub lists a **1×** request multiplier for Code 2 and **0.33×** for Flash on those plans. [GitHub usage-based pricing](https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing) · [Legacy annual-plan multipliers](https://docs.github.com/en/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans)

## MAI Code 2 benchmarks vs GPT-6.1 Sol and Claude Opus 5.5

Microsoft reports that across four coding evaluations, MAI Code 2 averaged **98% of GPT-6.1 Sol’s performance at about 40% of the cost**. Against **Claude Opus 5.5**, the same release comparison puts Code 2 at about **96% of its performance and 5% of its cost**. The denominator in the 98% headline is the comparison model’s performance across the suite. Individual task pass rates answer a different question. [Microsoft’s comparison and methodology notes](https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/)

The four evaluations are DeepSWE 1.1, Terminal-Bench 2.1, SWE Atlas and FrontierCode 1.1. All models ran at maximum reasoning effort. Microsoft used the Copilot CLI without subagents on MSBench for the first three. It sourced FrontierCode 1.1 scores and costs from Artificial Analysis and priced its model at the **50% launch discount**. Its separate Flash comparison uses the first three suites and reports performance comparable to GPT-6 Luna and Claude Haiku 5.5 at about 65% and 20% of their respective costs. [Microsoft’s footnotes](https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/) · [Artificial Analysis’s FrontierCode 1.1 evaluation](https://artificialanalysis.ai/evaluations/frontiercode)

Section 3 of the model card puts the two MAI models in the same Copilot CLI harness. It generally averages single-attempt pass rates over three independent runs per task and counts infrastructure errors as failures. On **DeepSWE 1.1**, Code 2 scores 73.2% and Flash 59.9%. On **Terminal-Bench 2.1**, the scores are 84.6% and 78.3%. On **SWE Atlas**, Flash edges ahead at 44.8% to Code 2’s 43.1%. That suite includes codebase questions, test writing and refactoring. The lead changes with the work the benchmark asks a model to do. [Microsoft model card, pages 6–7](https://microsoft.ai/pdf/MAI-Code-2-And-MAI-Code-2-Flash-Model-Card.pdf#page=6)

Onevium’s GPT-6.2 comparison uses **FrontierCode 2.0** for Astra and Sol. Microsoft’s headline uses GPT-6.1 Sol and the earlier FrontierCode suite. To rank MAI directly against GPT-6.2 for a team, give them the same task, tools and review criteria. [GPT-6.2 Astra vs Sol pricing and benchmarks](https://onevium.com/blog/gpt-6-2-astra-vs-sol-pricing-benchmarks)

![Microsoft maximum-effort pass rates for Code 2 and Flash. DeepSWE 1.1 scores are 73.2% and 59.9%, Terminal-Bench 2.1 scores are 84.6% and 78.3%, and SWE Atlas scores are 43.1% and 44.8%.](https://onevium.com/assets/blog/mai-code-2-flash-benchmarks-en.webp)

Redrawn from section 3 of Microsoft’s model card. These are pass rates on three named suites, with the same Copilot CLI harness.

## Give both models the same quote table and score the fix

The exercise is one function. A quote stores its price in cents. A price of zero means free and `null` means “ask for a quote.” Give both models the business rule up front. Unpriced items go last in both directions. Equal prices stay in import order. The original array must survive so that a user can restore that order. [Download the offline exercise and six checks](https://onevium.com/downloads/mai-code-2-sort.zip)

We ran the same Node.js checker on three implementations supplied with the exercise. The starting function compares prices as strings and passes **2 of 6**. A numeric-only fix that copies the array passes **4 of 6**. Its two failures come from JavaScript treating `null` as zero in subtraction. Given “unpriced, free, $9” in that order, the unpriced item can still precede the free one. The reference implementation handles missing prices before comparing numbers and passes **all 6**.

| Input or action                                  | What the reviewer should see                                                       |
| ------------------------------------------------ | ---------------------------------------------------------------------------------- |
| Sort $9, $10 and $2 both ways                    | $2, $9, $10 ascending, then $10, $9, $2 descending                                 |
| Sort unpriced, free and $9                       | Free, $9, unpriced ascending. $9, free, unpriced descending.                       |
| Sort two equal prices, then restore import order | The tie keeps its order. The original array and its records still match the input. |

We wrote and ran the three supplied implementations. Our Copilot CLI reported both model selections unavailable for this exercise. The head-to-head model scores above come from Microsoft’s separate benchmark. To collect the two models’ scores, use fresh sessions with the same reasoning effort and tools. Give each model only `starter.mjs` and the business rule above. Save its first proposed function separately. After review, put one answer in `candidate.mjs` and run `node check.mjs ./candidate.mjs` from the extracted directory. The checker names each failed condition. Keep that output, the human edit, any extra runs and actual usage together. They tell you whether the higher rate bought you a shorter review.

## When would you switch from Flash to MAI Code 2?

If Flash’s function passes all six checks and a reviewer can inspect the complete change in minutes, I’d accept it. Save the larger model for the report that the table is fixed but the CSV is still sorted incorrectly, or that switching pages loses the selected order. Now there are multiple consumers to trace and an integration test worth writing.

One issue belongs with the product owner first. Sales wants unpriced items at the bottom. Procurement wants them at the top. Either implementation can pass a test written for one department and disappoint the other. Establish which rule applies in each view, then put both models up against it. For the next default-model decision, compare what each accepted patch cost and how much reviewer time it took. [How to measure the value of an AI workflow](https://onevium.com/blog/measure-ai-workflow-value)

Source: [Microsoft AI · Introducing MAI Code 2 and MAI Code 2 Flash](https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/)
