Recursive just shipped Flint, a 40-billion-parameter open-weight coding model that runs locally at 125+ tokens per second. No API key. No per-token bill. No cloud dependency. The kicker: Flint was largely designed, trained, and optimized by Recursive’s own AI system — the Eureka Machine. It’s Apache 2.0, available on Ollama and Hugging Face right now, and it’s the first open coding model that meaningfully competes with API-only incumbents on agentic coding benchmarks.
What Makes Flint Fast
Flint uses a Mixture of Experts architecture with 39.8 billion total parameters but only about 2.5 billion active per token. That gap is the whole trick. At inference time, the router selects 6 of 256 available expert layers for each token, plus one always-on shared expert. The result is dense-model-quality output at a fraction of the compute cost — which is why you get 125 tok/s on a MacBook Pro M4, not the 12 tok/s you might expect from a model this large.
The context window is 262,144 tokens. That’s real-codebase scale — enough to load a medium-sized project and ask it to find the bug without chunking.
Getting Started
The fastest path is Ollama. One command pulls the official 4-bit quantized build (~23 GB):
ollama run flint:40b-a2b-qat-int4If you prefer llama.cpp or want finer control over quantization, the weights are on Hugging Face at RecursiveSI/flint under Apache 2.0 — no revenue gate, no OEM clause, no service-operator trigger. Check canitrun.dev to verify your hardware before pulling.
Now for the hardware reality check. Recursive calls this a “laptop model,” and that marketing is… generous.
| Hardware | Memory | Speed | Verdict |
|---|---|---|---|
| MacBook Pro M4 Pro (48GB) | 48GB unified | ~125 tok/s | Recommended |
| MacBook Pro M5 Ultra | 192GB unified | ~200 tok/s | Excellent |
| NVIDIA RTX Spark (64GB) | 64GB VRAM | ~150 tok/s | Sweet spot |
| RTX 4090 (24GB) | 24GB VRAM | Requires Q3 (21.8GB) | Tight |
If you are on a 24GB GPU or a 16GB Mac, skip this release. The Q4_K_M GGUF comes in at 24.2 GB, which leaves almost no headroom on a 24GB card. You can run Q3_K_M at 21.8 GB, but the quality degradation is noticeable on complex reasoning tasks. Wait for a distilled or smaller variant.
Benchmark Scores
Recursive reports 89.7% on SWE-bench Pro v2 — best in class for MoE models under 50 billion parameters. SWE-bench Verified comes in at 74.2%, and Terminal-Bench 2.1 at 54.9%.
One caveat worth flagging: Qwen scores 73.0 on Terminal-Bench 2.1 against Flint’s 54.9, so Flint is not universally dominant. Different labs also report on different benchmark versions, making direct comparisons tricky. What the numbers do confirm is that Flint is competitive with closed API models on the agentic coding tasks that matter most — investigating a codebase, fixing bugs, writing tests, implementing features.
The Eureka Machine Angle
The more interesting story here is not the model; it is how it was built. Recursive’s Eureka Machine — an automated AI research system — handled nearly every phase of Flint’s development: data curation, training recipes, infrastructure, inference optimization, model shape search, and output layer compression to 4 bits. A small team built the whole thing in under four months.
This is recursive self-improvement in practice, not a lab demo. The stated roadmap is for each Flint iteration to train the next version faster, with humans overseeing the process. Whether that scales to frontier models is an open question, but Flint is proof that the loop is already running. TechCrunch covered the AI-built angle in depth if you want the full backstory.
When to Use Flint vs. API Models
Flint is not a replacement for Claude or Codex across all tasks. It is a specialist tool, and it is excellent when used as one.
Use Flint when: your codebase is sensitive or proprietary, your agentic workflows are burning through API costs (100K+ tokens per session adds up), you need offline or air-gapped operation, or you want sub-100ms response latency without a network hop.
Stick with API models when: you need general-purpose reasoning, multi-modal capabilities, the latest context window, or you simply don’t have the hardware. Flint is explicitly a coding specialist — reviewers noted noticeably weaker performance on creative writing and translation tasks.
The Verdict
If you have the hardware — a 48GB Mac or a 32GB+ GPU workstation — Flint belongs in your local agent stack. The combination of Apache 2.0 licensing, 125+ tok/s inference, 262K context, and genuine agentic coding performance puts it in a class of one for open-weight local models right now. Read Recursive’s official announcement for the full technical spec.
The fact that an AI system largely built it is either the most exciting or most unsettling detail, depending on your priors — but either way, Flint ships.
If you do not have the hardware yet, bookmark this. The trend toward fast, capable, local-first coding models is not slowing down, and Flint is the clearest signal yet that the gap between local and cloud has closed faster than most expected.
