Microsoft's Approach to LLM: MAI-Thinking-1

*On the technical report “MAI-Thinking-1: Building a Hill-Climbing Machine” by The Microsoft AI Team. Published June 2, 2026. Source: *

Microsoft AI shipped a technical report this week for MAI-Thinking-1, a reasoning model that scores 52.8% on SWE-Bench Pro and 97.0% on AIME 2025. Those numbers put it in the same room as frontier models its size. The numbers are not the story. The story is the sentence the team keeps returning to: they did not set out to build a model, they set out to build a hill-climbing machine, and the model is the product.

I want to walk you through what that means, because it is a real bet about how progress in AI happens, and the bet shows up in three choices most labs would not make.

Most teams bootstrap a new reasoning model by distilling traces from a bigger one. You take a strong model, sample its chains of thought, and train your model to imitate them. It is faster and it works. Microsoft said no.

Their first principle: capabilities should be learned, not inherited. They trained MAI-Base-1 on 30 trillion tokens of human-written data, processed in-house, with no synthetic data from language models and an active effort to strip AI-generated text out of the crawl. No distillation from third-party models. The RL climb starts from a checkpoint that has never seen a reasoning trace.

Here is the claim underneath the purity. Imitation gives you the answers but not the robustness. A model that copied its reasoning has no idea why the reasoning works, so it cracks under the long RL runs that actually build skill. I find this plausible and unproven in one move. The report asserts the steerability payoff more than it measures it. And note the asterisk: they do use self-distillation from their own earlier checkpoints to resume crashed runs, so the rule is about other people’s models, not about distillation as a technique.

The cost of this choice is enormous. You have to solve cold-start reasoning yourself, on an unstable RL run, with no teacher to fall back on. That is where the engineering lives.

Three specialist models do the early work, each with its own reward. One climbs STEM and competition code. One climbs agentic coding and tool use. One climbs helpfulness and safety. Then a supervised pass distills all three into a single model, and a final RL climb turns that into MAI-Thinking-1.

The reason to split first and merge later is mundane and correct: the three domains reward different things, and three teams can climb in parallel without stepping on each other. The risk is that consolidation flattens the specialist peaks. A model good at three things gives up the edge that three single-domain models keep. The final climb exists to claw some of that back. Whether it does is the open question the benchmarks alone cannot answer.

Here is what surprised me. The headline scores ride on a pile of unglamorous fixes to keep a long RL run from killing itself. Reinforcement learning over thousands of steps wants to diverge. The team’s real contribution is making it not diverge.

Start with the objective. They take GRPO and add two guardrails. The first is an asymmetric trust region with an upper bound that breathes. The second is a hard cap on the raw probability ratio that stops gradient-norm spikes.

def grpo_token_loss(ratio, adv, eps, k, r_max):

• r = ratio.clamp(max=r_max) # outer clip: kill extreme ratios*

• lo, hi = 1.0 - eps, 1.0 / (1.0 - eps) + k # asymmetric trust region*

• tr = r.clamp(lo, hi) # k widens the top, see below*

• return -(torch.minimum(r * adv, tr * adv)).mean()*

Read ratio as how much more likely the new policy makes a token than the old one, and adv as whether that token led to a better-than-average reward. The r_max clamp is the outer cap. It throws away any token where the two policies disagree by a wide margin, because those are the tokens that blow up the gradient. The lo, hi pair is the trust region, the band the update is allowed to move inside. The whole loss says: take the more pessimistic of the clipped and unclipped estimates, so the policy cannot reward-hack a noisy advantage. If r_max is missing, you get the spikes the team spent weeks chasing.

Now the part I like, because it is control theory wearing an ML coat. The upper bound hi is not fixed. A variable k widens it when the policy is too certain and tightens it when the policy is too random. They steer k with an integral controller that watches the policy’s entropy.