Flint vs Qwen 3.8 27B: Which Local Coding Model Wins?
Flint is roughly 10x faster than dense Qwen 3.8 27B but scores 55 vs 73 on Terminal Bench. Here is where each local coding model fits.
Should you use Flint or Qwen 3.8 27B for local coding agents?
It depends on whether speed or accuracy is your bottleneck. Qwen 3.8 27B is a dense model that scores higher on Terminal Bench (73 vs 55), SWE-Bench, and LiveCodeBench, but it decodes slowly (about 13 tokens per second on an M4 MacBook Pro). Flint is a sparse mixture of experts that runs roughly 10x faster and gets close on some coding tests. For agent loops with many calls, Flint's speed is attractive. For hard tasks, Qwen 3.8 27B is still stronger.
TL;DR
- Flint is a 40B-total, 2.5B-active MoE from the new lab Recursive, released under Apache 2.0.
- On an M4 MacBook Pro, Flint reached about 130 tokens per second in Recursive's own engine, against roughly 13 for dense Qwen 3.8 27B.
- Qwen 3.8 27B wins the head-to-head on accuracy: Terminal Bench 73 vs 55, and it also leads on SWE-Bench and LiveCodeBench.
- Against MoE peers such as Qwen 3.6 35B, Flint leads on most benchmarks and roughly ties Qwen 3.6 on LiveCodeBench.
- Flint needs more guidance than larger models, so break jobs into small, explicit steps and pick your harness carefully.
- Recursive says an automated research system helped design Flint, but no paper has been published, so those claims can't be checked yet.
What is Flint?
Flint is the first model from Recursive, a lab led publicly by Richard Socher. It is a mixture of experts model with 40 billion total parameters and about 2.5 billion active per token. There are 256 experts. The router picks six per token, and one shared expert is always on.
Two other design details matter for long agent sessions. Of the layers, 35 use sliding window attention (about 500 tokens), and only 14 use full attention. That keeps long context cheaper. The documented limits are 262k tokens of context and up to 65k output tokens. Reasoning is always on.
Licensing is simple: Apache 2.0, not gated. Recursive published four official Hugging Face repos: BF16, INT4, a standard GGUF quantization, and NVFP4.
Why does a sparse model decode so much faster than a dense one?
Local decoding speed is mostly limited by memory bandwidth, meaning how many weights the hardware must read for each token. A dense 27B model touches all its layers and weights every step. Flint touches only the roughly 2.5B active parameters.
The total parameter count answers a different question: will the model fit in memory at all? That is Flint's real cost. You get small-model speed, but you need room for a 40B-parameter model. The sources don't give exact memory requirements, so check the file sizes of the quantization you plan to use.
How do Flint and Qwen 3.8 27B compare on benchmarks?
The reviewer's summary: Flint is not the best coding model. It gets close to dense-model quality at a much higher speed. The Terminal Bench gap is the clearest number.
| Flint | Qwen 3.8 27B | Qwen 3.6 35B (MoE) | |
|---|---|---|---|
| Architecture | Sparse MoE, 40B total / ~2.5B active | Dense, 27B | Sparse MoE, ~35B total / ~3B active |
| Terminal Bench | 55 | 73 | Behind Flint on most tests |
| SWE-Bench | Behind Qwen 3.8 27B | Ahead of Flint | Behind Flint on most tests |
| LiveCodeBench | Behind Qwen 3.8 27B | Ahead of Flint | Roughly tied with Flint |
| Speed (M4 MacBook Pro) | ~130 tok/s | ~13 tok/s | Not stated |
Treat the Qwen 3.6 35B column with care. The source says Flint leads "pretty much on everything" among MoE peers, including Qwen 3.6 35B and Laguna XS, and ties Qwen 3.6 on LiveCodeBench. It also says Flint beats its rivals on instruction following. Exact figures for the other cells were not given, so I've described the relationship rather than inventing numbers.
The reviewer also ran some benchmarks on the NVFP4 build and saw differences from the official numbers, some better and some worse. Results shift with quantization, harness, and settings, so run your own tasks before committing.
How fast is Flint in practice?
The 130 tokens per second figure comes from Recursive's own engine, called Wreck, on a Mac. At the time of the review, that engine only installed on a fairly powerful Mac. The footage of it came from Recursive's launch video, not the reviewer's own hardware.
On an RTX Pro 6000 running the NVFP4 build, the reviewer typically saw around 200 tokens per second. That is a different machine and quantization, so don't treat it as a like-for-like comparison with the Mac number.
One caveat on speed: Flint's reasoning is verbose and variable. Sometimes it thinks for a few hundred tokens, sometimes for thousands. Fast decoding helps, but a long reasoning trace still costs wall-clock time.
What is the tradeoff between speed and accuracy?
For chat, 13 tokens per second is tolerable. For agents it hurts. A loop with dozens of model calls multiplies every slow decode. Flint's speed makes iteration practical on local hardware, and the sparse design is why.
You pay for that in two ways:
- Lower ceiling on hard tasks. The 55 vs 73 Terminal Bench gap is large, and Flint also trails on SWE-Bench and LiveCodeBench.
- More hand-holding. Recursive's own blog says Flint may need more guidance than bigger closed coding models. With 2.5B active parameters, that means smaller jobs with explicit instructions.
A reasonable split: use Flint for fast, well-scoped steps in an agent loop (edits, test runs, small refactors). Use Qwen 3.8 27B when a task is ambiguous, multi-step, or expensive to get wrong and you can wait.
How do you run Flint locally?
Support is already broad. The sources list:
- Ollama
- LM Studio
- llama.cpp
- vLLM and SGLang, for serving
- Recursive's Wreck engine, which is where the headline Mac speed comes from
Harness choice matters about as much as model choice now. Recursive's docs recommend Pi over Open Code, citing reports of Pi being about 1.5x faster with workflows. Test both with your own tasks.
How was Flint built, and should you trust the claims?
Recursive says its automated research system, which it calls the Eureka machine, helped design the architecture, the quantization, and the GPU kernels. The system is a loop: an agent proposes an idea, writes code, runs experiments, and the winners seed the next round, with many paths in parallel.
Three results were attributed to it:
- Architecture search. It started from a roughly 35B-total, 3B-active design similar to Qwen 3.6 35B, then settled on 40B total and 2.5B active.
- Output layer quantization. With a tokenizer of about 150,000 tokens, the output layer alone is around 300 million parameters. Flint quantizes it to 4 bits and recovers accuracy by distilling from a 16-bit version (quantization-aware training). This may help explain why the NVFP4 build scores close to full precision.
- Metal mega kernel. On Apple silicon, a single kernel fuses the whole decode pass, cutting kernel launches and memory trips.
The caveat is real. There is no published paper, and Recursive hasn't said which models or how much compute drove the system. Whether a frontier model from another company did part of the work is an open question. Judge Flint by what it does on your tasks, not by the origin story.
Recursive also noted a useful lesson from this work: as search gets stronger, candidates start gaming the evaluator, for example by caching outputs or exploiting timing. If you run agent loops or RL, treat your verifier as an attack surface.
Frequently Asked Questions
Is Flint better than Qwen 3.8 27B?
No, not on accuracy. Qwen 3.8 27B scores 73 on Terminal Bench to Flint's 55 and also leads on SWE-Bench and LiveCodeBench. Flint's advantage is speed, at roughly 10x on the same MacBook Pro.
How does Flint compare to Qwen 3.6 35B?
Both are mixture of experts models. Flint leads Qwen 3.6 35B on most benchmarks in the comparison and roughly ties it on LiveCodeBench. It also has fewer active parameters (about 2.5B vs about 3B), which is where its speed advantage comes from.
Can Flint run on a laptop?
Yes, with caveats. Recursive's engine reached about 130 tokens per second on a Mac, but that engine needed a fairly powerful one. Flint also runs in Ollama, LM Studio, and llama.cpp, though the 40B total parameter count means memory capacity is the limiting factor.
Is Flint open source?
Flint uses the Apache 2.0 license and is not gated. Recursive published BF16, INT4, GGUF, and NVFP4 versions on Hugging Face.
What harness should I use with Flint?
Recursive's docs recommend Pi over Open Code, citing reports of Pi being about 1.5x faster with workflows. Break larger jobs into smaller, explicit steps, since Flint tends to need more guidance than bigger models.
How we source, write, and correct our articles. Editorial standards
