Recursive Flint is IMPRESSIVE
A 40B param MoE model that rips on relatively low power hardware
10/26/2026
When I first saw the release of Recursive Flint I was a little skeptical. Benchmarks show shocking performance on M4 Pros at a level of intelligence that beats the best from Qwen / Gemma /etc in this footprint of around 27-50B parameters. So I took a spare 64GB Mac Mini and fired it up against the same harness and test suites I bench the considerably larger 2x 128GB DGX Spark class models on. The results? Really damn impressive. Full results here.
Speed (spark-tuning/scripts/bench_decode.py, 1,000 decode tokens)
| Context target | Prompt tokens | Time to first token | Decode tok/s | Prefill tok/s |
|---|---|---|---|---|
| 1K | 823–998 | 1.2–1.6 s | 114–120 | ~670 |
| 16K | 12,823–15,414 | 21–27 s | 84–91 | ~565–610 |
| 64K | 51,223–61,630 | 128–169 s | 45–51 | ~360–400 |
| 128K | 102,423–123,485 | 377–528 s | 26–31 | ~235–272 |
First off the speed. Because it's only 2.5B active params it's pretty damn quick on an M4 Pro (and I would guess 5% quicker on an M5 Pro). Prefill is predictably quite slow, but decode is solid, degrading with context length pretty severely. But this isn't terrible, as long as your use case doesn't require regular fast turn around time on uncached prompts. rec serves one request at a time, up to Flint's full 262K context, which fits in about half of a 64GB Mac.
Quality (spark-tuning's harness, data and sandbox; 32K budget; one run per cell)
| Test | T=1.0 (card) | T=0.6 | T=0 | Best Spark run (spark-tuning) |
|---|---|---|---|---|
| HumanEval+ (164), base / plus | 97.6 / 88.4 | 97.6 / 91.5 | 96.3 / 90.2 | 95.7 Qwen FP4-Local medium (16K) |
| MBPP+ (378), base / plus | 94.7 / 79.4 | 94.2 / 79.1 | 93.7 / 79.1 | 83.6 GLM FP4-Local low (thinking-off path) |
| GSM8K (1319) | 96.29 | 96.59 | — (skipped) | 96.5 |
| LiveCodeBench (80) | 65.0 | 71.2 | 70.0 | 58.8 MiMo / GLM FP4-Local, 32K |
| LCB answers at the 32K cap | 21 | 19 | 19 | 28–36 |
| LCB mean completion tokens | 16,983 | 16,608 | 16,872 | 13,800–18,667 |
Time to solve (concurrency 1)
| Setting | HE+ solved / 41 | s per problem | s per solved | mean tokens | LCB solved / 10 | s per problem | at the cap |
|---|---|---|---|---|---|---|---|
| Flint T=1.0 | 35 | 18.6 | 21.7 | 1,963 | 4 | 311 | 4 |
| Flint T=0.6 | 36 | 15.9 | 18.1 | 1,741 | 5 | 282 | 4 |
| Flint T=0 | 37 | 24.4 | 27.1 | 2,555 | 5 | 269 | 4 |
Flint T=0.6, 16K (results/quality/FLINT-TTS-t06) |
36 | 16.2 | — | — | 1 | — | 8 |
Spark, Qwen FP4-Local medium, 32K |
36 | 14.3 | 16.3 | 935 | 1 | 564 | 9 |
| Spark, MiMo thinking on, 32K | 37 | 22.1 | 24.5 | 1,005 | 1 | 717 | 8 |
Spark, GLM FP4-Local high, 32K |
37 | 9.0 | 10.0 | 370 | 3 | 628 | 6 |
With a full 32K budget we see the little INT4 model often outperforming the much larger FP4 local versions of Qwen 3.8 Flash Next and GLM 5.3 Flash running TP=2 on a pair of DGX Sparks on hard problems; while it trails slightly on the easy ones. Flint is not particularly temperature sensitive, 0.6 was slightly better, though not significantly, which we also see with Qwen and company. Not only was Flint solving more LiveCodeBench problems within the budget but it was often faster to get there on the "hard" problems despite being on much weaker hardware.
So these results were super promising, though there was some concern it was just "benchmaxxed" against these problems. So we took problems from AtCoder after Flint's knowledge cutoff (June 2026) and had Qwen run them on the Spark cluster to compare:
AtCoder 2026-07-04 to 2026-10-25, by stratum (solved / problems):
| easy (33) | medium (33) | hard (81) | ABC (109) | ARC (38) | |
|---|---|---|---|---|---|
| Flint int4, T=0.6 | 33 | 30 | 37 | 88 | 12 |
Qwen medium |
33 | 25 | 21 | 72 | 7 |
Qwen xhigh |
33 | 26 | 19 | 69 | 9 |
Overall Flint scored 68.0% vs Qwen's 53.7% on AtCoder problems. On the older LiveCodeBench problems, scored the same way*, it was 76.2% vs 53.8%. So Flint dropped about 8 points on problems newer than its training data while Qwen didn't move. The lead shrank from 22 to 15 points on recent AtCoder problems*. The benchmaxxing worry was partly right, but most of the lead is real.
I look forward to trying Flint for some actual work this week and see if this level of smarts holds for my actual work. In my testing rec 0.1.0 crashed after about 30 hours with a Metal memory-allocation error, but I suspect this is a rough edge that will get fixed soon.
This is shockingly impressive, and certainly the best model I have run on a (relatively) small Mac. It is also going to be a really compelling option on the new (stupidly expensive) 64GB DGX Spark as well as those RTX Spark laptops that just came out. Exciting stuff!
* Caveat: Scored on each problem's sample tests only (AtCoder no longer publishes full tests)