Recursive Flint Review: A Free Laptop Coding Model and the Claims Still to Check
Flint activates just 2.5 billion of its 40 billion parameters and ships under Apache 2.0. The speed and benchmark numbers are all self-reported, so here is what holds up.
Jump to 10 sections
Recursive's Flint is a free, open-weight coding model released October 21, 2026 under Apache 2.0. It has about 40 billion total parameters but activates only about 2.5 billion per token, and Recursive says it runs at around 131 tokens per second on an M4 Pro MacBook. Every benchmark and speed number so far comes from Recursive itself.
A coding model that runs on a laptop with no per-token fees would change the cost math for many developers. That is why the launch drew attention, and why the numbers deserve a careful read before anyone swaps it into a workflow. Model Drop reviews launches against what the evidence supports, and this review is for developers deciding whether Flint is worth a download.
What Is Recursive Flint?
Flint is an open coding model built by Recursive, a startup led by Richard Socher, formerly chief scientist at Salesforce. According to the AI Weekly alert, it uses a mixture-of-experts design with about 39.8 billion total parameters, 2.5 billion active per token, 256 routed experts with 6 selected per token and a 262K-token context window.
Quantized versions go down to 11.4 GB, small enough for a laptop with enough memory. The weights are available under the Apache 2.0 license, which allows commercial use.
The company emerged from stealth in May with $650 million raised at a $4.65 billion valuation, with backers including GV, Nvidia and AMD Ventures, according to coverage of the launch. Flint is its first public model.
How Does a 40B Model Run on a Laptop?
It runs on a laptop because a mixture-of-experts model only uses a slice of its parameters for each token. Flint holds 40 billion parameters in memory but computes with about 2.5 billion at a time. Memory has to fit the whole model, but the speed depends on the active part.
That is the trade-off behind the headline speed. Our explainer on mixture-of-experts versus dense models covers it in detail: you need enough memory for all experts, but each token costs far less compute than in a dense model of the same size.
The 11.4 GB quantized file shows the other piece. Recursive says its low-bit training cut model size by 71% with almost no quality loss. If that holds up, the model fits on hardware many developers already own.
How Fast Is Flint Really?
Recursive's numbers are impressive and unverified. A repost of TechCrunch's coverage says the company measured about 131 tokens per second on a MacBook Pro with an M4 Pro chip, versus 58 to 69 for comparable models such as Gemma 4 and Nemotron 3.5 Lightning. It reports more than 150 tokens per second on Nvidia's RTX Spark.
That would make Flint roughly twice as fast as similar models on the same machine. Other reports give a slightly lower figure of about 125 tokens per second, which suggests the number depends on settings.
Several caveats apply. Speed measured on one machine, in short contexts, with a specific quantization, does not carry over to your setup. Throughput also falls as the context grows. For coding work with large repositories, the long-context speed is the number that matters, and no one has published it yet.
What Do the Benchmarks Say?
All benchmarks are company-reported. Recursive says Flint scores 74.2% on SWE-bench Verified, a real-world bug-fixing test, which it says leads mixture-of-experts models under 50 billion parameters. It lists 54.9% on Terminal-Bench 2.1. In its six-test average, only Alibaba's Qwen3.8 27B ranks above Flint.
The AI Weekly alert also lists 89.7% on SWE-bench Pro v2. Other coverage does not cite that figure, so treat it as a number to confirm against the model card.
The table below summarizes what is claimed and where each claim stands.
| Claim | Source | Status |
|---|---|---|
| 74.2% on SWE-bench Verified | Recursive | Not independently reproduced |
| 54.9% on Terminal-Bench 2.1 | Recursive | Not independently reproduced |
| 89.7% on SWE-bench Pro v2 | One report | Needs confirmation |
| About 131 tokens per second on M4 Pro | Recursive | Single configuration |
| Completed Wired's test requests | Wired, via a secondary report | Small, informal test |
Vendor benchmarks are a starting point, not a verdict. Our guide to which AI model benchmarks still mean anything explains why prompt sets, scaffolds and contamination can move scores a lot.
What Did the First Independent Testing Find?
The first outside impressions are positive but small in scope. A ToolNavs summary reports that Wired tested Flint on a Mac with 48 GB of RAM and that it built a to-do app, a research tool and a small website, handling each request on the first try.
That is a useful sign, but it is not a benchmark. Three small projects say little about large codebases, unusual frameworks or long debugging sessions. Wired's reviewer also noted, per the TechCrunch repost, that smaller models generally made more errors or ran slower than Claude or Codex.
Recursive itself acknowledges the gap. It says Flint needs more guidance than major paid assistants and recommends splitting large tasks into smaller steps.
Why Is the Eureka Machine Part of the Story?
Recursive says it used an automated research system, called the Eureka Machine, in nearly every stage of building Flint. The company says the system generates ideas, runs experiments and picks next steps, and that it contributed to the architecture, the low-bit training and custom kernels for Apple Silicon and RTX Spark.
A small team built the model in under four months, per Recursive. The company did not say how much researcher time the system saved, so the efficiency claim is hard to size.
The framing matters for the industry. Recursive presents Flint as an early test of AI helping to build better AI. It says the current setup is supervised by humans and that humans could halt the process if problems arose. Those are promises about process, and the model itself still needs to be judged on output.
Who Should Try Flint, and Who Should Wait?
Flint is worth a download for developers who value privacy, offline use or zero per-token cost. Running locally means code never leaves your machine, and there are no usage fees. That matters for proprietary code and for teams with data-handling rules.
It is less ready for anyone who needs the strongest possible results on large, tangled problems. Hosted frontier models still have the edge there, and our roundup of AI coding agents compared shows how the tool layer changes results.
The steps below give a sensible way to evaluate it for your own work.
- Download a quantized build that fits your memory with room to spare.
- Run it on five real tasks from your own repository, not demo prompts.
- Record time to a working result, number of corrections and tokens per second at your normal context size.
- Compare against your current assistant on the same five tasks.
- Check the license terms and any data requirements before adopting it in a team setting.
If you plan to run it regularly, pick a local server that fits your workflow. Our comparison of local AI inference servers covers the main options, and our look at small models that run on one GPU gives a sense of the costs and trade-offs.
How Does Flint Fit the Open-Weight Landscape?
Flint joins a crowded field of open models, and it competes on efficiency more than on raw capability. Its pitch is that a sparse model can deliver strong coding results on consumer hardware. Our explainer on open-weight versus closed models shows why that appeals to teams that want control over their stack.
The open question is durability. A launch-week speed record is easy to claim, and the real test is how the model holds up across months of use, new frameworks and updates. Open weights let outsiders test it, which is a point in its favor.
What Should Recursive Publish Next?
Three pieces of evidence would turn claims into facts. First, the full prompt sets and scaffolds behind each benchmark, so others can rerun them. Second, speed at realistic context lengths, such as 32K and 128K tokens, not only short prompts. Third, results across more than one machine, including mid-range laptops with less memory.
Independent leaderboards will also help. A model that holds its ranking when someone else runs the tests earns more trust than one that wins on its own chart. Because the weights are open, nothing stops outside groups from doing exactly that work this month.
Until then, the sensible stance is interest without commitment. Try it, measure it on your tasks and keep your current assistant as a fallback.
The Verdict on Flint, So Far
Flint is a promising launch with strong claims and thin independent evidence. The design is sound, the license is permissive and early hands-on impressions are good. The speed and benchmark numbers should be treated as the company's own until others reproduce them.
At Model Drop, our editors will update this review when independent benchmarks and long-context speed data arrive. Your next step is to download a quantized build and run it against five tasks from your own code before you decide.
