Recursive Flint: The Free Local Coding Model, Explained

A five-person-scale team at a one-year-old startup just shipped a coding model that beats every other sub-50-billion-parameter model on SWE-bench Verified, and the company says its own AI research system did most of the work. Flint is free, Apache 2.0, and runs offline on a MacBook Pro.

Here is the one thing to take from this piece: if you have Apple Silicon or an Nvidia RTX Spark box and want a private, no-subscription coding model, download Flint today. If you need benchmark numbers that someone other than the vendor has checked, give it a few weeks.

What Flint is, and who it's for

Flint comes from Recursive (formerly Recursive Superintelligence), the startup led by Richard Socher, Salesforce's former chief scientist. Recursive emerged from stealth in May 2026 with $650 million in funding at a $4.65 billion valuation, backed by GV, Nvidia, and AMD Ventures (per TechCrunch). The company's stated mission is recursive self-improvement: AI that helps build better AI. Flint, released October 21, 2026, is the first public product of that bet.

The model is a mixture-of-experts (MoE) transformer with 39.8 billion total parameters, of which roughly 2.5 billion activate per token (Recursive rounds this to "40B-A2.5B") (per the RecursiveSI/flint model card). Because so few parameters fire on any given token, Flint is light enough to run on consumer hardware instead of a data-center GPU. It handles text and code, supports multi-turn tool use and reasoning, and is built specifically for agentic coding work: investigating a codebase, fixing bugs, writing tests, implementing features.

Source: huggingface.co, captured October 22, 2026.

The part getting attention is how fast Recursive built it. The company's automated research system, the Eureka Machine, "helped develop nearly every part of Flint's model-building stack, from data and training recipes to infrastructure and inference optimization," and a small team shipped the model from scratch in under four months (per Recursive). Recursive says Eureka contributed a sparser architecture search, a quantization recipe that shrank the model by 71% with little quality loss, and custom Metal kernels for Apple Silicon. None of that is independently auditable yet; it's Recursive's account of its own process.

Flint is for a specific reader: a developer who wants a coding assistant that runs entirely on their own machine, keeps code off a vendor's servers, and does not meter usage by the token. It is not, on Recursive's own account, a drop-in replacement for Claude or GPT-class cloud coding agents on anything beyond moderately scoped tasks.

What it costs

Nothing, as long as you have the hardware. Flint's weights ship under the Apache 2.0 license on Hugging Face, which permits free commercial use and modification (per the model card). There's no subscription, no per-token API fee, and no seat license. TechCrunch frames this as the explicit pitch: running locally lets developers "avoid the usage fees that AI cloud services charge based on how much text the model processes" (per TechCrunch).

Your actual cost is the machine. The full BF16 checkpoint is about 80 GB to download (per the model card), and quantized builds trade download size and memory for some precision. Hugging Face's own hosted inference is separate from the weight license; Recursive notes that "hosted API terms and data practices are separate from the weight license" if you ever run Flint through a managed endpoint instead of your own box.

How to get it running

There are two real paths, depending on your hardware.

Workstation or cloud GPU (BF16, full precision). Recursive's own getting-started flow targets a single B300 or H200 GPU, serving the full checkpoint through its SGLang kit inside a Docker container with the GPU, shared memory, and the model directory mounted in. That path needs a data-center-class card, not a laptop; the exact commands and flags are documented step by step at docs.recursive.com/getting-started.

Laptop (quantized). This is the path the brief is actually about. Recursive says Flint "works with tools and frameworks including llama.cpp, Ollama, Unsloth, LM Studio, vLLM, and SGLang," and quantized GGUF and MLX builds landed on Hugging Face within hours of launch, including unsloth/flint-GGUF and lmstudio-community/flint-GGUF (checked on Hugging Face's quantizations listing, October 22, 2026). The practical route for most readers:

pip install -U huggingface_hub
hf download unsloth/flint-GGUF

Then point llama.cpp, Ollama, or LM Studio at the downloaded file, picking a quant level (Q4_K_M is the common starting point) that fits your available memory.

Recursive also ships its own lightweight engine, rec, tuned specifically for Flint on M4 Pro and M5 Pro/Max chips, as a faster alternative to general-purpose runtimes.

On hardware: Recursive says Flint generates "more than 125 tokens per second on an M4 Pro MacBook Pro" (per Recursive), while TechCrunch's reporting puts it at roughly 131 tokens per second on the same chip, about double the 58 to 69 tokens per second that Google's Gemma 4 and Nvidia's Nemotron 3.5 Lightning manage on identical hardware (per TechCrunch). On an RTX Spark, both sources put throughput above 150 tokens per second. Wired's Will Knight ran Flint on a Mac with 48 GB of memory to build a to-do app and a research-crawling tool, and reported it "nailed his coding requests every time" where smaller models usually stumbled (per TechCrunch's account of the Wired review). Treat 48 GB as a reasonable floor if you want headroom for a long context window; the documented context configuration is 262,144 tokens, and Recursive recommends staying within 256k for coding work even though the architecture supports up to 512k.

How it compares on SWE-bench Verified

The benchmark numbers come from Flint's own model card, which is a primary source but still Recursive's self-reported evaluation:

Model	Params (active)	SWE-bench Verified	Terminal-Bench 2.1	Tok/s, M4 Pro MacBook Pro
Flint	40B (2.5B)	74.2%	54.9%	~131
Gemma 4	sub-50B class	not disclosed by Recursive	not disclosed by Recursive	~69
Nemotron 3.5 Lightning	sub-50B class	not disclosed by Recursive	not disclosed by Recursive	~58
Qwen3.8 27B	27B	higher than Flint on Recursive's 6-test average	-	not reported

Sources: SWE-bench Verified and Terminal-Bench 2.1 scores per the RecursiveSI/flint model card (evaluated with mini-swe-agent and Terminus 2, pass@1 averaged over at least five attempts). Speed and the Gemma 4 / Nemotron 3.5 Lightning / Qwen3.8 27B comparisons per TechCrunch, reporting Recursive's released figures.

Two things stand out. First, Flint wins its weight class on SWE-bench Verified: TechCrunch reports it "outperformed other models under 50 billion parameters." Second, it does not win everywhere. On Recursive's own six-benchmark average, only Alibaba's Qwen3.8 27B scores higher, meaning a smaller, non-MoE model still beats Flint on overall capability, even as Flint wins on local inference speed. For scale, Meta's Muse Spark Open, a much larger open-weight model released the week before, uses 816 billion parameters and needs a terabyte-plus of memory; it's a different category of hardware, not a real alternative for a laptop (per TechCrunch).

Where it actually falls short

Three limits matter more than the benchmark table.

The benchmark numbers are Recursive's own, run on Recursive's own evaluation harness, and no outside lab has reproduced them yet. That doesn't make them false, but it does mean you're trusting the vendor's math until someone else checks it, which is normal for a model released this week and worth revisiting in a month.

Recursive opened the weights, not the research system. The Eureka Machine, the thing doing the headline-grabbing "AI built this" work, stays closed. You can verify what Flint does; you can't verify how Eureka decided to build it that way.

And Flint's own model card is blunt about day-to-day friction: it "can still produce incorrect or harmful content, faulty code, or inappropriate tool calls," structured tool-call grammar "does not prevent the model from choosing an unsafe or incorrect action," and long reasoning chains can burn through the output budget before finishing. TechCrunch adds that Recursive itself "acknowledged that Flint would need more guidance than the big paid coding assistants and suggested breaking large tasks into smaller steps." That's the opposite of a model you point at a vague ticket and walk away from.

The verdict: install now, or wait

Install Flint today if you're a solo developer or hobbyist on Apple Silicon at the memory tier covered above or an RTX Spark-class box, you want a private, offline coding assistant with zero per-token cost, and you're comfortable breaking work into smaller, explicit steps rather than firing off an open-ended agent task. Grab a quantized build from unsloth/flint-GGUF or lmstudio-community/flint-GGUF, load it in Ollama or LM Studio, and judge it against your own repo.

Wait if you're deploying this for a team that needs predictable, auditable behavior, or if your workflow depends on the SWE-bench number holding up under scrutiny you haven't done yourself. Give it a month: watch for the first third-party benchmark checks, and watch whether Recursive opens any part of the Eureka Machine pipeline the way it opened Flint's weights. Until one of those things happens, Flint is a genuinely fast free model with a strong story and a single-source benchmark sheet.