# Recursive Flint: 40B Coding Model for Your Laptop

> Source: <https://byteiota.com/recursive-flint-40b-coding-model/>
> Published: 2026-11-15 00:07:19+00:00

Recursive just dropped Flint, a 40-billion parameter coding model that runs entirely on a MacBook Pro, generates 131 tokens per second, and doesn’t send your code anywhere. It’s Apache 2.0. And it was largely designed by Recursive’s own AI research system. That last detail is worth unpacking.

## MoE Is What Makes This Possible

Flint uses a [Mixture-of-Experts (MoE) architecture](https://huggingface.co/blog/moe): 39.8 billion total parameters, but only about 2.5 billion are active for each token. The model routes each token to 6 of its 256 experts — plus one always-on shared expert — rather than running everything through the full network. You get the knowledge of a 40B model at the compute cost of a much smaller one.

That’s why the speed numbers are real. On an M4 Pro with 48GB of unified memory, Flint writes 131 tokens per second through MLX. Dense local models at comparable quality typically run at 15–25 tok/s. This is a 5–10x difference, and it’s the gap that makes local deployment practical for agentic workflows rather than just demo toys.

## The AI That Designed Itself

Recursive’s Eureka Machine is an automated research system that runs the full ML loop autonomously: propose, implement, test, iterate — across many parallel threads. For Flint, the Eureka Machine chose the architecture. It started from a 35B/3B baseline, explored expert counts and widths, and converged on 40B total / 2.5B active as the optimal tradeoff for coding speed and accuracy. It also wrote the Apple Silicon and RTX Spark inference kernels.

Flint was built in four months. A comparable model development cycle at a traditional lab takes 12–18 months. That delta is the Eureka Machine’s contribution, and it makes Flint as much a proof of AI-driven model development as it is a coding tool in its own right.

## The Numbers — With an Honest Caveat

Recursive reports these benchmark scores:

| Benchmark | Flint Score | 
|---|---|
| SWE-bench Pro v2 | 89.7% | 
| SWE-bench Verified | 74.2% | 
| Terminal-Bench 2.1 | 54.9% | 
| LiveCodeBench v6 | 80.3% | 
| IFEval (BF16) | 95.1% | 

The caveat: these are self-reported. No independent evaluation had been published as of late October 2026. The 89.7% [SWE-bench Pro v2](https://www.swebench.com) figure is a strong claim from a lab still building its track record. For comparison, Qwen 3.8 — a dense 27B model — scores 94.9% on that same benchmark and beats Flint on four of six coding evals. Flint’s main advantage over Qwen 3.8 isn’t accuracy; it’s speed and offline operation.

## The 48GB Wall

Recursive’s rec launcher — the official way to run Flint — only supports the M4 Pro, M5 Pro, or M5 Max with 48GB or more of unified memory. Most M4 Pro MacBook Pros ship in 24GB and 36GB configurations. The 48GB config is the top-of-line option.

If you don’t have 48GB, there are workarounds:

- The mlx-community 3-bit build runs in about 17.8GB — usable on a 24GB machine, with some accuracy loss
- Unsloth’s UD-Q4_K_XL GGUF is 25.1GB, workable on a 24GB GPU with VRAM and RAM offloading
- On Windows or Linux with an RTX 3090 (24GB), 3-bit quants run at around 46 tok/s via llama.cpp

## How to Run It

Three paths, in order of ease:

**Mac with 48GB — rec engine:**

```
curl -fsSL https://raw.githubusercontent.com/recursive-oss/rec/main/install.sh | bash
rec launch pi
```

**Any OS — Ollama:**

```
ollama run flint:40b
```

**llama.cpp or LM Studio:** Download GGUF weights from [Hugging Face](https://huggingface.co/recursive-ai/flint), load in [llama.cpp build b11803](https://github.com/ggml-org/llama.cpp/releases/tag/b11803) or later. Flint support merged October 21 (PR #30928).

For agentic workflows, Flint drops into OpenHands, Cline, and Aider via their local model backends — point them at your Ollama or llama.cpp server and you have a fully offline coding agent.

## Who Should Care

Flint is for three groups specifically. First: developers on 48GB M4/M5 Pro MacBooks who want to stop paying per-token for routine coding work. At 131 tok/s, it keeps up with a fast typist. Second: teams with real privacy requirements — financial, legal, healthcare codebases where sending source to a cloud API is a non-starter. Third: anyone running agentic workflows who needs high throughput at zero marginal cost.

If you’re on a standard 16GB or 36GB MacBook, or need vision capabilities, Flint isn’t there yet. And if you need independently verified benchmarks before committing, that’s a reasonable position to hold.

## Bottom Line

Flint isn’t the best coding model available — Qwen 3.8 beats it on accuracy with a smaller footprint. But it is likely the fastest capable coding model you can run locally today, and it’s free, private, and Apache 2.0. For anyone who clears the 48GB bar, this is worth running now.

The Eureka Machine story adds something most model releases don’t: Flint is a data point that AI-driven model development works at this scale. That story is going to get more interesting with each iteration — Recursive has already said the next version starts from Flint as its baseline.
