Is Flint the Killer of Qwen 3.8 27B? (First RSI Model)

Summary

The video evaluates Flint, Recursive’s first coding model, against local alternatives such as Qwen. Its central conclusion is that Flint’s headline speed of 131 tokens per second is legitimate on the tested setup, but tokens per second do not necessarily predict how quickly a coding task will be completed. Flint can be very fast on short, clearly scoped tasks, yet its always-on reasoning can consume many extra tokens and make some jobs much slower.

Model and technical features

• 39.8B total parameters, using a mixture-of-experts (MoE) architecture. A router activates six expert blocks plus a shared expert for each token, so about 2.5B parameters are active at a time.
• 49 layers: 14 attend to the full conversation history, while 35 use a 513-token window to reduce memory use at long contexts.
• 262K-token context window; text-only, with no vision. One developer measurement cited in the video puts the 8-bit cache at about 3.8 GB at full context.
• Available under the Apache 2.0 license. The video reports model files ranging from roughly 11.9 GB for a highly compressed version to 23–25 GB for other versions.
• Recursive says its automated Eureka research system helped build much of the model in under four months. The presenter treats this as an unverified claim because no paper on the system has been published.

Speed, quality, and task-time trade-offs

Flint’s MoE design helps explain its per-token speed. On an M4 Pro with 273 GB/s memory bandwidth, the video estimates that a 4-bit dense 27B model must load about 13.5 GB of weights per token, compared with about 1.25 GB for Flint’s active parameters. This makes Flint’s reported 131 tokens/s plausible. However, the presenter stresses that this is a short-context result, not a guarantee of real-world task speed.

On Recursive’s published benchmarks, Flint performs strongly against a similarly sized MoE competitor, including scores of 54.9 vs. 44.9 on Terminal Bench 2.1 and 89.7 vs. 73.8 on SWE-Bench Pro v2. Against the smaller dense Qwen 27B, however, Flint loses four of six published benchmarks and averages 80.6 vs. 84.6.

The major caveat is Flint’s reasoning behavior:

• Reasoning is always on, and users cannot set a reasoning-effort level or thinking budget. Recursive recommends large output budgets for difficult reasoning and coding-agent tasks.
• In one cited 14-task test, Flint solved 12 tasks versus Qwen’s 10, but used 45,082 tokens versus 2,732 and took about eight times longer. Limiting Flint to 2,048 output tokens reduced its correct results from 12 to nine.
• In an agentic coding test, both models solved seven of 10 tasks, but Flint’s median task took 3.9 minutes, compared with 30 seconds for Qwen.
• Flint’s reasoning can help with difficult work, but it can also create unpredictable delays, even for small edits. Recursive’s troubleshooting guidance acknowledges that agents may repeat actions or drift from instructions, and recommends shorter tasks and fresh conversations.

Context and benchmark caveats

• Recursive’s 131 tokens/s figure uses only 1,000 input tokens. Its published long-context result drops to about 69 tokens/s, and the video cites further declines as context grows.
• Coding agents may begin with 17,000–26,000 tokens of instructions and context. Reading that prompt can add substantial delay before generation begins; the presenter cites an example where a 26,000-token prompt took nearly 90 seconds to prefill.
• A long run at roughly 115,000 tokens of context reportedly fell to around nine tokens/s.
• Recursive’s “up to twice as fast” comparison uses different inference engines for the models. On the same engine, the video reports Flint at 87.98 tokens/s vs. Qwen at 65.55, or about 1.34× faster. Recursive’s faster proprietary engine is Mac-only, has specific hardware requirements, and did not run on every Mac tested.
• Weight format and quantization matter. Some negative reviews used early builds or heavily quantized files, while Recursive’s benchmarks used NVFP4 weights. Flint is also text-only, so it cannot inspect screenshots or visually check UI work.

Where Flint works best—and who might try it

Flint appears strongest on short, scoped, well-defined tasks. In one test on an RTX 5090, it passed 12 of 18 runs in 375 seconds; a comparable model passed 14 of 18 but took 1,749 seconds. Longer or open-ended agent tasks are more vulnerable to extended reasoning, looping, or instruction drift.

The presenter particularly recommends trying Flint for people with supported 48 GB M4 Pro/M5 Pro-class Macs, especially those currently using a dense local model and prioritizing generation speed. It may also suit users who need an Apache-licensed, US-based alternative or people willing to offload some experts to system RAM on lower-memory GPUs. The video reports that Flint is available to try free through OpenRouter and OpenCode’s free tier.

For AMD hardware, the presenter recommends the Vulkan build, warning that a Windows ROCm configuration reportedly fell back to CPU execution. Users should also check which model weights they download and verify that the chosen file and runtime are compatible with their hardware.

Practical testing guide

The video recommends evaluating Flint by time to a completed task, not tokens per second:

1. Choose a task you have already solved with your current model, with tests or another clear completion criterion.
2. Time from submitting the prompt until the task is actually complete.
3. Keep tasks short and specific, and start a fresh conversation for each one to avoid carrying a large context forward.
4. Consider a hybrid workflow: use a heavier model for planning or architecture, then Flint for smaller implementation tasks and edits.
5. When comparing agent setups, the presenter points to Recursive’s Pi agent; Recursive’s documentation reportedly suggests it can run workflows about 1.5× faster than OpenCode in informal testing.

Overall, Flint is a promising fast local model, particularly for short tasks and compatible Mac setups. Its speed advantage is real at the token level, but its lack of a reasoning control and tendency to use many tokens can erase that advantage on longer jobs.

Main speakers and sources

• Kai — the video’s presenter and tester.
• Recursive — model specifications, benchmark charts, documentation, and troubleshooting guidance.
• Dol Mario Local AI — cited comparison across everyday tasks.
• AI Code King — cited measurements of agent context, long-context speed, and coding tasks.
• Community users and commenters — cited reports of agent behavior and hardware experiences.