Flint Is Fast, But Qwen 3.8 27B Still Wears the Local Crown

Benchmarks: Qwen still wins the heavy ones

The important caveat first: most numbers here are vendor-reported. Qwen’s card is Alibaba’s own table; Flint’s card is Recursive’s own table. Qwen does have more third-party validation — VentureBeat reported an Artificial Analysis Intelligence Index of 52 and Agentic Index of 51 at launch — while Flint is still too new for a comparable independent benchmark suite. (VentureBeat, Recursive model card)

Using Recursive’s own six-test comparison, the pattern is clear: Flint wins the instruction-following tests, but Qwen wins the heavier coding tests. † marks scores measured by Recursive rather than the model developer.

Source: Recursive/Flint comparison as transcribed by i-scoop and LLMCheck.

The SWE-bench Pro v2 row needs an asterisk: it is Recursive’s own measurement on its own harness, not the public SWE-bench Pro leaderboard. Qwen’s official public SWE-bench Pro score is 61.7, and Recursive does not publish a directly comparable public SWE-bench Pro score for Flint. So the safest reading is: Qwen leads on Terminal-Bench, LiveCodeBench, and SWE-bench Verified; Flint leads on IFBench/IFEval; the internal Pro v2 row should not be used to declare a winner. (Qwen model card, LLMCheck caveats)

That is why the honest verdict is not “Flint killed Qwen.” It is: Flint beat the small MoE field, but Qwen 3.8 27B still beats Flint on the hardest shared coding tests. TechCrunch’s summary matches that: on Recursive’s own six-test average, only Qwen3.8 27B scored higher than Flint. (TechCrunch)

Speed is where Flint changes the conversation

Per token, Flint is dramatically faster. A dense 27B model reads most of its weights for every token; Flint reads only a small slice. That is the entire point of the MoE design.

On a 48GB-class Apple Silicon machine, Qwen3.8-27B is commonly around 14 tok/s in stock local runtimes. Flint is around 80–92 tok/s in stock llama.cpp, and 127–145 tok/s with Recursive’s rec engine. That is roughly 6–10× faster per token, depending on which engine you count. For an agent that makes dozens of tool calls, that difference is not cosmetic. It can turn a five-minute loop into a one-minute loop. (TerminalBytes, LLMCheck, TechCrunch)

But speed comes with trade-offs. Flint’s weakest benchmark is Terminal-Bench, where the model has to operate a real terminal. Recursive also says Flint may need more guidance than larger closed coding models, and LLMCheck notes tool-call markup issues in some MLX runs. Qwen3.8-27B is slower per token, but it is more rounded: stronger terminal/agentic scores, stronger LiveCodeBench, stronger vision/document abilities, and broader validation. (Flint model card limitations, LLMCheck)

For home users

If you have 24–32 GB of RAM, Qwen3.8-27B is still the easier recommendation. The Q4 build is around 17 GB, it runs in Ollama/LM Studio/llama.cpp, and it can do coding, general chat, images, documents, and research. It is not fast, but it is capable. On 16 GB, you can squeeze Qwen down to 2-bit or 1-bit, but I would not use those quants for agentic coding; Unsloth’s own guidance is blunt that very low-bit builds are not for tool calling. (TerminalBytes RAM table)

If you have 48 GB or more, Flint becomes very interesting. It is the better “fast private coding agent” candidate: quick enough to iterate, private enough for local repos, and open under Apache 2.0. I would still keep Qwen installed for harder terminal work, multimodal tasks, and anything where the cost of a wrong answer is high.

For business local AI users

For business use, Qwen3.8-27B remains the safer default. It has the stronger public coding profile, multimodal support for documents and screenshots, a larger validation footprint, and more predictable behavior across general knowledge, coding, and agentic tasks. If your workload includes document understanding, image/video input, compliance-sensitive local inference, or higher-stakes code changes, Qwen is the better primary model.

Flint is a strong secondary engine for routine coding loops: test generation, refactors, small bug fixes, repository exploration, and fast drafting where a human reviews the diff. I would not make it the only production coding model yet. Run both on your own repositories, measure pass rate and wall-clock time, and pay special attention to tool-call reliability.

Bottom line

No, Flint did not dethrone Qwen 3.8 27B. It took the speed and efficiency crown, and it is now the most interesting sub-50B MoE coding model for local agents. But Qwen3.8-27B is still the overall king in this size class because it wins the heavier shared coding benchmarks, supports vision, has broader validation, and is more useful as a general local model.

The practical answer is not “pick one forever.” It is: Qwen for capability, Flint for velocity.

And because both models are open-weight, any machine that can run one can usually run the other. That makes it a win-win for users: install both, and reach for Flint when speed matters or Qwen when capability and accuracy matter for the problem at hand.

References

1. Recursive — Introducing Flint
2. RecursiveSI/flint — Hugging Face model card
3. Qwen/Qwen3.8-27B — Hugging Face model card
4. TechCrunch — Recursive launches Flint
5. i-scoop — Recursive’s Flint vs Qwen 3.8
6. LLMCheck — Recursive Flint on Mac: speeds, RAM, setup
7. VentureBeat — Qwen3.8-27B runs frontier-class coding agents locally
8. TerminalBytes — Qwen3.8 27B local speed and RAM measurements
9. Vals AI — LiveCodeBench leaderboard