Recursive Flint is the first open coding model that claims frontier-tier SWE-bench numbers while running on a MacBook. Recursive released it on October 21, 2026, with 74.2% on SWE-bench Verified, 54.9% on Terminal-Bench 2.1, and more than 125 tokens per second on an M4 Pro, all from a model that activates about 2.5 billion parameters per token.
Every one of those numbers is vendor-reported, and the laptop claim has a big asterisk: you need 48 GB of unified memory. I went through Recursive’s launch post, the Hugging Face model card and the rec engine repo to work out what Flint actually needs, how it compares to the small open models I have covered before, and where it fits in a coding agent setup.
What Is Recursive Flint?
Recursive Flint is a 39.8B-parameter mixture-of-experts coding model with about 2.5B active parameters, released under Apache 2.0. It is the first model from Recursive, a lab founded in 2025 and led by Richard Socher, formerly Salesforce’s chief scientist. According to TechCrunch, Recursive came out of stealth in May with $650 million raised at a $4.65 billion valuation, backed by GV, Nvidia and AMD Ventures.
The headline story is how it was built. Recursive says its automated research system, the “Eureka Machine,” contributed to nearly every stage, from pretraining through inference. It proposes experiments, runs them and picks the next ones based on results. A small team plus that system built Flint from scratch in under four months.
The specific contributions are listed on the launch page, and they are more concrete than most “built by AI” claims:
- Architecture search: it started from a 35B total, 3B active baseline and landed on the 40B, 2.5B shape
- Low-bit training: per Socher, quoted by TechCrunch, this shrank Flint by 71% with almost no quality loss
- 4-bit output layer: it quantized
lm_headto 4 bits, which Recursive notes goes against common practice - Kernels: custom low-bit, MoE and attention kernels, including a Metal megakernel that fuses the whole decode pass on M4 and M5 chips
What Recursive does not say is how much researcher time the Eureka Machine saved. I would treat “largely built by AI” as a direction of travel rather than a measured result.
Recursive Flint Specs: What the Model Card Says
The Hugging Face model card is more detailed than the launch post:
- Parameters: 39.8B total, about 2.5B active per token (about 2.2B excluding embeddings and output head)
- Layers: 49, with 2 dense layers followed by 47 MoE layers
- Experts: 256 routed per MoE layer, 6 selected per token, plus one always-on shared expert
- Attention: 35 sliding-window layers (513-token window) and 14 full-attention layers
- Context: 262,144 tokens, shared between prompt and output
- Input / output: text only
- Knowledge cutoff: June 2026
- License: Apache 2.0
- Download: about 80 GB for the BF16 checkpoint
One inconsistency is worth flagging. The launch page says “up to 512k tokens” and recommends staying within 256K, while the model card states 262,144. I would plan around the model card’s number.
Tool calling is OpenAI-compatible with multi-turn support. The card tells you to keep the returned reasoning_content in conversation history and to budget at least 32,768 output tokens on hard problems. It also warns that tool-call grammar does not stop the model from choosing an unsafe action, so your harness has to enforce permissions.
This is a reasoning model with a long output budget, not a fast autocomplete model. Plan your context and latency around that.
Flint vs Mellum2.1 vs Qwen3.5-9B: Coding Benchmarks
Here are the published SWE-bench Verified scores for Flint and the small open coding models I have covered on this blog. Read the chart with the harness caveat below it.
- Recursive Flint (40B / 2.5B active) 74.2%
- Qwen3.5-9B 50%
- JetBrains Mellum2.1 (12B / 2.5B active) 47%
- Gemma 4 E4B 23%
| Model | Total / active params | SWE-bench Verified | Terminal-Bench 2.1 | Harness |
|---|---|---|---|---|
| Recursive Flint | 39.8B / 2.5B | 74.2% | 54.9% | mini-swe-agent / Terminus 2 |
| Qwen3.5-9B | 9B dense | 50.0% | 21.7% | Pi v0.73.1 |
| JetBrains Mellum2.1 | 12B / 2.5B | 47.0% | 17.4% | Pi v0.73.1 |
| Gemma 4 E4B | E4B | 23.0% | 3.4% | Pi v0.73.1 |
(Source: RecursiveSI/flint model card; JetBrains/Mellum2.1-12B-A2.5B-Thinking model card, Oct 2026. All vendor-reported.)
Flint and Mellum2.1 have the same active parameter count, which makes this the most interesting comparison. Flint scores 27 points higher on SWE-bench Verified with roughly 3.3x the total parameters. Since it activates the same 2.5B per token, speed per token should be similar on the same hardware, while memory needs are not.
Now the caveats, because they are real:
- Different harnesses. Recursive ran SWE-bench with mini-swe-agent and no internet. JetBrains ran its comparison in Pi v0.73.1 with a 114K context. Scaffolding moves these scores by several points.
- Pass@1 averaged over five attempts for Flint, with agent timeouts of up to five hours per task. That is generous compared to how most people run an agent day to day.
- Terminal-Bench 2.1 used Terminus 2 with internet access, and the model card says solutions found through web retrieval were counted as failures.
- No independent leaderboard had published Flint results at launch, as CellCog’s write-up points out.
Flint also lists 89.7% on SWE-bench Pro v2. That number looks out of line with its Verified score, and I would not compare it against older SWE-bench Pro figures from other vendors, since v2 is a different test set.
For scale, the Mellum2.1 review covers why a 12B model with an 8.1 GB quantized file is still the better pick for some setups, and Meta’s Muse Spark Open at 816B parameters scores 76.4% on Terminal-Bench 2.1 but needs at least 700 GB of accelerator memory.
On published numbers, Flint is the strongest open coding model you can plausibly run on one machine at your desk. It is not the strongest open coding model overall.
What Hardware Does Recursive Flint Need?
The realistic minimum is an M4 Pro, M5 Pro or M5 Max Mac with 48 GB of unified memory. That requirement comes from the rec engine README, which also asks for about 30 GB of free disk and Node.js 22 for the Pi harness.
Recursive’s speed claims:
- M4 Pro MacBook Pro: more than 125 tokens per second at short contexts (TechCrunch reports about 131)
- 64 GB NVIDIA RTX Spark: more than 150 tokens per second at short contexts
- Comparison: TechCrunch says similar models such as Gemma 4 and Nvidia’s Nemotron 3.5 Lightning ran at 58 to 69 tokens per second on the same Mac
- rec vs llama.cpp: 1.4x to 2.6x the throughput on an M4 Pro across 1K to 252K contexts, using 4-bit weights and excluding prefill
The footnote on the launch page defines speed as an average over a 128K-token session with prefill excluded, while the headline figures are for short contexts. Those two measurements are not the same thing, and prefill is exactly where long-context agent sessions on a laptop get slow.
On NVIDIA, the BF16 checkpoint is sized for one B300 or H200 per replica. Recursive says the final NVFP4 model scores within 0.7 points of the 16-bit one across its benchmarks.
If you have a 16 GB or 32 GB laptop, Flint is not for you yet. Mellum2.1 at 8.1 GB is.
How to Run Recursive Flint Locally
On a supported Mac, rec is the fastest route. These commands come from the rec repo:
# install rec to ~/.local/bin
curl -fsSL https://raw.githubusercontent.com/recursive-oss/rec/main/install.sh | bash
# start Flint and open the Pi harness (preferred) or OpenCode
rec launch pi
rec launch opencode
# or run an OpenAI-compatible server for other clients
rec serve # http://127.0.0.1:11500/v1, model name "flint"
rec auth token # API key for that serverAs with any curl | bash installer, read the script before you run it.
On a GPU box, the model card gives vLLM and SGLang snippets:
pip install vllm
vllm serve "RecursiveSI/flint"Use temperature 1.0, top-p 0.95 and top-k 20. Recursive used those for all its evals, and the server applies them when a request omits them.
For harnesses, Recursive’s getting-started docs cover OpenCode (local, or a hosted Flint-40B free tier with rate limits), Pi (local through rec, or free through Radius), Cline and OpenHands. Claude Code and Codex are not in the docs, and since rec serve speaks the OpenAI chat completions format, I would not expect Claude Code to work against it without a translation layer. If you want open models inside Claude Code today, the Together Link setup is the documented route, and the OpenCode 2.0 vs Claude Code comparison covers the harness Recursive supports best.
Where Flint Fits in a Coding Agent Stack
Recursive is upfront about the limits. Flint “may need more guidance than larger closed-source coding models,” and it recommends splitting complex tasks into smaller subtasks with explicit instructions. TechCrunch’s summary of Wired’s early review says the reviewer built a to-do app and a web research tool and found Flint got his requests right, which is encouraging but is two small projects.
That guidance lines up with how I already think about local models. They work best inside the spec-first, step-by-step workflow described in the agentic engineering guide, where the human writes a precise plan and the agent executes small, checkable chunks. Hand Flint a vague “refactor the billing module” prompt and you are testing its weakest area.
Where I would use it:
- Private codebases where code cannot leave the machine and an offline model is a requirement
- High-volume, low-stakes agent work like test scaffolding, lint fixes and boilerplate, where per-token API costs add up (compare the AI model pricing tracker to see what a hosted model costs for the same volume)
- Travel and flaky connections, which is a smaller use case but a real one
Where I would not use it yet is as the only agent on a long, multi-file refactor. Frontier cloud models like Claude Opus 5.5 publish results on newer, harder agentic tests such as Terminal-Bench 4.0, where Anthropic reports 66.4%, and Recursive has not published Flint numbers on those yet.
Flint makes local coding agents a credible option for developers with a 48 GB Mac. For everyone else, it is a strong sign of where laptop models will be in a year.
If you are patching servers this week instead of trying new models, the PHP2Shell vulnerability guide covers the other big story from the same day.
