TL;DR: Flint is a 39.8B-parameter MoE coding model with only ~2.5B active per token, released October 21 under a clean Apache 2.0 license. The official 4-bit GGUF is 22.9GB — weights alone nearly fill a 24GB card, so the comfortable homes are 32GB and 48GB setups. Vendor speed claims (125+ tok/s on an M4 Pro MacBook) pass our bandwidth sanity check.

	Flint 40B-A2.5B	Nemotron 3.5 Bolt 74B-A9B	Qwen3.8-27B
Best for	Fast agent loops on 32-48GB	Strongest agent model that fits 24GB	Best all-rounder on a 24GB card
Weights at 4-bit	22.9GB (NVFP4, official)	22.02GB (IQ2_XXS, official)	~17GB (Q4_K_M)
License	Apache 2.0, no strings	OpenMDW-1.1	Apache 2.0
The catch	24GB card = weights fit, context doesn’t	2-bit quant is doing heavy lifting	Dense: ~3× slower decode than Flint

Honest take: If you already own a 24GB card, keep running Qwen3.8-27B or Bolt and wait for smaller Flint quants with independent benchmarks. If you’ve been eyeing the dual-3090 48GB build or own a 48GB Mac, Flint is the first coding model built specifically for that middle tier — and the license means you can ship with it.

Before buying anything for this model, run your exact quant + context combination through our VRAM calculator — the gap between “weights fit” and “weights plus a real agent context fit” is the whole story here.

What shipped on October 21

Recursive — the self-improving-AI startup founded by ex-Meta FAIR research director Yuandong Tian, with Richard Socher as CEO, which raised $650M+ at a $4.65B valuation in May 2026 with NVIDIA and AMD both participating — released its first model: Flint-40B-A2B, a local coding model the company says was built with its automated research system.

The verified shape of the release:

• 39.8B total parameters, ~2.5B active per token, routed across 256 experts. That ratio (6.3% active) is more aggressive than Qwen3.6-35B-A3B (~8.6%) and in the same family as Nemotron Bolt 74B-A9B.
• 262,144-token context window per the model card. The launch post mentions “up to 512K”; until the model card changes, budget for 262K.
• Apache 2.0 weights at RecursiveSI/flint on Hugging Face — no revenue gate, no OEM clause, no service-operator trigger. The hosted API has separate terms; the weights don’t.
• Official 4-bit GGUFs on day one: an NVFP4 build at 22.9GB and a Q4_1 build at roughly 24GB, plus community repos from Unsloth and lmstudio-community within a day of release.

Day-one official GGUFs matter because they skip the usual two-week wait for community quants — the same pattern NVIDIA set with Nemotron 3.5 Bolt on October 15, and NVFP4 GGUFs have run in mainline llama.cpp since PR #30520 was merged that same day.

The VRAM math: why 24GB is the wrong card

Here’s the arithmetic that decides what you can run this on:

Build	File size	Fits 24GB?	Fits 32GB?	Fits 48GB?
NVFP4 GGUF (official)	22.9GB	Weights only, ~1GB spare	Yes, ~9GB for KV cache	Yes, comfortable
Q4_1 GGUF (official)	~24GB	No practical headroom	Tight	Yes
Q4_K_M (community)	~24GB	No practical headroom	Tight	Yes
BF16 (full precision)	~80GB	No	No	No — needs 96GB+

On a 24GB RTX 3090 or 4090, the 22.9GB NVFP4 file loads — and then the first real agent session kills it. A coding agent context of even 16K-32K tokens needs KV cache space the card no longer has, and Flint’s whole pitch is long agentic sessions in a 262K window. The failure mode is the classic one:

ggml_backend_cuda_buffer_type_alloc_buffer: allocating 1024.00 MiB on device 0: cudaMalloc failed: out of memory

The workarounds are the same ones we documented in the CUDA OOM fix guide: cap --ctx-size to 4K-8K and quantize the KV cache (-fa on -ctk q8_0 -ctv q8_0). That turns a 24GB card into a demo machine for this model, not a daily driver. MarkTechPost’s read of the model card matches: Recursive’s stated targets are 48GB Apple Silicon Macs (M4 Pro and up) and 48GB-class NVIDIA GPU setups.

A sane llama.cpp launch on a 32GB card looks like this:

llama-server -m flint-40B-A2.5B-NVFP4.gguf \
  -ngl 99 -fa on -ctk q8_0 -ctv q8_0 --ctx-size 32768
# expect: ~23GB weights + ~4-6GB KV/compute, streaming at well over reading speed

LM Studio picks the model up through the lmstudio-community GGUF repo. Several launch-day writeups also list Ollama, vLLM, SGLang, and MLX support; we could not independently confirm a flint tag in the Ollama library from this environment, so if you’re an Ollama user, check ollama.com/library or import the GGUF manually.

Speed: the vendor numbers pass the sanity check

Recursive claims 125+ tok/s on an M4 Pro MacBook Pro and 150 tok/s on a 64GB NVIDIA RTX Spark, both at short context, using its own inference engine and quantized weights.

Run those through the bandwidth ceiling (tok/s ceiling = memory bandwidth ÷ bytes read per token). At 4-bit, Flint reads roughly 22.9GB × (2.5/39.8) ≈ 1.4GB per token:

Hardware	Bandwidth	Ceiling	Vendor claim	% of ceiling
M4 Pro	273 GB/s	~190 tok/s	125+	~66% — plausible
RTX Spark (N1X)	300 GB/s	~210 tok/s	150	~71% — plausible

Both land in the 60-80% band where real MoE decode usually sits. Contrast that with the inflated numbers we regularly catch from benchmark-farm sites — these claims are at least physically possible.

Nobody has published independent numbers on discrete GPUs yet (the model is two days old). Computed from the same method, calibrated against our measured canon — Qwen3.6-35B-A3B at 157.66 tok/s on an RTX 3090 reads ~1.9GB/token, i.e. ~32% bandwidth efficiency under llama.cpp — a used RTX 3090 (936 GB/s) should decode Flint at roughly 150-250 tok/s, and a Radeon AI PRO R9700 (640 GB/s) at roughly 100-170 tok/s. Treat both as computed estimates, not measurements; we’ll update when llama-bench runs land.

Two things follow from the 2.5B-active design. First, decode speed stops being the reason to buy expensive hardware for this model — nearly everything that can hold it runs it faster than you can read. Second, prefill (prompt processing) and context capacity become the real differentiators, which is exactly where discrete NVIDIA cards beat unified-memory machines and where 48GB beats 32GB.

The benchmark claims — and the asterisks

All launch benchmarks are self-reported by Recursive, run through mini-swe-agent with no internet access, and not yet on any independent leaderboard. With that said, the vendor table:

Benchmark	Flint BF16	Flint NVFP4	Qwen3.6 MoE	Qwen3.8 dense
SWE-bench Verified	74.2	74.1	73.4	75.6
SWE-bench Pro v2	89.7	88.5	73.8	94.9
Terminal-Bench 2.1	54.9	—	—	73.0
LiveCodeBench v6	80.3	—	—	—

Three honest reads:

1. The NVFP4 build barely loses anything (74.1 vs 74.2 SWE-bench Verified). Since NVFP4 is the build you’ll actually run locally, that’s the most useful row in the table.
2. Flint does not beat the frontier of open coding models. Qwen3.8 dense outscores it on both SWE-bench columns and by 18 points on Terminal-Bench. Flint’s claim is a different one: near-frontier agent quality at ~2.5B active parameters, which means 3-5× the decode speed of a dense model of similar quality on the same hardware.
3. The 89.7 SWE-bench Pro number is the suspicious outlier — it would put Flint far above much larger models while SWE-bench Verified shows near-parity with Qwen3.6. Until a third party reproduces it, weight your decision on the Verified column.

For how Flint’s niche compares to the other small coding models of this fall — JetBrains’ Mellum 2.1 12B for 12GB cards below it and Nemotron Bolt 74B beside it — our local coding LLM overview has the full ladder.

Who runs it on what

48GB of VRAM (two used RTX 3090s) — the intended audience, and the config with the best price-to-capability ratio right now. The pair costs $2,912-$3,116 at October 2026 used prices ($1,456-$1,558 per card), holds the 22.9GB NVFP4 build plus a six-figure-token KV cache, and brings CUDA prefill speed that no unified-memory machine matches. Full build details in our dual-3090 vs used-4090 comparison and the 48GB tier guide.

32GB (Radeon AI PRO R9700, $1,400-$1,900 street) — the cheapest single new card that runs Flint with usable context. 22.9GB weights + ~9GB for KV at q8_0 supports a 32K-64K working window. ROCm’s prefill gap (2.6-3.4× slower than NVIDIA, per our R9700 review) matters more on an agent model than a chat model — agents re-read long contexts constantly. The RTX 5090 32GB also qualifies, but at $3,822-$5,000 street it costs more than the 48GB dual-3090 path and holds less.

48GB+ Apple Silicon (M4 Pro and up) — Recursive’s own demo platform, and the 125+ tok/s claim was made on exactly this hardware. If you already own a 48GB-or-more M-series Mac, Flint is free capability; see our Ollama MLX guide for the current Mac inference stack. Buying a Mac for this model only makes sense if you also want everything else a Mac is.

128GB unified memory (Strix Halo, DGX Spark) — runs Flint at Q8 (~42GB) with enormous context headroom, and NVIDIA’s new 64GB DGX Spark configs started rolling out from partners today, October 23, aimed squarely at this model class. Bandwidth (256-300 GB/s) caps decode around 130-210 tok/s computed ceiling — still faster than you read. Our DGX Spark 64GB vs 128GB breakdown covers that decision.

24GB (single 3090/4090) — wait. Weights fit, agent contexts don’t. Either run Bolt 74B’s IQ2_XXS (designed for 24GB) or wait for Flint Q3/IQ-series community quants with measured quality numbers.

What to actually buy

Prices as of October 2026, all verified in the sections above:

Your situation	The hardware	Price	Where
You want Flint as a daily coding agent, best capability per dollar	2× used RTX 3090 (48GB)	$2,912-$3,116 + host	Check price
You want one new card with warranty that runs it today	Radeon AI PRO R9700 32GB	$1,400-$1,900	Check price
You already own a 24GB card	Nothing — run Qwen3.8-27B / Bolt 74B, wait for smaller Flint quants	$0	—
You already own a 48GB+ Mac	Nothing — Flint is free capability on it	$0	—
You want to test Flint before spending anything	Rented 3090/4090, from $0.07/hr	pay per hour	Vast.ai

If you wire Flint into Cursor or Cline as a local BYOK backend, our sister site covers that setup at aicoderscope.com; for the self-hosting stack around it (llama.cpp server, Open WebUI), see aifoss.dev.

FAQ

Does Flint fit on a single RTX 3090 or 4090? The 22.9GB NVFP4 weights load on a 24GB card, but an agent-sized context does not fit beside them. With --ctx-size capped at 4-8K and q8_0 KV cache it runs as a demo; as a daily coding agent it needs 32GB+.

Is the license really unrestricted? The weights are Apache 2.0 — no revenue cap, no user threshold, commercial self-hosting allowed. Recursive’s hosted API has its own separate terms.

Is it better than Qwen3.8-27B? On vendor numbers it’s roughly equal on SWE-bench Verified (74.2 vs the dense Qwen3.8’s 75.6) while decoding several times faster thanks to 2.5B active parameters. But Qwen3.8-27B fits a 24GB card at Q4 with context to spare; Flint doesn’t. On a 24GB card, Qwen wins by default.

How fast is it on a used RTX 3090? No independent measurement exists yet. Computed from the bandwidth-ceiling method calibrated on our measured MoE canon, expect roughly 150-250 tok/s decode at short context — we’ll update when real llama-bench numbers appear.

What was Flint trained from? Recursive says it was built with the company’s automated research system; the launch materials we could verify don’t conclusively state whether it was trained from scratch or adapted from an existing base.

Recommended Gear

Products linked in this article:

• Used RTX 3090 24GB — $1,456–$1,558 each used (Oct 2026); two of them make the 48GB config Flint was built for
• Radeon AI PRO R9700 32GB — $1,400–$1,900 street; the cheapest single new card that runs Flint with usable context

Sources

• Recursive releases Flint, an open-weight 40B MoE local coding model with 2.5B active params — MarkTechPost
• Recursive SI launches Flint 40B: open weights that run on the developer’s own machine — Yahoo Tech
• Yuandong Tian’s Flint release announcement — X
• Recursive Flint: 40B local coding model, specs and scores — CellCog
• Recursive Flint: specs, VRAM, local agent test — AtomicAgent
• Recursive releases Flint 40B model for local coding — TestingCatalog
• Recursive just open-sourced a 40B coding model — DEV Community
• Flint 40B-A2.5B Q4_K_M GGUF (community quant) — Hugging Face
• NVIDIA and local AI community fuel open source models and intelligent agents — NVIDIA Blog
• Bringing the Spark to Europe: DGX Spark 64GB rollout — NVIDIA Blog
• Recursive Superintelligence raises $650M as it emerges from stealth — TechMarketView
• Ex-Meta star researcher joins race to self-improving AI at US$4.6B startup — SCMP
• Used RTX 3090 price history — Best Value GPU

Last updated October 23, 2026. Prices and specs change; verify current rates before purchasing. Benchmark scores above are vendor-reported and not yet independently verified.

Get the numbers before you buy

New GPU and mini-PC benchmarks, VRAM thresholds, and price checks — sent when there's something worth acting on, not on a schedule. No spam, unsubscribe anytime.

Email address Subscribe