Recursive released Flint on 21 October, presenting it as a fast coding model that runs locally on a laptop (launch post). The parts of that release anyone can check are concrete: about 79.6 GB of BF16 weights on Hugging Face under Apache 2.0, an architecture documented in the model’s own configuration file, and a serving kit that names the data-centre GPUs it supports. The parts that have drawn most of the attention are the ones no outside check has settled: the performance figures, and the company’s claim that an internal system called the Eureka Machine contributed to nearly every part of the model-building stack.
Everything below reflects the sources as they stood on 25 October 2026.
What the download contains
The Hugging Face repository RecursiveSI/flint holds 15 BF16 safetensors shards totalling about 79.6 GB, along with a configuration file, tokenizer, chat template and an SGLang serving kit, at revision 2a247be0c0aec895ccb0ac7ca92229ec6df37288. The LICENSE file is the unmodified Apache License 2.0 text with no added clauses, and the community quantization repositories inherit the same licence.
The model card draws the line that matters most for anyone weighing the release: “Flint is released under the Apache 2.0 license. Hosted API terms and data practices are separate from the weight license.” Those hosted terms, dated 21 October, make training on submitted inputs a condition of using the hosted services, with no opt-in and no opt-out except where the law grants one. The same terms expressly permit benchmarking and publishing results, provided the methodology and results are described accurately.
The architecture in config.json is a decoder-only mixture of experts: 39.8B parameters in total with roughly 2.5B active per token including the output head (the card’s footnote puts the active body alone at about 2.2B), 49 layers of which two are dense and 47 are mixture-of-experts, 256 routed experts with six selected per token plus a shared expert, and a vocabulary of 150,144. Only 14 of the 49 layers use full attention; the other 35 keep a 513-token sliding window. The stated knowledge cutoff is June 2026.
The released checkpoint needs a 141 GB data-centre GPU
Recursive’s serving instructions ask for one GPU with at least 141 GB of memory per replica: a B300, B200 or H200. They state that 80 GB GPUs are not supported, that B200 and GB200/GB300 are not validated yet, and that tensor, expert and pipeline parallelism, quantized weights and KV cache, and speculative decoding are not validated either. Plan on about 80 GB of disk for the weights and roughly 50 GB for the container image. The server listens on 0.0.0.0 without authentication by default. Transformers support is not there yet: the model card says the modelling code is not included and the serving kit says Transformers does not support Flint, so the generic Transformers snippets shown on the model page should not be read as a working path.
What you can run locally
Two official routes exist, and one of them is incomplete. rec, Recursive’s own inference engine, requires an M4 Pro, M5 Pro or M5 Max Mac with at least 48 GB of unified memory and about 30 GB of free disk. It checks the chip and the memory before downloading and refuses to fetch Flint below that floor, and it handles one generation at a time. RTX Spark support, the hardware behind one of the launch throughput figures, had not shipped at the time of checking. The llama.cpp guide in the documentation was not runnable as published: it still contained unfilled placeholders for the runtime repository URL and the validated context length, next to a warning not to substitute a model’s advertised maximum for the tested limit on your machine (Mac guide).
Everything else runs on community quantizations, and there are many. The Hugging Face listing showed 63 quantized repositories, including Unsloth’s GGUF builds, LM Studio’s and ggml-org’s, and MLX builds; Unsloth’s repository alone reported 78,891 downloads in the previous month. Published file sizes run from 11.4 GB for a 1-bit GGUF to 42.3 GB at 8-bit, with 25.1 GB at 4-bit, 29.9 GB at 5-bit and 36.3 GB at 6-bit. The mlx-community 4-bit build takes 25.6 GB on disk and about 26 GB of unified memory, was built and scored on a 36 GB Mac where long prompts leave little headroom, and needs the third-party mlx-optiq package because stock mlx-lm has no Flint class. A usable local build lands somewhere around 25 to 36 GB of weights before the KV cache. Some listings advertise 21B or 33B parameters rather than 40B, which suggests expert trimming or mislabelling; those per-repo counts were not verified.
Recursive’s own numbers, and the average built from six benchmarks
The model card publishes three figures, marked with a dagger for scores measured by Recursive: 54.9% on Terminal-Bench 2.1, 89.7% on SWE-bench Pro v2 and 74.2% on SWE-bench Verified. Sampling was temperature 1.0, top-p 0.95 and top-k 20, with Terminus 2 for Terminal-Bench and mini-swe-agent for the SWE-bench runs; the agentic scores are average pass@1 over at least five attempts.
The card also carries an adjustment that works against Recursive, and it belongs beside the Terminal-Bench score: solutions obtained through web retrieval are counted as unsuccessful in Flint’s run, and the card notes that developer-reported comparison scores may not apply the same adjustment. The 89.7% on “SWE-bench Pro v2” is Recursive’s label for a benchmark with no public description under that version name. The published SWE-Bench Pro paper describes 1,865 problems from 41 repositories, split into public, held-out and commercial sets, with the commercial results released only as aggregate scores, so the non-public portions cannot be re-run from outside and the contents of “v2” are unknown. The model scores higher on that harder suite than on the easier Verified suite, an ordering worth noting without treating it as evidence of an error.
The headline number in the launch post is a mean across six benchmarks that is not published as text anywhere the sources could reach; it appears in chart images. The average is unweighted and mixes three agentic software-engineering suites (Terminal-Bench 2.1, SWE-bench Pro v2, SWE-bench Verified) with three single-turn suites (LiveCodeBench v6, IFBench, IFEval). Two of the single-turn suites measure instruction following rather than coding, and the IFBench authors’ own convention is temperature 0 with prompt-level loose accuracy, so Recursive’s figures are not directly comparable with published IFBench numbers even before they are averaged in. No weighting and no confidence interval are reported. Recursive’s own scope claim is narrower than the headline: the post says Flint is best among MoE models under 50B total parameters and “rivals the coding performance of dense models with 25-40 billion parameters, while running more than five times faster”. TechCrunch, working from Recursive’s average across the six tests, reported that only Alibaba’s Qwen3.8 27B scored higher.
512k in the blog, 262,144 everywhere else
The launch post says Flint supports context windows of up to 512k tokens and recommends staying within 256k for best results. The 512k figure appears nowhere else that could be fetched. The model card’s specification table gives a documented context configuration of 262,144 tokens including prompt and output; config.json sets max_position_embeddings to 262144; both SGLang launch commands use --context-length 262144; and OpenRouter’s page for the free endpoint lists 262,144. The card frames the number the way the evidence supports: “The context configuration is a capacity limit, not a guarantee of uniform accuracy across all sequence lengths or tasks.” Long contexts are not free either. The serving kit estimates the KV cache at 28 KiB per token on the full-attention layers, about 7.5 GB for a single 262,144-token sequence, plus 70 KiB per token on the sliding-window layers, which retain only the last 513 tokens per request.
Throughput conditions, as stated
The blog says Flint generates more than 125 tokens per second on an M4 Pro MacBook Pro and more than 150 tokens per second on a 64 GB Nvidia RTX Spark at short contexts, up to twice as fast as comparable models. Its own footnote defines the speed figure differently: average tokens per second throughout a 128k-token session, with prefill excluded. Recursive’s materials carry three multipliers with three baselines: up to twice as fast as comparable models, more than five times faster than dense 25-40B models with similar scores, and, in the rec engine’s README, 1.4 to 2.6 times the token throughput of llama.cpp on an M4 Pro with 4-bit weights, 1K to 252K-token prompts, 1,024 output tokens and five runs per context. Not stated anywhere: the number of runs behind the headline figure, the prompt-length distribution, whether server or harness overhead is included, the thermal and power state, and which quantization was used. TechCrunch repeated Recursive’s figures with more precision than the blog, at about 131 tokens per second on an M4 Pro MacBook Pro against 58 to 69 tokens per second for similar models on the same machine, and attributed them to Recursive’s tests. The one throughput figure measured by somebody other than Recursive is not a laptop result: OpenRouter’s platform telemetry puts the free hosted endpoint at a P50 (median) of 92 tokens per second over three days.
What Wired’s hands-on tested
Will Knight’s Wired piece is the only outside hands-on in the sources checked. He used a Mac with 48 GB of RAM, chip not named, over “the past few days”, on three tasks: a command-line to-do list, a program that scours the web for research on recursive self-improvement, and a simple website explaining the field. He found the model “fast and very capable” and wrote that it “nailed my coding requests every time”. The comparison with Claude and Codex in the piece is an impression about models of this size, with no head-to-head measurement behind it. Throughput, context length, runtime and quantization, chip model, per-task duration, success criteria, tool-calling reliability, long-context behaviour and cost are not reported. Much of the article is about recursive self-improvement policy, including an Anthropic researcher’s resignation and bills in Congress proposing to ban the work, which is background to the product.
Community machine results are self-reports
A handful of users have posted their own numbers in the model’s Hugging Face discussions. They are self-reported: no published method, unpinned quantization tags, no replication. One user reports an M5 Pro Mac mini with 64 GB running a 4-bit build through Ollama at 115 tokens per second on a short prompt and 87 tokens per second while writing code after reading a 20,000-token codebase, with 40 of 40 tests passing on a feature added to that codebase, and complains that the model “overthinks”, sometimes spending more than 20,000 reasoning tokens before writing code (discussion 15). Another reports an RTX Pro 5000 48 GB with an NVFP4 GGUF at about 26 GB of VRAM and about 115 tokens per second decode at full context (discussion 17). A fit table in discussion 8 estimates about 24 GB for a 4-bit MLX build and about 27 GB for Q4_K_XL, but that table is an estimate from a compatibility site, with no measurement behind it, and when its author asked the M5 Pro user above for an exact quantization tag and prompt-evaluation rate, neither was available. Two further threads place the model below Qwen 3.6-35B-A3B and Qwen 3.8 27B as impressions.
The nearest thing to an outside check on the scores comes from a community evaluator who re-ran two of the published figures on a single RTX PRO 6000 with the NVFP4 GGUF: LiveCodeBench v6 at 82.2% over 45 problems and SWE-bench Verified at 80% over 50 tasks, described in the post as in line with Recursive’s NVFP4 results, with the method and transcripts in a linked public repository (discussion 7). Both samples are small, and neither of the two headline agentic scores is covered.
Several threads document friction that matches Recursive’s own caution that Flint “may need more guidance than the larger closed-source coding models you’re used to”. There are reports of tool-use planning loops through the rec endpoint (discussion 12), argument-formatting problems in other runtimes, a chat template ignoring enable_thinking=false under vLLM, and one run that spent 56,059 reasoning tokens inside a 64K output budget. A community answer on the engine’s controls says reasoning_effort, thinking_token_budget and reasoning_budget_tokens were not supported at one revision, and that custom stop strings are rejected by the Flint grammar. The model card’s own warning points the same way: “long reasoning can increase latency and exhaust the output budget before an answer is complete.”
The Eureka Machine claim, in Recursive’s words
Recursive’s wording is specific enough to quote and hold at that: “Our Eureka Machine helped develop nearly every part of Flint’s model-building stack, from data and training recipes to infrastructure and inference optimization.” The post describes the system exploring expert configurations and widths, searching quantization recipes, quantizing the output head to 4 bits, and producing a Metal megakernel for M4 and M5 chips, and says those discoveries helped a small team “build Flint from scratch and reach state-of-the-art results on our target benchmarks in under four months”. Wired quotes Recursive’s chief executive, Richard Socher, saying that “nearly every aspect of the entire model pipeline was actually done and improved upon by AI”. The model card does not mention the Eureka Machine at all; its training section says only that Flint was trained from scratch through pretraining, mid-training, supervised fine-tuning and reinforcement learning. The attribution lives in the blog and the interviews, and the model repository does not record which parts were automated.
Nothing outside the company has seen the process. There is no paper, no external audit, no ablation, no published experiment log, no split between human and automated contribution and no headcount. TechCrunch reports that Recursive did not say how much time the Eureka Machine saved its researchers, and the same piece puts the company’s funding at USD 650m on a USD 4.65bn valuation with an AWS compute deal, which is the scale the four-month claim should be read against. The nearest inspectable artifact is the company’s June 2026 post on automated AI research, which published three self-run results and open-sourced its run artifacts, and which states its own limit plainly: the work “does not necessarily prove independent rediscovery, since the underlying models may know many public techniques”. That post supports the claim that the system exists and produces inspectable output. It does not establish what the system contributed to Flint, and the launch post does not quantify it either.
What “laptop coding model” covers
The label holds for a narrow class of machines: a recent Apple silicon Mac with at least 48 GB of unified memory on the vendor engine, or a 32 GB-plus GPU or high-memory Mac running a community quantization of roughly 25 to 36 GB. It does not describe a typical consumer laptop, and the vendor requirement is enforced by a pre-download hardware check. Recursive concedes the guidance gap directly: “While Flint is very capable, it may need more guidance than the larger closed-source coding models you’re used to.” Hosted access is the other open question. The documentation’s FAQ answers “Is there a Flint API?” with “Yes. The Flint API is available to select partners. Request access”, while OpenRouter listed a free hosted endpoint for recursive/flint-v1.0:free at check time, and the documentation offers free hosted use through OpenCode’s free tier and the Radius provider inside Pi. Those two positions do not match.
No full reproduction of the headline results
The community check above covers two suites at 45 and 50 samples on a quantized build; the six-benchmark average, the Terminal-Bench and SWE-bench Pro v2 scores, and every speed figure still rest on Recursive’s own runs, and no full independent reproduction of any of them exists in the sources checked. Search tools were unavailable during the check, so outside coverage that was not fetched cannot be ruled out, and the Hugging Face repository has a single commit, so post-launch weight changes cannot be checked beyond the pinned revision. The reading changes if any of the following appears: a public description of “SWE-bench Pro v2”, an outside measurement of throughput or a re-run of the headline benchmarks, RTX Spark support in rec, the llama.cpp guide’s placeholders being filled, or the 512k line being reconciled with the documented 262,144-token configuration. Recursive’s model terms expressly permit third parties to benchmark Flint and publish the results, so the checks that would settle the numbers are open to anyone with the hardware to run them.
