Recursive Releases Flint, a 40B Coding Model for Laptops

Recursive released Flint on October 21, 2026, a mixture-of-experts coding model with 39.8 billion total parameters that activates about 2.5 billion per token — small enough to run on a laptop, with weights under Apache 2.0. It is the first model from Recursive Superintelligence, the startup led by Richard Socher, and the company says its automated research system helped design most of the stack that produced it.

What Shipped

Flint is a decoder-only MoE with 49 layers — two dense, then 47 sparse — and 256 routed experts per layer, of which six are selected per token alongside an always-active shared expert. Attention splits between 35 sliding-window layers that see the current token plus 512 preceding ones, and 14 full-attention layers that carry no positional encoding. The vocabulary is 150,144 tokens and the stated knowledge cutoff is June 2026.

The parameter accounting is precise in a way that matters: the 2.5 billion active figure includes the output head but excludes the input embedding matrix, and the active body alone is about 2.2 billion. The BF16 checkpoint is roughly 80 GB, one B300 or H200 per replica with the bundled SGLang kit; Recursive also publishes an NVFP4 build for local hardware and an Apache-2.0 inference engine called rec tuned for M4 Pro and M5 Pro/Max. The weights run in llama.cpp, Ollama, LM Studio, vLLM and SGLang.

The Benchmark Claim, Scoped

Recursive’s headline is carefully bounded: Flint leads mixture-of-experts models with fewer than 50 billion total parameters on agentic coding benchmarks. Within that class the numbers are strong — 54.9% on Terminal-Bench 2.1, 89.7% on SWE-bench Pro v2 and 74.2% on SWE-bench Verified, plus 80.3% on LiveCodeBench v6 and 95.1% on IFEval.

The scope is doing real work, and Recursive’s own comparison shows why. Dense Qwen3.8 27B, in the same weight class, beats Flint on four of the six benchmarks: 73.0 against 54.9 on Terminal-Bench, 94.9 against 89.7 on SWE-bench Pro v2, 90.3 against 80.3 on LiveCodeBench and 75.6 against 74.2 on SWE-bench Verified. Flint wins IFBench and IFEval. The trade is speed: that dense model runs at roughly 11 tokens per second through a 128K session, against about 47 to 70 for Flint depending on runtime.

So the claim is not that Flint is the best coding model of its size, but that it buys most of that quality several times faster. Recursive also notes that its Terminal-Bench score counts solutions reached through web retrieval as failures, an adjustment developer-reported baselines may not share. Every figure is Recursive’s own measurement or a developer number it reproduced; no independent evaluator has published results yet.

Where the Speed Comes From

Two decisions carry most of the performance. The architecture was chosen by search: Recursive says it started from a 35B/3B baseline and let its automated system explore expert configurations and widths, landing on 40B total and 2.5B active.

The quantization is the more interesting half. Because so few parameters are active, the output layer is a large share of the weights read for every token, so Recursive quantized lm_head to four bits — against usual practice, which keeps output layers at higher precision — and recovered accuracy with offline distillation, training the quantized model on its own pre-sampled responses with the 16-bit model as teacher. The published deltas are small: 74.2 to 74.1 on SWE-bench Verified, 54.9 to 53.7 on Terminal-Bench 2.1, and a slight gain on LiveCodeBench. That is the difference between a 40B model needing a datacentre GPU and one fitting in a high-end laptop’s memory.

Built by the Eureka Machine

Recursive frames Flint less as a model release than as a test of its research automation. The Eureka Machine proposes ideas, implements them, tests them and uses the results to pick the next experiment; the company says it contributed to data, optimizers, training recipes, architecture search, quantization and kernels, and that a small team of people and agents built Flint from scratch in under four months. That is a claim about process, and the benchmarks measure the model, not the method.

What This Means

For a coding team the practical question is whether a 40B model at laptop speed beats a 27B model that scores higher and runs slower. For interactive work — completions, test generation, small fixes — latency dominates, and Flint sits in the right place on the frontier chart. For a hard refactor that a dense model gets right first time, the comparison still favours the dense model.

The unresolved detail is context. The release post advertises up to 512K tokens and recommends staying under 256K; the model card documents 262,144 tokens, noting the limit is capacity rather than a guarantee of uniform accuracy. Until the larger window is documented, the safe reading is roughly 256K. Flint does set a bar for how a small lab ships a model, though: weights, an inference engine, serving recipes, quantized builds with published deltas, and a benchmark appendix that names its harnesses and adjustments.

This post was drafted with AI assistance and reviewed by RITS staff.

Sources

• Recursive: “Introducing Flint” (October 21, 2026)
• Hugging Face: RecursiveSI/flint model card and benchmark charts
• GitHub: recursive-oss/rec, the local inference engine (Apache 2.0)
• Recursive documentation: getting started