Recursive Flint: 40B Open Model, 2.5B Active

Recursive has published Flint, a coding model released under Apache 2.0 with 39.8 billion total parameters and roughly 2.5 billion active per token. The headline is that sparsity ratio. A mixture-of-experts model this sparse does far less arithmetic per token than its total size suggests, which is the whole argument for running it on hardware you own. The benchmark numbers attached to the release are the vendor's own, and that distinction matters more than usual here.

Everything below comes from the published model card, read during this run. Where the card is silent, this post says so.

The architecture, in plain terms

Flint is a decoder-only mixture-of-experts transformer with 49 layers, two dense and 47 MoE. Each MoE layer holds 256 routed experts. For any given token a router picks six of them, plus one shared expert that is always active. That is how 39.8B parameters becomes about 2.5B of actual work per token, and the card notes the active body alone is closer to 2.2B once the output head is excluded.

If the routing idea is new to you, our explainer on mixture of experts covers why picking a few experts per token is not the same as running a small model.

The attention design is where Flint diverges from the usual recipe. Of 49 layers, 35 use sliding-window attention with a 513-token window and 14 use full attention. It runs 32 query heads against 4 key/value heads at head dimension 128, with per-head QK RMSNorm, learned per-head attention sinks, and rotary embeddings applied only on the sliding-window layers. The documented context window is 262,144 tokens, shared between prompt and output, and the card is explicit that this is a capacity limit rather than a promise of even accuracy across the whole range.

The benchmark numbers, and who produced them

These are the release evaluations as the card reports them. No independent reproduction existed at the time of writing.

The card gives its settings, which is better practice than most releases manage: temperature 1.0, top-p 0.95, top-k 20, scores averaged as pass@1 over at least five attempts. It also states that on Terminal-Bench, solutions reached through web retrieval were counted as failures, which makes that 54.9% a stricter number than it looks.

Treat the spread between 89.7% and 74.2% as the interesting part. Two numbers from the same family of benchmarks that differ by fifteen points are measuring different things, and the gap is a reminder that a benchmark name is not a score. Our guide to reading vendor benchmarks covers what to check before repeating a figure, including why a model that has already seen the test set scores well without being good.

What it costs to actually run

This is where the laptop framing in much of the coverage gets ahead of the card. The card's own deployment guidance is one B300 or H200 GPU per replica using the SGLang kit, with a download of about 80 GB for the BF16 checkpoint. That is a server, not a laptop.

The local story comes from the quantised builds, which the card says are prepared separately for NVIDIA and Apple Silicon runtimes rather than shipped in the main repository. Quantisation is what brings the memory requirement down far enough to matter on a workstation, at some cost in output quality. Our explainer on how much VRAM a local model needs covers the arithmetic, and whether any of this beats paying per token is the question we worked through in self-hosting an open-weight model versus an API.

Two other practical notes from the card. Transformers modelling code was not yet included at publication, so your runtime options are narrower than the licence implies. And the card recommends an output budget of at least 32,768 tokens for hard problems, because reasoning is counted inside that budget.

What Apache 2.0 does and does not give you

Apache 2.0 on the weights is genuinely permissive, including for commercial use. The card is careful to note that hosted API terms and data practices are separate from the weight licence, which is the distinction people most often collapse. Open weights are not the same thing as open source, and our piece on the difference between open weights and open source sets out what is actually being released in each case.

What the card admits

The stated limitations are worth repeating because they are specific rather than boilerplate. The model can produce incorrect or harmful content, faulty code, or inappropriate tool calls, and the card's advice is to test generated code and review consequential changes before applying them. Long reasoning can increase latency and exhaust the output budget. Results vary with checkpoint precision and inference runtime, which is a direct warning that a quantised build will not reproduce the table above.

The card gives no explicit release date. It does state a knowledge cutoff of June 2026, which is the figure to keep in mind if you point it at a library that has changed since. For a way of tracking releases like this one without reading every launch post, see our guide to keeping up with AI news.

Frequently asked questions

Can Flint run on a laptop?

Not the published BF16 checkpoint, which is about 80 GB and is documented against a single B300 or H200 GPU. Quantised builds for Apple Silicon and NVIDIA runtimes are published separately and are what local use depends on.

Is the 89.7% SWE-bench Pro score independently verified?

No. It is a release evaluation reported by Recursive on its own model card. The same card reports 74.2% on SWE-bench Verified, which is a different benchmark with a different difficulty profile.

What does 2.5B active parameters mean?

Only a fraction of the network runs for each token. A router selects six of 256 experts per MoE layer plus one always-on shared expert, so the compute per token resembles a much smaller model while the stored weights remain 39.8B.

Does the Apache 2.0 licence cover commercial use?

Yes, for the weights. The card separates the weight licence from the terms covering any hosted API, so check those separately if you use the vendor's own service rather than running the weights yourself.