Flint on Ollama: Recursive's 40B coding-agent MoE, and what it needs to run

Recursive's Flint landed in the Ollama library today: a 39.8-billion-parameter mixture-of-experts model built specifically for local coding agents. Here's a practical first look at what it is, what hardware it wants, and how to run it.

Listen to this post · 11 min

Accessibility: the whole post is read aloud — Space plays or pauses, ← → skip 10 seconds, and you can change the speed. It keeps playing with your screen locked.

Share this post

In short

  • Flint is Recursive's 39.8B MoE coding-agent model, on Ollama from 22 October 2026 under Apache 2.0.
  • One size: a 23GB download with a 256K context; budget ~23GB plus context headroom, so realistically a 32GB Mac or a 24GB+ GPU.
  • Run it with ollama run flint; it supports tools and thinking, so it drops into agent harnesses.
  • Publisher-reported benchmarks are strong (74.2% SWE-bench Verified, 54.9% Terminal-Bench 2.1) but independent results don't exist yet.
  • It's specialised: repository-scale agentic coding, not general chat — smaller models remain the right pick for 12–16GB machines.

What flint is

Flint is a 39.8-billion-parameter mixture-of-experts model from Recursive, released under Apache 2.0 and added to the Ollama library today (22 October 2026).

The pitch is narrow and clear: it's a model for local coding agents. Give it a repository task — investigating a bug, implementing a feature, writing tests — and it reasons through the work and uses tools across multiple turns. Recursive describes it as built for development workflows that move from understanding code to making changes.

The MoE design is the interesting bit for local runners. Of the 39.8 billion total parameters, only about 2.5 billion are active per token. That means generation speed is closer to what you'd expect from a small model than a dense 40B — the trade-off being that you still need memory for all 39.8 billion weights.

Ollama lists its capabilities as tools and thinking, with a 262K-token context window — room for a substantial chunk of code plus the accumulated history of an agent session. Inputs are text-only; there's no vision, so no screenshots or diagrams.

Sizes, memory and the hardware you'll need

There's one size on Ollama: flint:latest (the same as flint:40b), a 23GB download with a 256K context window.

For memory, we use the same rule of thumb as always on this blog: budget roughly the download size in RAM or VRAM, plus headroom for context. A long coding-agent session with a big repository loaded will use more memory than the weights alone — agent sessions tend to actually fill the window they're given, so don't plan to run this on a machine that only just fits 23GB.

Realistically, you want 32GB of memory to be comfortable:

  • A 32GB Mac (Apple Silicon, where the unified memory and the MoE sparsity work in your favour)
  • A 24–32GB gaming GPU — RTX 3090/4090 class or better
  • A homelab box with enough system RAM to run it on CPU — possible, but slow, and a poor fit for an interactive agent

Recursive also ships quantised versions: an int4 build for Apple Silicon and an NVFP4 GGUF for other GPUs. The Ollama download is the easy path. The Hugging Face files are there if you want to pick your own quant — but as of today we haven't verified them working in llama.cpp, LM Studio or anything else, so treat that as untested rather than impossible.

If you're on a 16GB laptop, this one isn't for you — see the comparison table further down for what is.

How to run it

One command:

ollama run flint

or ollama run flint:40b — they're the same model.

Because Ollama lists flint with tools and thinking, it drops straight into agent setups that talk to Ollama's OpenAI-compatible API: coding-agent harnesses, Open WebUI with tools enabled, or your own scripts. That's the whole point of the model — it's not meant to be chatted at, it's meant to be wired into something that gives it a repo and a task and lets it work.

A caveat on other engines: as of today, the Ollama library page is the only run instruction we've seen from Recursive. The NVFP4 GGUF on Hugging Face implies llama.cpp-family engines should be able to load it, but we haven't verified a working LM Studio or vLLM setup — treat that as untested rather than impossible. We made the same note for Clef Flash on its release day; day-one Ollama-only releases are a normal pattern.

If you're weighing engines generally, our LM Studio vs Ollama and vLLM vs Ollama posts cover the trade-offs. For a single-user coding agent, Ollama is the path of least resistance here; vLLM becomes interesting if you're serving flint to several agent sessions from one homelab box.

What it's good at — and what the benchmarks do and don't say

In Recursive's release evaluations, flint scored:

  • 54.9% on Terminal-Bench 2.1
  • 89.7% on SWE-bench Pro v2
  • 74.2% on SWE-bench Verified

Source: Recursive's evaluation, via the Ollama readme.

Two caveats, stated plainly. First, these are publisher-reported — the readme itself notes that evaluation setups and runtimes can affect scores. No independent benchmarks exist yet, which is the same position we took with Bonsai 2 on its release day. Second, we haven't run these benchmarks ourselves, so treat the numbers as a claim to check, not a settled fact.

For context on what they mean: SWE-bench Verified is the widely used benchmark of real GitHub issues, so a publisher-reported 74.2% puts flint in serious company for agentic coding. Terminal-Bench measures multi-step terminal work, which matches the tool-using, multi-turn design — it's the benchmark closest to what flint is actually for.

Recursive also published a BF16 vs NVFP4 comparison on the model page. We haven't examined the numbers in detail, but it's worth checking before assuming you need full-precision weights — for local runs, you usually don't.

How it fits among local coding models

If you're choosing what to download tonight, here's how flint sits against familiar options. Download sizes and hardware floors for the comparison models are our estimates from the usual Q4-class quant sizes, not vendor figures:

ModelArchitectureDownload (est.)ContextBest atHardware floor (our estimate)
flint:40b40B MoE (~2.5B active)23GB256KRepository-scale agentic coding32GB Mac / 24GB+ GPU
qwen2.5-coder:14bDense 14B~9GBup to 128KGeneral coding12GB GPU
gpt-oss:20bMoE~13GBup to 128KGeneral reasoning16GB-class hardware
bonsai-2:27b27B8.3GB262KVision + tools12GB GPU

The pitch is specialisation. Flint trades general-purpose chat for repository-scale agentic work: multi-turn tool use over a long context. That's a genuinely different job from "write me a function", and it's the job most local models are worst at.

Practical reading of the table:

  • If your GPU is 12–16GB, flint isn't the model for you — it won't load. qwen2.5-coder:14b or a smaller MoE will, and will do honest work.
  • If you have a 24GB+ GPU or a 32GB+ Mac and want a local agent that can hold a repository plus task history, flint is the interesting new option this week.

If you'd rather not commit 23GB of disk before knowing whether an agentic coding workflow suits you, qwen2.5-coder:7b is callable through the Inpherio API from £0.063 per 1M output tokens — a cheap way to test the pattern first.

Limits and things to watch

  • Text-only. No screenshots or diagrams in, so visual debugging workflows are out. If you want a local model that can see, bonsai-2:27b does vision, tools and thinking in 8.3GB.
  • 23GB is a big commitment. The MoE sparsity helps speed, not footprint — you still need memory for all the weights. This is the trade-off of MoE on consumer hardware.
  • All quality claims are Recursive's own as of release day. Wait for independent evals before treating the SWE-bench numbers as settled.
  • One quant on Ollama so far. If you want other sizes, the Hugging Face GGUFs are the route — with the usual caveat that we haven't tested them.

What we'd pick

If you have the hardware — a 32GB Mac or a 24GB+ GPU — and you're running local coding agents, flint is worth a first look today: ollama run flint, wire it into your harness, and see how it behaves on your own repository. That's a better test than any publisher-reported benchmark.

If you don't have the memory, don't stretch: qwen2.5-coder:14b on a 12GB GPU will finish your task while flint is still failing to load. And if a card of that class sits idle in your machine between sessions, it can also earn serving open models — worth a thought before it spends all day unoccupied.

We'll update this post as independent benchmarks and other-engine support appear.

Questions people ask

How much RAM do I need to run flint locally?

The download is 23GB, so budget roughly that in RAM or VRAM plus headroom for context. Realistically you want 32GB of memory to be comfortable — a 32GB Mac, a 24GB+ gaming GPU, or a homelab box with plenty of system RAM.

Is flint better than qwen2.5-coder for coding?

They're aimed at different jobs. Flint is built for multi-turn, tool-using repository work with a 256K context; qwen2.5-coder is a dense general coding model that runs on far smaller GPUs. No independent comparison exists yet.

Can I run flint on a 16GB GPU or laptop?

No. The single Ollama tag is a 23GB download, so 16GB-class hardware can't hold it. Look at qwen2.5-coder or gpt-oss:20b instead.

Does flint work with coding agents like Cline or Open WebUI?

Ollama lists flint with tools and thinking capabilities, so anything that talks to Ollama's OpenAI-compatible API — coding-agent harnesses, Open WebUI with tools enabled, your own scripts — should work.

Is flint free and open source?

Yes. It's released under Apache 2.0, so you can download, run and build on it without restriction.

Models in this post — live on Inpherio

Have a GPU, a Mac or a spare PC?

Let it earn while you sleep.

Run open models for people who need them. You set the price and keep everything but the 15% fee.

Become a host

Building with AI?

Every open model, one API.

OpenAI-compatible. Priced by the people who run the hardware.

Start free See the marketplace

Read “Flint on Ollama: Recursive's 40B coding-agent MoE, and what it needs to run” at https://inpherio.co.uk/blog/flint-on-ollama-recursive-s-40b-coding-agent-moe-and-what-it-needs-to