Microsoft Cuts Coding Model Price to One-Quarter

Microsoft today (August 12) released the coding model MAI-Code-1.1-Flash. An upgrade to MAI-Code-1-Flash, which debuted in June, the new version does not focus on increasing parameter count or extending the context window. Instead, it directly improves the three areas developers notice most: success rates on coding tasks, generation speed, and usage costs.

According to data released by Microsoft, the new model delivers a 22% performance improvement on Terminal-Bench 2.1 when executing tasks through GitHub Copilot CLI and a 15% improvement on .NET-related tasks. Token generation speed is up 25%, while the number of tokens required to complete the same task is down 25%. Pricing has also fallen to roughly one-quarter of that of the original model.

In other words, this is not a minor update that merely adds a few points to benchmark scores. Microsoft is attempting to transform MAI-Code from “another optional model in Copilot” into a default execution layer cheap enough to be invoked frequently.

Pricing Falls to About One-Quarter, With Output Tokens at Just $1.20

According to pricing published by GitHub Copilot, MAI-Code-1.1-Flash is billed at:

• Per 1 million input tokens: $0.20, approximately RMB 1.4;
• Per 1 million cached input tokens: $0.02, approximately RMB 0.14;
• Per 1 million output tokens: $1.20, approximately RMB 8.1.

The corresponding prices for the original MAI-Code-1-Flash were $0.75, $0.075, and $4.50. Strictly speaking, the prices of all three tiers in the new version are about 26.7% of the old version’s prices—not exactly 25% in mathematical terms—but describing them as “about one-quarter” is reasonable.

| Billing Item | MAI-Code-1-Flash | MAI-Code-1.1-Flash | Reduction | | --- | ---: | ---: | ---: | | Input tokens / 1 million | $0.75 | $0.20 | About 73.3% | | Cached input tokens / 1 million | $0.075 | $0.02 | About 73.3% | | Output tokens / 1 million | $4.50 | $1.20 | About 73.3% |

For users with annual GitHub Copilot subscriptions, the new model has a 0.25× premium request multiplier. This means that, within Copilot’s quota system, four MAI-Code-1.1-Flash requests would theoretically consume the equivalent of one premium request with a 1× multiplier.

It is important to note that the premium request multiplier and API token billing are not the same thing. The former determines quota consumption within Copilot plans, while the latter is closer to the model inference costs familiar to developers. Microsoft’s reduction of both types of costs indicates that this upgrade is not merely intended to attract API customers. More importantly, it is designed to increase the frequency with which models are invoked within Copilot.

The Real Cost Reduction Is More Than Fourfold

The lower unit price is only the most obvious reduction on paper. MAI-Code-1.1-Flash also claims to reduce the number of tokens needed to complete the same task by 25%. If this figure can be reproduced in real-world codebases, developers’ actual cost savings will be greater than the price list suggests.

Consider a simplified example: a coding agent task consumes 1 million input tokens and 500,000 output tokens, with caching temporarily excluded from the calculation.

Using the original model, the cost would be:

• Input: $0.75;
• Output: $2.25;
• Total: $3.00.

Using the new model while keeping token usage unchanged, the cost would be:

• Input: $0.20;
• Output: $0.60;
• Total: $0.80.

If token usage for the same task is then reduced by 25%, as Microsoft claims, the cost would fall further to approximately $0.60. Compared with the original model, that represents a theoretical reduction of 80%.

Of course, this is only a linear estimate. Actual costs will also be affected by cache hit rates, the number of tool-call rounds, repository size, and the number of retries after failures. This is especially true in agent scenarios: even if a model is cheaper per invocation, the final bill may still exceed that of a more expensive but more reliable model if it frequently takes the wrong path, repeatedly reads files, or modifies the same code over and over.

Therefore, the key question for MAI-Code-1.1-Flash is not “how cheap is each million tokens?” but whether Microsoft’s claims of improved capabilities and reduced token usage can both hold true at the same time. If the savings come only from shorter answers, their value is limited. If the model genuinely reduces wasted reasoning, repeated reads, and error correction, then it represents a meaningful efficiency upgrade for coding agents.

A 22% Improvement on Terminal-Bench Shows It Wants to Take Over the Terminal

Microsoft chose to highlight Terminal-Bench 2.1 rather than focusing solely on code-completion benchmarks. The signal is clear: MAI-Code-1.1-Flash is not intended for the traditional task of “writing the next line of code,” but for coding agents capable of continuously executing operations in a terminal.

Typical tasks may include:

1. Reading the repository structure and project documentation;
2. Locating the faulty module;
3. Modifying multiple files;
4. Running builds, tests, or static checks;
5. Making further adjustments based on errors;
6. Providing a final summary of the changes.

These tasks are very different from autocomplete in an IDE. If a completion model occasionally writes an incorrect line, the developer can immediately delete it. If a terminal agent makes an incorrect judgment, however, it may execute more than a dozen consecutive steps, wasting both time and tokens in the wrong direction. Terminal-Bench primarily evaluates a model’s ability to complete multistep tasks in a terminal environment, so a 22% improvement is more relevant to how Copilot CLI is actually used than an isolated code-generation score.

Benchmark figures still need to be viewed with caution, however. Microsoft has so far disclosed only relative improvements. The reference materials do not provide the new version’s absolute score, nor do they show comprehensive side-by-side results against contemporary models such as Claude, GPT, GLM, or Kimi in a standardized environment. A relative improvement of 22% could be substantial, or it could simply mean moving from a low baseline to a usable level.

Until third-party retesting becomes available, the more reasonable conclusion is: MAI-Code-1.1-Flash is moving in the right direction, but vendor-provided data alone is not enough to declare it the most powerful coding model.

A 15% Improvement on .NET: Microsoft’s Home Turf and the Market It Most Needs to Win

The new model’s 15% improvement on .NET tasks is unsurprising.

From training data and toolchains to distribution channels, Microsoft has advantages in the .NET ecosystem that other model vendors would find difficult to replicate. Visual Studio, VS Code, GitHub, Azure DevOps, NuGet, C#, and GitHub Actions can collectively form a complete development context. It would be difficult to justify a proprietary model optimized for Copilot if it could not even perform well on .NET.

For enterprise development teams, this improvement may be more valuable than scores on general-purpose coding benchmarks. A large number of internal systems are still built on C#, ASP.NET Core, SQL Server, and Azure services. Their tasks typically involve not generating a webpage from scratch, but maintaining decade-old business repositories, upgrading dependencies, adding tests, migrating APIs, or troubleshooting deployment failures.

The difficulty in these scenarios is not whether a model knows how to write the syntax, but whether it can understand solution structures, project references, build configurations, and internal enterprise constraints. If Microsoft can deeply integrate MAI-Code-1.1-Flash’s .NET optimizations into Copilot workflows, that will be more competitive than simply improving results on short-code tests such as HumanEval.

25% Faster Generation Plus 25% Shorter Output Could Produce a More Noticeable Difference

Microsoft says the new model’s token generation speed has increased by 25%. On its own, this means that the generation time for an output of the same length could theoretically be reduced by about 20%, because when speed rises from 1 to 1.25, the time required falls to 0.8 of the original.

If the number of tokens required for the same task is also reduced by 25%, then, considering only the output-generation stage, the theoretical time could fall to:

0.75 ÷ 1.25 = 0.60.

That means a reduction of up to approximately 40%.

This also cannot be directly equated with a 40% reduction in end-to-end latency. Coding agents must still wait for file retrieval, shell commands, compilation, testing, and network requests, while time to first token may not improve at the same rate. However, for tasks that require repeated model invocations, faster generation and shorter outputs compound, usually producing a more noticeable improvement than either metric alone.

For Copilot, speed may even be more important than peak capability. Developers may accept a highly capable agent that runs in the background for ten minutes, but they are unlikely to tolerate waiting dozens of seconds every time they rename a variable or ask for an explanation of an error. The Flash series is targeting precisely these high-frequency, short-chain, latency-sensitive requests.

Native Vision Added, but Its Value Depends on How Copilot Implements It

MAI-Code-1.1-Flash also adds native vision capabilities, enabling it to understand and analyze image content.

For a coding model, vision is not just about “describing an image.” More practical uses include:

• Generating frontend pages from product mockups;
• Comparing design files with browser screenshots to identify discrepancies in spacing, color, or layout;
• Reading terminal errors, monitoring dashboards, and performance flame graphs;
• Analyzing architecture diagrams, database relationship diagrams, and flowcharts;
• Locating UI regression issues from mobile screenshots.

However, the model having vision capabilities does not mean that all Copilot interfaces already support complete image-based workflows. The final experience depends on how GitHub and VS Code pass images to the model, whether they support multiple images in context, whether they can integrate with browsers or testing tools, and how image tokens are billed.

If users can only upload a screenshot and generate a piece of code, the difference from existing multimodal models will not be substantial. Vision will become genuinely productive for coding agents only if they can automatically capture screenshots, run webpages, compare the output against design files, and continuously make corrections.

Microsoft Needs Its Own Model, Not Just Another Option

After MAI-Code-1-Flash was first unveiled in June this year, it was added to GitHub Copilot to compete alongside models from vendors such as OpenAI and Anthropic. Two months later, Microsoft quickly launched version 1.1 with a substantial price cut. There is more behind this than routine model iteration.

Copilot built its product advantage by relying on external models, but model usage is also a continually growing expense. As development tools evolve from “occasionally completing code” to “automatically reading repositories and executing dozens of steps,” the amount of inference consumed by each user per day could increase by an order of magnitude. Even if subscription revenue remains unchanged, backend model costs could rapidly erode gross margins.

Developing MAI-Code in-house gives Microsoft control in three areas:

• Cost control: Reduce reliance on expensive external models and route high-frequency requests to Microsoft’s in-house model;
• Product optimization: Train specifically for Copilot CLI, VS Code, and .NET tasks rather than waiting for general-purpose models to adapt;
• Supply-chain bargaining power: Even if OpenAI or Anthropic models are still used for difficult tasks, Microsoft can keep baseline traffic in-house.

This is also what makes MAI-Code-1.1-Flash most noteworthy. It may not need to beat flagship models on every coding benchmark. As long as it can handle most everyday requests at a sufficiently low price, it can become Copilot’s “economical workhorse.” More capable models can handle complex architecture design and difficult debugging, while Flash takes care of code search, simple modifications, test generation, and terminal operations, making overall costs more manageable.

Low Cost Is No Longer an Extra—It Is a Core Capability of Coding Models

When the original MAI-Code-1-Flash was released, low cost and inference efficiency were already major selling points. But prices in the coding-model market are falling rapidly. Chinese models continue to drive down usage fees, while vendors such as OpenAI and Anthropic are also competing for developer workloads through smaller model variants, cache pricing, and batch-processing mechanisms.

In this market, a model’s ability to “write code” is no longer scarce. What truly affects model selection is a combination of metrics:

• Is the first-attempt success rate high enough?
• How many tokens are required to complete a task?
• Are tool calls reliable?
• What are the time to first token and total task latency?
• How much do input, output, and caching cost respectively?
• Can the model process images, logs, and large repositories?
• Is it easy to integrate with existing IDEs, CI/CD systems, and permission frameworks?

MAI-Code-1.1-Flash takes a pragmatic approach: instead of emphasizing the use of a larger model to overpower competitors, it advances capability, speed, and price together. For everyday development workloads, this is often more useful than ranking first on a single benchmark.

Teams using multi-model architectures also do not need to treat model selection as a single-choice question. They can use low-cost models for repository browsing, formatting changes, and test generation, while assigning complex refactoring or high-risk reviews to flagship models. Aggregation layers such as OpenAI Hub that are compatible with the OpenAI API can reduce the cost of switching models. However, whether MAI-Code-1.1-Flash will offer a standalone API and when it will become available through third-party platforms remain subject to future announcements from Microsoft and the relevant platforms. For now, its clearest use case remains GitHub Copilot.

Conclusion: This Upgrade Is More Pragmatic Than Expanding Parameter Count

MAI-Code-1.1-Flash does not try to generate attention with a larger parameter count. Instead, it reduces pricing to about one-quarter while improving terminal-task performance, .NET capabilities, generation speed, and token efficiency, in addition to adding native vision.

From a developer’s perspective, this is a more pragmatic path. Once coding agents truly enter production environments, their long-term viability will be determined not by a single impressive demonstration, but by how much each task costs, how long it takes, and how many times it fails.

The biggest unknowns at present are whether Microsoft’s reported improvements of 22% and 15% can be reproduced in complex private repositories, and whether the lower price is accompanied by more reliable tool use. If the answer is yes, MAI-Code-1.1-Flash will not merely become a cheaper option within Copilot—it could also become a key component in Microsoft’s efforts to reduce inference costs for its AI coding business.

References

• ITHome: Microsoft Launches the MAI-Code-1.1-Flash Coding Model—Summarizes Microsoft’s published benchmark improvements, token efficiency, Copilot request multiplier, and pricing information for the old and new models.