On October 21, 2026, a startup called Recursive released Flint — a 40-billion-parameter coding model built largely by an AI system, designed to run entirely on your laptop. No subscription, no cloud bill, no data leaving your machine. Here is everything we know about Recursive Flint, how fast it really is, and whether it belongs in your development workflow.
Table of Contents
- What Is Recursive Flint?
- Who Built Recursive Flint? (Meet Recursive)
- The Eureka Machine: AI That Helped Build the AI
- Recursive Flint Specs at a Glance
- How Fast Is Recursive Flint?
- Recursive Flint Hardware Requirements
- Recursive Flint Benchmarks: What the Numbers Say
- Recursive Flint vs the Competition
- How to Run Recursive Flint on Your Laptop
- What Recursive Flint Is Good At
- Where Recursive Flint Falls Short
- Who Should Use Recursive Flint?
- Recursive Flint FAQs
- The Bottom Line
What Is Recursive Flint?
Recursive Flint is an open-weight coding model released on October 21, 2026, built specifically for agentic coding — the kind of AI work where a model investigates a codebase, fixes bugs, implements features, and writes tests on its own (launch details via MarkTechPost). It is a mixture-of-experts (MoE) model with about 40 billion total parameters, but only around 2.5 billion are active for any given token, which is what makes it fast enough to run on a single laptop.
What makes Recursive Flint genuinely different from the parade of recent open-weight releases is how it was made. Recursive, the company behind it, says its automated research system — the Eureka Machine — helped build nearly every part of the stack: the architecture, the quantization, the inference kernels, even the training recipes. That makes Flint the first public proof that an AI research assistant can produce something developers can actually download and use.
The weights are available on Hugging Face under the permissive Apache 2.0 license, so anyone can run Recursive Flint locally, fine-tune it, or build commercial products on top of it. It runs with familiar open-source tooling — llama.cpp, Ollama, Unsloth, LM Studio, vLLM, SGLang — plus Recursive’s own inference engine, “rec.” It is text-only, supports reasoning, and speaks OpenAI-compatible tool calls, which means it plugs into most existing agentic coding setups.

Recursive Flint brings 40-billion-parameter coding intelligence to a single laptop — no cloud subscription required.
Who Built Recursive Flint? (Meet Recursive)
Recursive — formally Recursive Superintelligence — is led by CEO Richard Socher, a name many in AI will recognize. Socher was Salesforce’s former chief scientist and later founded the search startup You.com. Under his leadership, Recursive has raised $650 million at a $4.65 billion valuation, with backing reported by WIRED from Google Ventures, Nvidia, and AMD Ventures — a serious war chest for a company releasing its very first model.
The ambition is bigger than one coding model. Recursive’s stated goal is automated AI research: systems that propose ideas, write the code to test them, check the results, and plan the next round of experiments — running many research loops in parallel with human scientists. Recursive Flint is the first shipped product of that process, built from scratch in under four months by a small team of humans working alongside AI agents.
That four-month timeline is worth pausing on. Training a frontier-class coding model from scratch typically takes much longer and a far larger team. Whether or not you believe the most ambitious claims about the Eureka Machine, the schedule alone suggests the tooling meaningfully accelerated the work — and it puts Recursive on the map as a lab to watch alongside the established players.
The Eureka Machine: AI That Helped Build the AI
The most interesting part of the Recursive Flint story is not the model itself — it is the machine that helped create it. According to Recursive, the Eureka Machine is an automated research system that proposes ideas, writes the code to test them, evaluates the results, and decides what to try next, running many experiments in parallel.
The company credits the system with contributions across nearly the entire stack (full Eureka Machine breakdown at teckhustlers):
- Architecture: the Eureka Machine tested expert layouts and converged on the 40-billion-total, 2.5-billion-active design.
- Quantization: it found a way to shrink the model to 4-bit precision while staying within 0.7 benchmark points of the full model — the trick that makes the 23 GB download possible.
- Kernels: it wrote custom inference code tuned specifically for Apple Silicon and NVIDIA RTX Spark chips, which is where the speed claims come from.
- Training: it worked on data selection, optimizers, and training recipes.
An honest caveat, raised by WIRED’s reporting: a model that codes well is not the same thing as a system that keeps making itself smarter on its own. Recursive Flint is a snapshot — a finished product the Eureka Machine happened to help produce. Whether the Eureka Machine is getting measurably better at discovering new architectures and optimizations each time it runs — the actual definition of recursive self-improvement — is something Recursive has not yet shown outsiders proof of. Socher has also said the system that built Flint cannot escape human control, and that any future fully self-improving version would remain overseen by people who can stop it.

The Eureka Machine wrote custom inference kernels for Apple Silicon and NVIDIA chips — key to Recursive Flint’s speed.
Recursive Flint Specs at a Glance
Here are the verified Recursive Flint specifications, drawn from the model card and launch-day reporting:
| Spec | Recursive Flint |
|---|---|
| Total parameters | ~40 billion (39.8B) |
| Active parameters per token | ~2.5 billion |
| Architecture | Decoder-only MoE Transformer — 49 layers, 256 routed experts (6 picked per token) plus 1 shared expert |
| Context window | 262,144 tokens documented; company blog cites up to 512K (256K recommended) |
| Knowledge cutoff | June 2026 |
| License | Apache 2.0 (fully open weights) |
| Modalities | Text only — no image or audio input |
| Tool calls | OpenAI-compatible; reasoning supported |
| Where to get it | Hugging Face (open download) |
| Runs with | llama.cpp, Ollama, Unsloth, LM Studio, vLLM, SGLang, Recursive’s own “rec” engine |
The mixture-of-experts design is the key to everything else about Recursive Flint. Instead of one giant network where every parameter fires for every token, an MoE model splits the network into many smaller “experts” and routes each token through only a handful of them. Flint stores 40 billion parameters but uses roughly 2.5 billion per token — so the compute cost per token looks like a small model while the knowledge capacity looks like a big one.
If the terms “tokens” and “context window” feel fuzzy, the short version: tokens are the chunks of text a model reads and writes, and the context window is how much text it can consider at once. A 262,000-token window is enormous — enough to hold a large codebase, its documentation, and a long conversation about a bug without forgetting the beginning.
How Fast Is Recursive Flint?
Speed is Recursive Flint’s headline claim, and the numbers are striking. Recursive says its optimized inference engine pushes Flint past 125 tokens per second on an M4 Pro MacBook Pro and past 150 tokens per second on an NVIDIA RTX Spark at short contexts — which it describes as up to twice as fast as comparable models.
Independent-ish corroboration exists: TechCrunch, citing Recursive’s tests, put the MacBook figure at about 131 tokens per second, versus 58 to 69 for similar models such as Google’s Gemma 4 and Nvidia’s Nemotron 3.5 Lightning on the same machine. A WIRED reporter who ran Recursive Flint on a Mac with 48 GB of memory found it handled every coding request quickly, including building a command-line to-do app, a web-search research tool, and a simple website.
To put 125 tokens per second in practical terms: a typical code snippet — a function, a bug fix, a test file — materializes in a few seconds. Recursive also claims Flint matches dense models of 25 to 40 billion parameters on coding while running more than five times faster. As always with launch-day figures, treat the exact numbers as company-reported until independent labs re-run them — but the direction is unambiguous: this is built to feel instant on consumer hardware.
Recursive Flint Hardware Requirements
Recursive Flint is not a “runs on anything” model — it needs a machine with serious unified memory. The official requirements:
- Apple Silicon: 48 GB Macs — M4 Pro, M5 Pro, or M5 Max
- NVIDIA: 48 GB GPUs (or a 64 GB RTX Spark for the top speed figures)
- Download size: the 4-bit quantized build is about 23 GB (the Ollama listing shows a 23 GB build with a 256K context)
That 48 GB bar is the price of admission, and it is worth being honest about: a base-model laptop with 16 GB of RAM cannot run Recursive Flint. But compare it with the alternatives in its weight class. Meta’s Muse Spark Open — an 816-billion-parameter open model — needs at least a terabyte of memory per TechCrunch’s reporting. Flint’s 23 GB download and 48 GB requirement put frontier-adjacent coding capability on hardware a professional developer might already own. Local means offline, private (your code never leaves the machine), and free of per-token API charges.

Recursive Flint needs 48 GB of unified memory — a serious but reachable bar for professional developers.
Recursive Flint Benchmarks: What the Numbers Say
Recursive reports that Flint leads all mixture-of-experts models under 50 billion total parameters on agentic coding benchmarks. The headline figures from the model card:
- SWE-bench Verified: 74.2% — the standard test of real-world bug-fixing ability, built from actual GitHub issues and pull requests. This is the score that matters most for coding agents.
- SWE-bench Pro v2: 89.7% — a harder professional variant of the benchmark.
- IFEval: 95.1% — instruction-following accuracy, important for agents that must obey precise formatting and tooling constraints.
- Terminal-Bench 2.1: 54.9% — a terminal-agent benchmark where Flint trails the strongest dense models (dense Qwen 3.8 scores 73.0% here, per MarkTechPost’s comparison).
Two caveats, both important. First: every one of these numbers is company-reported. WIRED was careful to flag that nobody outside Recursive has independently verified them yet, and benchmark setups vary between labs — so independent testing will matter before anyone treats these as settled. Second: the Terminal-Bench result shows where a small active-parameter count bites. Dense models that fire all their parameters per token still win on some agentic tasks; Flint’s bet is that its speed and local-deployment advantage outweigh the gap.
Recursive is also candid that Flint may need clearer instructions than larger closed models for complex jobs — breaking big tasks into smaller steps gets better results. That is a common trait of smaller models and worth knowing before you hand it a sprawling refactor.
Recursive Flint vs the Competition
Recursive Flint lands in a crowded October 2026 field. Here is how it stacks up against the names developers will actually be choosing between:
| Model | Size / type | Runs locally? | Coding strength | Cost |
|---|---|---|---|---|
| Recursive Flint | 40B MoE, 2.5B active | Yes — 48 GB Mac/GPU | 74.2% SWE-bench Verified (company-reported) | Free (Apache 2.0) |
| Meta Muse Spark Open | 816B open weights | Only with ~1 TB RAM | Frontier-class | Free weights, huge hardware bill |
| Google Gemma 4 / Nvidia Nemotron 3.5 Lightning | Similar class, dense | Yes, comparable hardware | Competitive | Free weights |
| GPT-6 Astra (OpenAI, cloud) | Closed frontier | No | Top-tier | API pricing per token |
| GitHub Copilot / Claude Code | Cloud assistants | No | Excellent, polished | Subscription ($10–20+/mo) |
The honest positioning: Recursive Flint does not beat the best closed models on raw coding ability, and it does not try to. It competes on a different axis — speed plus sovereignty. If you want a coding agent that runs offline, keeps proprietary code in-house, costs nothing per token, and responds in seconds on a MacBook Pro, Flint’s combination is genuinely new. If you want the absolute strongest model for the hardest reasoning tasks and do not care about data leaving your machine, the cloud frontier still wins.
For readers choosing between cloud assistants, our best AI coding assistant 2026 roundup compares GitHub Copilot, Cursor, Claude Code, and the rest on price, free tiers, and agent modes — Recursive Flint slots in as the “run it yourself” option that roundup was missing. And if the self-hosting angle appeals to you, our FLUX 3 Image Klein guide covers the same philosophy for image generation: open weights, your hardware, zero per-use fees.

Recursive Flint vs the cloud giants: the trade is raw power for speed, privacy, and zero per-token cost.
How to Run Recursive Flint on Your Laptop
Getting Recursive Flint running is a standard open-model workflow — no waitlist, no API key, no signup:
- Check your hardware. You need a 48 GB Apple Silicon Mac (M4 Pro, M5 Pro, M5 Max) or a 48 GB NVIDIA GPU, plus ~25 GB of free disk space for the quantized weights.
- Pick a runtime. The easiest paths are Ollama or LM Studio (point-and-click model downloads), llama.cpp for the terminal-inclined, or vLLM / SGLang if you are serving it to a team. Recursive’s own “rec” engine is the option tuned specifically for Flint’s custom kernels.
- Download the weights. Grab the Apache 2.0 build from Hugging Face — the 4-bit quantized version is about 23 GB and stays within 0.7 benchmark points of the full model, so it is the one most people want.
- Connect your agent tools. Because Flint speaks OpenAI-compatible tool calls, it drops into most agentic coding setups (CLI agents, IDE extensions, custom harnesses) with a changed endpoint rather than a rewrite.
- Prompt in small steps. Recursive’s own guidance: break complex jobs into smaller instructions. Clear, stepwise prompts get markedly better results than one giant “rebuild my app” request.
One practical note: the model card documents a 262,144-token context window, while Recursive’s blog says up to 512K is supported — but the company recommends staying within 256K for best results. For nearly all real coding sessions, 256K tokens of context is far more than you will use.
What Recursive Flint Is Good At
Recursive Flint is a decoder-only MoE Transformer for coding agents — it was built for agentic loops, not chat. Its strengths cluster around the daily work of software development:
- Bug fixing: the 74.2% SWE-bench Verified score (company-reported) measures exactly this — real GitHub issues, real fixes.
- Feature implementation: writing new code against an existing codebase, with tests.
- Codebase investigation: the huge context window lets it hold large projects in memory while it explores.
- Fast iteration: at 125+ tokens per second, the edit-run-fix loop stays fluid — the reporter who tested it called out speed as the standout trait.
- Private, offline work: proprietary code, client projects, and air-gapped environments where cloud APIs are off the table.

Bug fixes, features, and tests — Recursive Flint was built for the agentic coding loop.
Where Recursive Flint Falls Short
No launch-day article should skip the limits, and Recursive Flint has real ones:
- Benchmarks are unverified. Every performance number comes from Recursive itself. Independent labs have not re-run them yet.
- Terminal-Bench lags dense rivals. At 54.9% on Terminal-Bench 2.1 versus 73.0% for dense Qwen 3.8, terminal-heavy agent work is a relative weakness.
- Needs clearer prompting. Recursive admits Flint may require more explicit instructions than larger closed models — plan on stepwise prompts for complex jobs.
- Text only. No image input, so no screenshot-based debugging or UI work from mockups.
- 48 GB memory floor. Most consumer laptops cannot run it — this is a pro-developer machine requirement.
- The self-improvement story is unproven. Flint is a snapshot product of the Eureka Machine, not evidence the machine is getting smarter each run.
Who Should Use Recursive Flint?
Recursive Flint is for you if: you code on a 48 GB Mac or a beefy NVIDIA workstation; you want a coding agent that works offline or on proprietary code; you are tired of per-token API bills; you like tinkering with open weights; or you want to experiment with agentic coding loops without committing to a cloud vendor.
Skip it (for now) if: your machine has 16–24 GB of RAM; you need image understanding; you want the strongest available reasoning on hard problems regardless of cost; or you prefer a polished, managed product over a self-hosted setup. In that last case, the cloud assistants in our coding assistant roundup are the better fit — and Meta’s Muse Spark Open is the alternative if you have datacenter-scale hardware and want maximum open-weight capability.
Recursive Flint FAQs
Is Recursive Flint free?
Yes. Recursive Flint is released under the Apache 2.0 license with weights on Hugging Face, so the model itself is free to download, use, and build on — including commercially. Your only cost is the hardware to run it.
Can Recursive Flint run on my MacBook?
Only if it has 48 GB of unified memory — that means an M4 Pro, M5 Pro, or M5 Max configuration. Base-model MacBooks with 16–24 GB cannot run it. The 4-bit quantized build needs about 23 GB of disk space.
How fast is Recursive Flint compared to other local models?
Recursive reports 125+ tokens per second on an M4 Pro MacBook Pro and 150+ on an NVIDIA RTX Spark — described as up to twice as fast as comparable models, with TechCrunch-cited tests showing ~131 tok/s versus 58–69 for Google’s Gemma 4 and Nvidia’s Nemotron 3.5 Lightning. These are company-reported figures.
Was Recursive Flint really built by AI?
Partially. Recursive says its Eureka Machine — an automated research system — helped build nearly every part of the stack, from architecture to quantization to inference kernels, over a sub-four-month build. Humans were in the loop throughout, and the self-improvement claims remain unproven.
How does Recursive Flint compare to GPT-6 for coding?
On raw ability, closed frontier models like GPT-6 Astra remain stronger, especially on hard reasoning. Recursive Flint’s advantage is different: it runs locally at high speed, costs nothing per token, keeps your code private, and works offline. Choose based on whether you value peak intelligence or speed plus sovereignty.
Does Recursive Flint work with my existing coding tools?
Likely yes. It supports OpenAI-compatible tool calls and runs on standard runtimes (Ollama, LM Studio, llama.cpp, vLLM, SGLang), so it integrates with most agentic coding setups by changing the model endpoint.
The Bottom Line
Recursive Flint is the most interesting open-weight release of the month for a simple reason: it is not just a model, it is a demonstration. A 40-billion-parameter mixture-of-experts coder that runs at 125+ tokens per second on a MacBook Pro, free under Apache 2.0, with a 74.2% SWE-bench Verified score — built in under four months with an AI research system doing much of the heavy lifting.
The honest version: the benchmarks need independent verification, the Terminal-Bench gap is real, and the “AI building AI” narrative is ahead of its proof. But the artifact is real, downloadable today, and genuinely useful for developers with the hardware. If you have a 48 GB machine and write code for a living, Recursive Flint is worth an evening of experimentation — and if the Eureka Machine’s trajectory is real, this is the least interesting thing it will ever build.
Sources: Recursive launch announcement via MarkTechPost; teckhustlers.com hands-on summary; WIRED reporting on the Eureka Machine (via startupfortune.com); oossa.com launch brief. Benchmark and speed figures are company-reported unless noted.
