Flint 40B: Recursive’s Coding Model Was Built Mostly by AI

Recursive Superintelligence shipped Flint last week — a 40B mixture-of-experts coding model that runs at 125 tokens per second on a MacBook Pro. The benchmarks are competitive. But the story isn’t the benchmarks. The story is how it was built: Recursive’s automated research system, the Eureka Machine, designed most of it. Architecture, training recipes, custom GPU kernels — the humans supervised; the AI decided. Flint is the first public proof that AI-directed research can produce a shipping, competitive model.

What the Eureka Machine Actually Did

The Eureka Machine is not a code assistant that helped engineers write boilerplate. It’s a closed-loop automated research system: propose an idea, implement it, build an evaluator, run experiments, keep whatever works, repeat across multiple parallel paths. Richard Socher described it handling “the data, the training recipes, the infrastructure and the code that runs the model.” That includes the custom GPU kernels Flint uses for inference.

One challenge Recursive had to solve: preventing the system from gaming its own evaluations. A judge that can be exploited is useless. They built evaluators that stronger search couldn’t fool — and the system still found improvements. The result was a frontier-class coding model produced by a small team in under four months from a cold start.

For context on the company: Recursive Superintelligence raised $650M at a $4.65B valuation, led by Alphabet’s GV and NVIDIA. Socher, formerly Salesforce’s Chief Scientist, founded it with Peter Norvig and Tim Shi. Flint is their first public product.

The Hardware Reality

“Runs on a laptop” needs a caveat. Flint requires 48 GB of unified memory — an M4 Pro MacBook Pro, M5 Pro, or M5 Max. A standard 16 GB M3 MacBook Pro doesn’t qualify. On the GPU side, you need 48 GB of VRAM: an NVIDIA RTX Spark or a workstation card. The 4-bit quantized build is about 23 GB on disk.

Within those constraints, the speed is real: 125+ tokens per second on M4 Pro for short contexts, 150+ on a 64 GB RTX Spark. Recursive claims Flint is 2x faster than comparable sparse MoE models and 5x faster than dense models with similar coding benchmark scores. For agentic loops that burn through thousands of tokens on repeated tool calls, that 5x figure matters far more than any single benchmark number.

Benchmarks (and the Fine Print)

Flint’s reported numbers are strong within its defined class — sparse MoE models under 50B total parameters:

• SWE-bench Pro v2: 89.7%
• SWE-bench Verified: 74.2%
• Terminal-Bench 2.1: 54.9% (vs. Qwen 3.6’s 44.9%)
• LiveCodeBench v6: 80.3%
• IFEval: 95.1%

Read that class definition carefully. Dense models like Qwen 3.8 (27B active) still score higher on some of the same tests. Flint wins on efficiency — 2.5B active parameters versus Qwen 3.8’s full 27B — and it wins on speed. The benchmarks are also vendor-reported; independent reproduction wasn’t available at launch.

Running Flint Now

Three paths, depending on your hardware:

Ollama is the easiest entry point. macOS support landed in v0.40.8; Linux and Windows followed in v0.40.9. Flint is in the Ollama library.

ollama run flint:40b-a2b-qat-int4

Rec is Recursive’s own inference engine, claiming 1.4–2.6x the throughput of llama.cpp on M4 Pro hardware. If you’re on Apple Silicon and want maximum speed, it’s worth testing. Requires macOS with at least 48 GB unified memory and 30 GB free disk.

OpenRouter lists Flint as recursive/flint-v1.0:free for developers who don’t have the local hardware. No setup required. llama.cpp users need a build from October 2026 or later — older versions error out with an “unknown architecture” message.

What This Signals

One framing: Flint is a competitive local coding model worth testing if you have the hardware. Another framing: a well-funded lab demonstrated that an automated research loop can produce a frontier-class model in four months without humans making the key architectural decisions. Both are true, and the second one is more significant.

Local agentic coding is maturing fast. The hardware floor is dropping. And if the Eureka Machine keeps running, Recursive won’t need another four months for the next version.