Local AI Advisor
All posts

Flint: a 40B open coding model that only wakes up 2.5B of itself per answer

Recursive's Flint is a 40-billion-parameter coding model with just 2.5B active per token — fast on a MacBook Pro, free on your own machine, and now in Ollama.

By Ray, Your Local AI Advisor5 min readlocal-llmnew-modelsai-news

Yesterday a new name showed up on the Ollama model list: flint. It is the first model from Recursive Superintelligence, the company led by Richard Socher (Salesforce's former chief scientist), and it is built for one job — coding agents that read unfamiliar code, trace bugs, add features, and write tests. It runs on your own machine, the weights are Apache 2.0, and the hook is the architecture: 40 billion parameters total, but only about 2.5 billion of them are active for each token. That is why a model this large can run fast on a laptop.

Flat illustration of a laptop with glowing code blocks, surrounded by puzzle-piece neural-network shapes and circuit nodes, some highlighted — a visual for a mixture-of-experts coding model

A 40B model that spends 2.5B per answer

Most models use every parameter on every token. Flint does not. It is a mixture-of-experts (MoE) Transformer with 49 layers: 2 dense layers, then 47 MoE layers. Each MoE layer holds 256 "experts" — small specialist networks — and routes each token through only 6 of them, plus one always-on shared expert. The model card states roughly 2.5 billion active parameters per token (including the output head; the active body alone is about 2.2B). The official size designation is "40B-A2.5B".

That sparsity is the whole point. Active parameters set the compute per token, so Flint thinks at the speed of a 2.5B model while storing the knowledge of a 40B one. Recursive reports 125+ tokens per second on an M4 Pro MacBook Pro at short contexts, and 150+ on a 64GB NVIDIA RTX Spark. TechCrunch's testing, reported secondhand, put the MacBook figure at about 131 tokens per second — versus 58 to 69 for comparable models like Google's Gemma 4 and NVIDIA's Nemotron 3.5 Lightning on the same machine.

Minimal diagram: a box labeled CODE PROMPT on the left, an arrow to a grid of hexagons where only three glow teal under the heading FEW EXPERTS ACTIVE, and an arrow to a box labeled ANSWER

The scores — read the footnotes

Recursive's published release evaluations: 95.1% on IFEval, 89.7% on SWE-bench Pro v2, 74.2% on SWE-bench Verified, and 54.9% on Terminal-Bench 2.1.

Bar chart of Flint's four benchmark scores: IFEval 95.1%, SWE-bench Pro v2 89.7%, SWE-bench Verified 74.2%, Terminal-Bench 2.1 54.9% — Recursive's own release evaluations, publisher-reported

Every number there is publisher-reported, and the model card itself flags the important footnotes. Terminal-Bench scores came from Terminus 2, SWE-bench from mini-swe-agent, with agentic scores averaged over at least five attempts. Recursive says Flint's Terminal-Bench score counts solutions obtained through web retrieval as unsuccessful — other vendors' scores may not apply the same adjustment. And on Recursive's own chart, Flint leads other MoE models under 50B parameters but trails the dense Qwen 3.8, which scored 73.0% on Terminal-Bench 2.1 against Flint's 54.9%.

The company itself adds the honest caveat: Flint may need more guidance than larger closed models. In practice, expect to give it clearer instructions and smaller steps.

What it takes to run on your machine

The hardware picture is specific, so here it is plainly:

  • The download: the Ollama listing shows a 23GB quantized build with a 256K context. Recursive says 4-bit weights need about 23GB total and the realistic target is a 48GB Apple Silicon Mac (M4 Pro, M5 Pro, M5 Max) or a 48GB NVIDIA GPU.
  • How to get it: ollama run flint. Ollama shipped Flint support in v0.40.8-rc0, released October 21 — and the release notes say Flint is supported on macOS first, with other GPU support coming in a later release. So NVIDIA and Linux users get the weights today but the one-command Ollama path on those platforms is still coming.
  • Agent workflows: the Ollama library page lists launch one-liners for Claude Code, OpenCode, Hermes Agent, and OpenClaw — e.g. ollama launch claude --model flint.
  • Context: the model card documents 262,144 tokens (prompt plus output). Recursive's blog says up to 512K works but recommends staying within 256K. Remember the weights are only half the memory story: a quarter-million-token context needs a large KV cache on top of the 23GB of weights, so stay near 48GB-class hardware when using long contexts.
  • License: Apache 2.0, on Hugging Face. Commercial use is allowed.
  • Formats: quantized builds exist for Apple Silicon and for other GPUs; Recursive also ships its own rec engine for the M4 Pro and M5 Pro/Max. Its NVFP4 build reportedly scores within 0.7 points of the full 16-bit model — worth knowing if you are on NVIDIA and watching VRAM.

One more background detail: Recursive says its automated "Eureka Machine" research system handled most of the pipeline — architecture, training, quantization, kernels — producing Flint in under four months. The Apache 2.0 weights mean anyone can now inspect the architecture and check that story for themselves.

What changes for you

If you run a local coding agent on a Mac, Flint is a serious new option as of this week: a 40B-class coding model, fast enough to feel instant, with a context window big enough to hold a real codebase. The Terminal-Bench gap against dense models is real, so do not expect it to replace a flagship cloud coder on hard terminal tasks — but at 125+ tokens per second on a laptop, with zero per-call cost, it changes what a local agent loop can afford to try.

Practical next step: use /check to pick a coding workload and see what hardware it maps to, or /learn for the context-window and quantization primers before you pull 23GB.

Sources