Flint Coding Model - Explained Simply

The Flint coding model is Recursive's first open-weights model: a 40B-parameter mixture-of-experts coder that only fires about 2.5B parameters per token, so it's fast enough to run on a laptop, and it was built largely by Recursive's own automated research system, the Eureka Machine.

📺 Watch: NEW Flint : A Fast Local Coding Model!

🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside

That's the short version. Here's who made it, how they made it, what the benchmarks say, and whether it belongs in your stack.

I covered Flint in a video this week because it ticks two boxes I care about: it's built for agents, and you can own it. No API meter running in the background. I run Hermes every day inside my Agent OS with a profile per model, and a fast, free, local coder is exactly the kind of model that earns its own profile.

Who built Flint

Flint comes from Recursive Superintelligence, Inc. Their stated goal is to build recursively self-improving superintelligence to automate knowledge discovery, and they're starting with the thing they know best: building models.

Recursive announced Flint on its blog in a post titled "Introducing Flint", dated 23 October 2026. The weights are on Hugging Face under the RecursiveSI organisation, and the licence is Apache 2.0. That means you can use it commercially, fine-tune it and ship it inside your own products.

The part that grabbed my attention: Recursive says Flint was built by "a small team of people and agents" in under four months.

If you want to learn how to plug models like this into a working agent setup, that's what we do inside the AI Profit Boardroom. You get the Agent OS, a 30-day AI agent roadmap, daily tutorials as new tools drop and 4 coaching calls a week, for $69/mo.

How the Eureka Machine built the Flint coding model

The Eureka Machine is Recursive's system for large-scale automated AI research and development. It runs the research loop on its own: propose an idea, implement it, test it, then use the result to pick the next step. It explores lots of directions in parallel and combines the ones that work.

Here's the old way versus the new way.

The old way: a research team argues about architecture, runs a handful of experiments, waits weeks, and tweaks one thing at a time.

The new way: agents run hundreds of those loops, humans steer, and the model ships in under four months.

According to Recursive, the Eureka Machine touched almost every layer of Flint. Data. Optimisers. Training recipes. Infrastructure. Inference optimisation. The blog calls out a few specific wins:

• Architecture search. It started from a 35B total, 3B active baseline and searched across expert configurations and widths to land on the final shape.
• Quantisation. It quantised the output layer to 4 bits, which goes against common practice, and added an offline distillation stage with the 16-bit model as the teacher. Recursive says that nearly halved training steps compared with a standard quantisation-aware training baseline, and the final NVFP4 model sits within 0.7 points of the 16-bit model across their benchmarks.
• Kernels. It produced specialised kernels for low-bit projections, MoE routing, attention and prompt processing, plus a Metal megakernel for Apple's M4 and M5 chips.

📺 Watch: Build Anything with GLM-5V-Turbo- Vision Coding Model! 🤯

Flint specs and benchmarks

Here's everything that matters in one place. The architecture numbers come from the Hugging Face model card. The benchmark scores are Recursive's own, measured by Recursive, and the speed figures come from the launch blog.

A few notes on how those scores were run, straight from the model card. Terminal-Bench used the Terminus 2 harness. SWE-bench used mini-swe-agent. Each score is average pass@1 over at least five attempts, with temperature 1.0, top-p 0.95 and top-k 20. And on Terminal-Bench, Recursive counted any solution found through web retrieval as a failure, which is a stricter rule than some developers apply.

Recursive's headline claim is that Flint leads mixture-of-experts models under 50B total parameters on agentic coding, and that it rivals dense 25B to 40B models on coding while running more than 5x faster. The speed numbers are measured at short contexts and averaged over a 128K-token session with prefill excluded.

One small wrinkle: the blog says Flint supports up to 512K tokens but recommends staying within 256K. The model card lists 262,144. Plan around the model card number.

Benchmarks are a starting point. What I care about is how a model does on my real tasks, which is why I keep my own scoreboard at Goldie Bench.

📺 Watch: GLM-5V-Turbo: Vision Coding Model Update is INSANE!

Why the active parameter count matters

This is the bit most people skip.

A dense 40B model uses all 40B parameters for every token. Flint stores 40B worth of knowledge but only wakes up about 2.5B of it per token. Think of a big agency where only the six specialists who know the job get pulled into each meeting.

You still need memory to hold the whole model. But the work per token is tiny. That's how you get triple-digit tokens per second on a MacBook.

The attention design helps too. Most layers only look at a 513-token sliding window, and only 14 layers attend to the full context. The vLLM team worked out that this keeps the KV cache to roughly 28 KiB per token, so long agent sessions don't blow up your memory as fast.

Agentic coding strengths

Flint isn't a chat model that happens to write code. It's tuned for coding agents, the kind that read a repo, run shell commands, edit files and loop until the tests pass.

Here's what makes it agent-friendly, per Recursive's docs and model card:

• Tool calls. Flint supports OpenAI-compatible tool calls, so most agent harnesses can talk to it without custom glue.
• Always-on reasoning. It thinks before it acts. Recursive says to keep the returned reasoning content in your conversation history and give hard problems at least 32,768 output tokens.
• Long sessions. A 262K window plus the compact cache means it can hold a lot of repo and tool history.
• Harness support. Recursive has setup guides for OpenCode, Pi, Cline, OpenHands and an experimental Codex CLI path. OpenCode even lists Flint-40B on its free tier, subject to capacity and rate limits.

Recursive is also upfront about the limits. The model can produce faulty code or inappropriate tool calls, so review what it writes before you apply it, and make your agent app enforce its own permissions. Long reasoning can also add latency and eat your output budget. That's standard advice for any agent model, and it's worth following.

If you want a hand picking where a model like Flint fits in your business, grab a free AI strategy session and we'll map it out.

Who Flint is for

Flint makes the most sense for four kinds of people.

1. Developers who want a private coder. Your code never leaves your machine. No API fees. Recursive pitches it as running offline on your own hardware.
2. Mac users with a recent Pro or Max chip. Recursive's own engine, rec, targets M4 Pro, M5 Pro and M5 Max machines with at least 48 GB of unified memory.
3. Agent builders. If you're running OpenHands, OpenCode, Pi or a stack like my Agent OS, Flint gives you a fast worker model you can hammer all day without a bill.
4. Businesses with sensitive code. Apache 2.0 weights plus local inference is a clean story for clients who don't want their repos going to a third-party API.

Who it's not for: anyone with an 8 GB or 16 GB laptop expecting magic. The quantised file alone is around 23 GB, and you need headroom on top of that.

Want the full download-and-run walkthrough, with file sizes, hardware and commands? I put it in a separate guide: Flint local coding model setup. And if you're comparing local options for Anthropic's tools, see my piece on Claude Code local.

For how all of this plugs into one system, read the Agent OS guide. Or skip the trial and error and book a free AI strategy session with my team.

FAQ

Is the Flint coding model free?

Yes. The weights are on Hugging Face under Apache 2.0, so you can download and run them on your own hardware with no licence fee. OpenCode also offers Flint-40B on a free tier with capacity and rate limits.

What is the Eureka Machine?

It's Recursive's system for large-scale automated AI research. It proposes, implements and tests ideas in parallel, and Recursive says it contributed to Flint's data, training recipes, quantisation, kernels and infrastructure.

How good is Flint at coding?

Recursive reports 89.7% on SWE-bench Pro v2, 74.2% on SWE-bench Verified and 54.9% on Terminal-Bench 2.1, all measured by Recursive. They claim it leads MoE models under 50B parameters on agentic coding.

Can Flint run on a laptop?

On the right laptop, yes. Recursive says it runs at more than 125 tokens per second on an M4 Pro MacBook Pro, and its rec engine needs at least 48 GB of unified memory.

Want to go deeper with local models and agents? Join the AI Profit Boardroom for the Agent OS, the 30-day roadmap and weekly coaching, or get a free AI strategy session and we'll build your plan together.