Microsoft Shipped Its Own Coding Model and Trained It Without OpenAI Data. MAI-Code-1-Flash Is Free in Copilot — Here's When to Actually Route to It.

On June 2 at Build, Microsoft dropped MAI-Code-1-Flash into the GitHub Copilot model picker inside VS Code, rolling out to every paid tier: Free, Pro, Pro+, and Max. It's a 5-billion-parameter coding model, trained on Microsoft's own Copilot harnesses and licensed data rather than OpenAI's, and tuned hard for token efficiency. Alongside it came MAI-Thinking-1, a 35B mixture-of-experts reasoning model in private preview through Azure AI Foundry, which Microsoft is explicit about having trained without any OpenAI data.

The coverage is fixated on the benchmark scores. That's the least interesting part. The part that matters to a solo builder is the timing: this model showed up one day after Copilot switched to metered, token-based billing. That's not a coincidence, and it changes a small decision you make a hundred times a day.

What Microsoft actually shipped

MAI-Code-1-Flash is small on purpose. At 5B parameters it's roughly a Haiku-class model on price, and Microsoft built it to be fast and cheap rather than to top a leaderboard. It lives natively in the Copilot picker, so there's no new account, no separate key, no extra subscription. If you already pay for Copilot, it's just another entry in the dropdown.

MAI-Thinking-1 is the heavier sibling: a 35B active-parameter MoE with a 256K context window, aimed at the reasoning-heavy work that MAI-Code-1-Flash is too small for. It's enterprise-first, deployed through Azure AI Foundry, with third-party inference available via OpenRouter, Fireworks, and Baseten for teams that want to route around Azure. As a solo operator you probably won't touch MAI-Thinking-1 this month. MAI-Code-1-Flash you can use today.

The thing both models have in common is the sentence Microsoft keeps repeating: trained without OpenAI data. That's the headline they actually care about, and it's worth understanding why.

Why "without OpenAI data" is the real announcement

For three years Microsoft's AI story was OpenAI's story. Copilot ran on OpenAI models, Azure was OpenAI's compute, and the two companies were welded together by an exclusivity deal. That exclusivity unwound earlier this year, and MAI-Code-1-Flash is the first product you can touch that proves Microsoft meant it. They now have a model they own end to end, running on infrastructure they control, that they can price however they want.

That matters to you because it's a signal about cost. Microsoft makes nothing extra when you burn OpenAI tokens through Copilot: that's margin flowing to a partner. When you burn MAI-Code-1-Flash tokens, the whole stack is theirs. A vendor that owns the model has every incentive to make its own model the cheap default and the frontier models the premium upcharge. That's exactly the structure you should expect Copilot's pricing to drift toward.

When you should actually route to it

Here's the practical decision, and it's not "switch everything to MAI." A 5B model is not going to architect your auth flow or untangle a gnarly race condition. It will absolutely handle the boring 70%: renaming things across a file, writing the obvious test, scaffolding a component, fixing a type error, converting a function from promises to async/await. That work doesn't need a frontier model, and on metered billing, paying frontier-token prices for it is just lighting money on fire.

The math got real on June 1. Copilot now bills on AI credits, where one credit is a cent and your usage is tied to input, output, and cached tokens. Base subscription prices didn't move, but agentic sessions (the long, multi-step runs where the agent reads files, edits, re-reads, and edits again) eat tokens fast. Those are precisely the sessions where routing routine steps to a cheap, fast model instead of an expensive one compounds into a meaningful difference at the end of the month.

So the rule I'd use: make MAI-Code-1-Flash your default for mechanical edits and let it run. The moment it stalls, gives you a confidently wrong answer, or you can feel it flailing on something that needs judgment, switch the picker to your frontier model for that task and switch back. You're not choosing a model for life. You're choosing a model per task, and most tasks are boring.

What I'd actually do this week

Open the Copilot picker, select MAI-Code-1-Flash, and use it as your daily driver for a few days. Pay attention to two things: where it's genuinely good enough, and where it wastes your time. You'll build an instinct for the boundary within an afternoon, and that instinct is the entire skill here. Then keep your frontier model one click away for the hard 10%.

Don't migrate your whole workflow to it on faith, and don't dismiss it because 5B sounds small. The win isn't the model. It's the routing discipline. A solo operator who reflexively sends every keystroke to the most expensive model available is going to feel metered billing in a way that someone who routes deliberately won't.

The honest counter-take: it's possible MAI-Code-1-Flash is just mediocre, and the free-in-Copilot framing is Microsoft offloading inference cost onto a model that produces worse code, which costs you more in review time than it saves in tokens. That's a real risk with any small model, and the only way to know is to run it on your actual codebase, not a benchmark. If after a week it's costing you more in re-prompts and cleanup than it saves, drop it: cheap tokens that produce code you have to redo aren't cheap. But the structural bet behind it, that Microsoft will make its own model the cheap default, is going to be true regardless of whether this specific version is good. Learn to route now, because metered billing means the cost of not routing only goes up.

Author

Lukas

@lukcombinator

Sources

• Introducing MAI-Code-1-Flash — Microsoft AI
• Microsoft unveils new AI models to lessen reliance on OpenAI and lower costs for developers — CNBC
• Microsoft's new MAI models — Simon Willison
• Microsoft MAI-Thinking-1 & MAI-Code-1-Flash: Developer Guide — DEV Community
• GitHub Copilot is moving to usage-based billing — GitHub