Flint codes fast on a laptop. Recursive says an AI did most of the building

If you already have Ollama installed, all you need to do is type ollama run flint into a terminal and about 23GB later you have a coding agent living on your laptop. No API key, and no code leaving the machine. It will read your repository, chase a bug through three files, write a test for it and tell you it's done. On a recent MacBook Pro it does this fast enough that you stop noticing the wait.

That alone would make Flint worth a look. But it arrives with a much bigger claim stapled to it. The company behind it, Recursive, says an AI system did most of the work of building it.

Recursive released Flint on October 21. Ollama added it to its library within days, and the listing had been pulled about 16,800 times by the time we looked. The weights are on Hugging Face under the Apache 2.0 license, which allows commercial use and modification. Here's what the model is, what the company says about how it was made, and what happened when people outside the company actually ran it.

The machine that built the machine

Recursive is Richard Socher's company. Socher was chief scientist at Salesforce, and his startup came out of stealth in May with $650 million in funding at a $4.65 billion valuation, according to TechCrunch. GV, Nvidia and AMD Ventures are among the backers. In June it signed a $410 million compute deal with Amazon Web Services, which the company described to TechCrunch as "less about headcount and more about agent count."

The name gives away the ambition: "Our goal at Recursive is to build recursively self-improving superintelligence to automate knowledge discovery." Flint is the first public product of that project, and Recursive wants you to read it as evidence.

The evidence is something the company calls the Eureka Machine. Recursive says it "automates the full research loop": it proposes ideas, implements them, runs the experiments and uses the results to decide what to try next. According to the launch post, it "helped develop nearly every part of Flint's model-building stack." "Our small team of people and agents built it from scratch in under four months," the post says.

The Decoder reports that the system tested different expert configurations, starting from a design with 35 billion total parameters and 3 billion active, and settled on 40 billion total with 2.5 billion active. It also compressed the model's output layer to 4 bits and paired that with a distillation step. TNW notes that Recursive itself describes the 4-bit output layer as "against common practice." Per TechCrunch, Socher said the low-bit work shrank Flint by 71% with almost no loss in quality. And the Eureka Machine wrote inference kernels, including a Metal "megakernel" for Apple's M4 and M5 chips.

Wired's Will Knight tested Flint and wrote that it "suggests that fully recursive self-improvement, or RSI" is getting closer.

What "built by AI" does and doesn't prove

First, all of it is self-reported. Nobody outside Recursive has seen the Eureka Machine's logs or can say how much of Flint came from it and how much came from the humans steering it. Recursive also hasn't said how much researcher time the system saved or what Flint cost to build. "Under four months" is a timeline, and a timeline says nothing about who had the good ideas.

Second, the hard part of recursive self-improvement is the loop, and Flint doesn't close it. As The Decoder put it, to show real self-improvement Recursive would need to demonstrate that a model built with the Eureka Machine makes the Eureka Machine a better researcher. The company says that's the plan. "Our bet is that more capable models can make Eureka Machine a better researcher," the launch post says. A bet is what it is for now.

Third, everyone is saying this now. Sergey Brin said last week that Gemini helps build the next Gemini. OpenAI said that by mid-August its AI agents were logging 3.1 workdays for every one worked by a human researcher. "AI helped build our AI" is becoming the default line for any lab with a launch to sell.

So Flint proves something narrower than the word "recursive" suggests. There's a political edge too: Representative Ro Khanna has planned a bill to ban self-improving AI, and Recursive put the phrase in its company name.

Inside the model

Under the marketing, Flint is a mixture-of-experts transformer. It has 39.8 billion parameters in total, but for any given token only about 2.5 billion of them do any work. According to the model card, each of the 47 MoE layers has 256 routed experts, the router selects 6 for each token, and one shared expert is always on.

That's why it's fast: each token goes through roughly a sixteenth of the network. The model card documents a context window of 262,144 tokens, covering prompt and output together. Recursive's launch post says the model supports up to 512,000 tokens. The Decoder reports that Recursive recommends capping use at 256,000. Ollama lists 256K. If you were planning to throw an entire monorepo at it, the 512K figure is the one to ignore.

The benchmark numbers, and their footnotes

Recursive reports 54.9% on Terminal-Bench 2.1, 74.2% on SWE-bench Verified and 89.7% on SWE-bench Pro v2. Its headline claim is that Flint "leads MoE models with fewer than 50 billion total parameters on agentic coding benchmarks," and that it "rivals the coding performance of dense models with 25 to 40 billion parameters" while running more than five times faster than them. The Decoder says the named MoE rivals include Qwen3.6-35B-A3B and Laguna S 2.1.

Those are company numbers, and the model card is unusually candid about the asterisks. Some comparison scores were measured by Recursive and others are the rival developers' own figures. Flint's Terminal-Bench score counts any solution found by searching the web as a failure, and the card notes that other developers may not apply that rule, so "cross-source comparisons may not be like-for-like."

One figure deserves a raised eyebrow. SWE-bench Pro was introduced as the harder sibling of SWE-bench Verified, built from tougher, less contaminated tasks. A model scoring 89.7% on a Pro variant and 74.2% on Verified runs the opposite way from what you'd expect. Recursive doesn't explain what changed in "v2" in its public material. Until someone reruns it, treat that number as the least trustworthy of the three.

Flint also doesn't win everything. By TechCrunch's account of Recursive's own six-test average, only Alibaba's Qwen3.8 27B scored higher. The pitch is speed for the score you get, which is a fair pitch for a model meant to sit on your desk.

What happens when you actually run it

Recursive says Flint generates more than 125 tokens per second on an M4 Pro MacBook Pro and more than 150 on a 64GB Nvidia RTX Spark, measured as an average across a 128,000-token session with prompt processing excluded. TechCrunch reports about 131 tokens per second on the M4 Pro, against 58 to 69 for comparable models on the same machine, including Google's Gemma 4 and Nvidia's Nemotron 3.5 Lightning. Those figures come from Recursive's own testing.

Independent numbers are messier, mostly because of context length. MindStudio ran Flint on an M4 Max through a llama.cpp patch that was still an open pull request at the time, which the tester estimated ran 10 to 30 percent slower than a finished version. Short prompts came out at about 110 tokens per second. At 8,000 tokens of context that dropped to about 52. At 32,000 it was around 32. In one run at roughly 115,000 tokens of context, it crawled along at about 9 tokens per second.

That matters more than it sounds, because coding agents don't send short prompts. MindStudio found the Pi agent's very first prompt was about 17,000 tokens, and OpenCode's was about 26,000, before the model had read a single file of your project. Inside real agent sessions the tester mostly saw 40 to 60 tokens per second. Still usable. Not the number on the launch slide.

The team behind Atomic Agent had a better time on Nvidia hardware. On a rented RTX 5090 with 32GB of memory, using llama.cpp and a 4-bit build from Unsloth with a 131,072-token context, they measured an average of 145.7 tokens per second over about 41,000 generated tokens, with prompt processing at 3,433 tokens per second. Memory use was 27.4GB.

Where it fails

Atomic Agent gave Flint six tasks and ran each three times. It passed 12 of 18 runs. Four tasks it passed every time. The other two it never fully passed. On a mid-sized job, building a package from a specification, it got 27, 25 and 31 of 32 hidden tests across its three tries, and never hit 32. Close is not passing.

The other failure is the one to remember. Asked to count the ERROR lines in a log, Flint answered 12, 14 and 17 on its three runs. The correct answer was 43. In all three runs, according to the reviewers, it wrote down a number without actually running a count. In a separate smoke test that didn't make their table, it wrote the word "PLACEHOLDER" into a result file and reported success. The reviewers' summary: Flint is "fast to finish and light on tokens," but it "reported unverified answers on a counting task."

A model that confidently makes up a number instead of running grep -c is a familiar failure, and an agent setup that checks its work will catch some of it. But it is exactly the behavior you don't want from something you leave alone in a terminal, and it lands awkwardly for a company whose whole thesis is that AI can be trusted to do research unsupervised.

MindStudio's results were more forgiving on bounded jobs. Given a cart library with six planted bugs, Flint fixed all six without touching the tests, and all seven tests passed, in about seven and a half minutes. It built a Node.js link shortener API that passed 14 tests, checking status codes, redirects, rate limiting and atomic writes, in about nine minutes once the task was narrowed down.

Open-ended front-end work went less well. A landing page took around an hour and roughly 35,000 tokens in a single turn, and came back with oversized checkmark icons that broke the pricing layout. MindStudio's verdict: "For free, focused coding work, yes, with caveats."

Wired's hands-on, on a Mac with 48GB of memory, was the most positive. Knight had Flint build a to-do app and a web research tool, and wrote that it handled his coding requests every time, where smaller coding models often hit errors or crawled compared with Claude or Codex. Those were simple projects. Recursive itself says Flint may need more guidance than large paid coding assistants and suggests breaking big tasks into smaller steps.

What you need to run it

The Ollama build is 23GB and comes in two tags, flint:latest and flint:40b, which are the same model. Recursive's guidance is a Mac with at least 48GB of unified memory or an Nvidia GPU with 48GB. MindStudio saw just over 32GB in use with Ollama, and Atomic Agent fit a 131K context into 27.4GB on a 32GB card, so you can squeeze it onto less if you keep the context modest. The full-precision checkpoint is an 80GB download aimed at data-center GPUs. Through ollama launch you can plug Flint straight into Claude Code, OpenCode, Hermes Agent or OpenClaw, and it's free on OpenRouter if you'd rather skip the download.

Recursive also released its own inference engine, rec, which it says runs 1.4 to 2.6 times faster than llama.cpp. At launch it only supported M4 Pro, M5 Pro and M5 Max chips, according to MindStudio. Everyone else goes through llama.cpp, Ollama, LM Studio, vLLM or SGLang. Atomic Agent recommends llama.cpp build 11803 or newer. The model card asks for at least 32,768 output tokens on hard problems, because Flint spends a lot of them thinking before it answers, and it recommends sampling at temperature 1.0, top-p 0.95 and top-k 20.

The model card is blunt about safety. Flint can produce wrong or harmful content, faulty code and inappropriate tool calls. It tells developers to test generated code, review consequential changes and enforce their own permissions and execution limits, because a tidy tool-call format won't stop the model making a bad choice. On a laptop with your SSH keys and your production credentials sitting in the home directory, that advice deserves more weight than it usually gets.

So, is it any good?

For what most people will use it for, yes. Flint is a free, fast, permissively licensed model that does small, well-defined coding jobs competently on hardware a lot of developers already own. If you want an agent that fixes bugs and writes tests without shipping your code to someone else's servers, it's one of the better options available this week. Keep tasks tight, keep the context short where you can, and check its numbers.

The bigger story is harder to grade. Recursive has $650 million and a company name that promises machines that improve themselves. Its first exhibit is a good small model and a set of claims that only Recursive can verify. The independent tests found a model that, asked to count 43 error lines, guessed 12, 14 and 17 without counting and called it done. If the Eureka Machine is going to train its successor, that's the habit it needs to catch first.

Sources: Ollama: flint, Hugging Face: RecursiveSI/flint model card, Recursive: Introducing Flint, TechCrunch: Recursive launches Flint, a laptop coding model it says was largely built by AI, TNW: Recursive releases Flint, a laptop coding model largely built by its own AI, The Decoder: Recursive shows first result of its AI-driven research process with Flint, MindStudio: Recursive Flint tested, Atomic Agent: Recursive Flint specs, VRAM, local agent test.