![Recursive Flint Opens 40B Coding Model at 2.5B Active [2026]](https://shattered.io/wp-content/uploads/2026/10/recursive-flint-40b-moe-coding-model-2026-gen.webp)
Recursive announced Flint on October 21, 2026, an open-weight mixture-of-experts language model built specifically for coding agents, and the launch is already drawing comparisons across the AI press for an unusual reason: the model’s own research system reportedly helped build it. Flint ships under an Apache 2.0 license with weights posted to Hugging Face, and it lands at a moment when the gap between frontier API models and local, downloadable alternatives keeps narrowing. According to MarkTechPost, Flint is a 40B-A2.5B design, meaning roughly 39.8 billion total parameters paired with about 2.5 billion active parameters per token, a ratio meant to keep inference light enough to run on a single workstation while retaining the capacity of a much larger network.
The release matters less for its size, which is modest next to the largest closed models on the market, and more for what it signals about where coding-agent infrastructure is heading. Free access on OpenRouter at launch, a 262K-token context window, and benchmark scores that land in the same conversation as paid frontier tools suggest Recursive is betting that agentic coding workloads, not raw parameter count, are the next battleground. This piece breaks down Flint’s architecture, its reported benchmark results, how it fits against the rest of the open-weight coding field, and why developer demand for AI agents already sets the stage for tools like it.
Don't miss new tech stories on Google
Add Shattered once in the Google app and our stories show up in your news suggestions.
What Is Recursive Flint? #
Recursive Flint is a decoder-only mixture-of-experts transformer purpose-built for coding agents rather than general chat. Recursive designed it around four core jobs: investigating a codebase, fixing bugs, implementing new features, and writing tests, all while supporting the kind of multi-turn reasoning and tool-calling that autonomous coding agents depend on. The model takes text in and produces text out, a deliberately narrow interface that keeps it compatible with the growing stack of agent harnesses, IDE plugins, and command-line tools built around OpenAI-style completion APIs.
What sets Flint apart from a typical startup model drop is distribution. Recursive published the full weights on Hugging Face under an Apache 2.0 license, the same permissive terms used by many of the open models competing for developer mindshare this year. That licensing choice means Flint can be fine-tuned, redistributed, and embedded in commercial products without the royalty or usage restrictions attached to more guarded releases. Combined with free access on OpenRouter at launch, Recursive is lowering the barrier to trying Flint about as far as it goes for a model of this class.
Recursive also chose to ship Flint as a local-capable model, meaning the design target includes running on a single high-end machine rather than requiring a multi-GPU cluster. For developers who have grown wary of sending proprietary codebases to third-party APIs, or who simply want to cut inference costs for high-volume agent loops, a model that can plausibly run on a laptop or a single workstation GPU changes the calculus around where coding-agent workloads get executed.
Inside the 40B-A2.5B Mixture-of-Experts Design #
Flint’s architecture is where the engineering story gets specific. Recursive built it as a 49-layer network: two dense layers followed by 47 mixture-of-experts layers, according to the model details reported by MarkTechPost. That front-loaded dense structure is a common pattern in MoE design, letting the first layers establish stable token representations before routing kicks in across the bulk of the network.
49 Layers, Mostly Mixture-of-Experts
The total parameter count sits at 39.8 billion, rounded in Recursive’s own naming to the 40B-A2.5B designation. That naming convention, now standard across the open-weight MoE field, tells you the total size and the active size in one string: 40 billion total, roughly 2.5 billion active per forward pass. The gap between those two numbers is the entire point of a mixture-of-experts model. Instead of activating every parameter for every token the way a dense model does, Flint routes each token through a small subset of its expert layers, so inference cost tracks closer to a 2.5B model than a 40B one.
2.2B Active Body Plus the Output Head
Breaking the active-parameter figure down further, roughly 2.2 billion of those active parameters belong to the model body, with the remainder coming from the output head that turns the final hidden states into token probabilities. That distinction matters for anyone trying to estimate memory footprint and latency on their own hardware, since the output head’s cost is largely fixed regardless of which experts get routed to on a given token.
This kind of sparse-activation design has become the default approach for any lab trying to ship a capable model that still runs affordably. Nvidia’s own Nemotron 3.5 open model line leans on a similar philosophy of making large total capacity available without forcing every deployment to pay full dense-model inference costs, and Recursive’s Flint slots into that same broader trend of MoE architectures aimed specifically at agentic and coding use cases rather than general-purpose chat.
Eureka Machine: Recursive’s AI Built Its Own Successor #
The detail generating the most attention around Flint’s release is not a benchmark number. It is the claim, reported by Cryptopolitan, that Recursive’s automated research system, which the company calls the Eureka Machine, helped develop Flint. Framed this way, Flint becomes a test case for a question the AI industry has been circling for a while: can an AI research pipeline meaningfully accelerate the design of the next model, rather than just assisting with routine engineering tasks around the edges?
Recursive has not published a detailed technical breakdown of exactly which parts of Flint’s design, training, or evaluation process the Eureka Machine touched, and specifics beyond the company’s own framing should be treated as reported rather than independently confirmed. But the framing itself is notable. If a small lab can point to an internal automated system as a contributor to a model that scores competitively on agentic coding benchmarks, it adds weight to the argument that AI-assisted AI research is shifting from a research-lab curiosity to a production practice that smaller players can use to compete with far better-funded labs.
That argument lines up with Recursive’s broader pitch, described by Cryptopolitan as testing “lab economics,” the idea that smaller teams using AI-accelerated research tools might be able to close the resource gap against labs with vastly larger budgets. Whether that thesis holds up over multiple model generations is an open question, but Flint is the first concrete data point Recursive has put in front of the public.
Benchmark Numbers: Terminal-Bench, SWE-bench Pro, and SWE-bench Verified #
Recursive reported three headline evaluation scores for Flint, each targeting a different dimension of coding-agent competence. On Terminal-Bench 2.1, a benchmark that tests a model’s ability to complete real command-line and terminal-based tasks, Flint scored 54.9%. On SWE-bench Pro v2, which evaluates agents on harder, more realistic software engineering tasks drawn from real repositories, Flint reached 89.7%. On SWE-bench Verified, the human-validated subset of the original SWE-bench suite that has become something of an industry standard for measuring whether a model can actually resolve GitHub issues end to end, Flint scored 74.2%.
Those three numbers, as reported by MarkTechPost, tell slightly different stories depending on which one you weight most heavily. The SWE-bench Pro v2 score is the standout figure, and if it holds up under independent testing, it would put Flint’s agentic coding performance in a range that a 2.5B-active-parameter model has no obvious business reaching. The SWE-bench Verified score of 74.2% is the more conservative, better-established number in the set, and it lands Flint in a competitive tier among openly available coding models without claiming to leapfrog the frontier.
It is worth being precise about what these numbers do and do not confirm. They are self-reported figures from Recursive’s own announcement, relayed by MarkTechPost’s testing coverage. Independent, third-party reproduction of these exact scores was not available at the time of this report, which is standard for a model released within the last 24 hours. Readers evaluating Flint for production use should treat the figures as a strong initial signal rather than a settled, cross-validated result.
A 262K-Token Context Window for Agent Workflows #
Flint ships with a 262,000-token context window, a figure that matters more for coding agents than it might for a general chatbot. Agentic coding workflows tend to be context-hungry: an agent investigating a bug may need to load multiple files, prior conversation turns, tool outputs, and test results into a single context before it can propose a fix. A context window in the 262K range gives Flint enough room to hold a meaningful slice of a mid-sized repository alongside the agent’s own reasoning trace, without needing aggressive chunking or retrieval tricks to compensate for a shorter window.
Context length has become one of the quieter arms races in the coding-model space precisely because agent loops amplify the cost of getting it wrong. A model that forgets earlier tool outputs or loses track of a file it edited three turns ago tends to loop, repeat failed fixes, or hallucinate state that no longer exists. Pairing a 262K context window with the kind of multi-turn tool-use training Recursive built into Flint is a direct response to that failure mode, even if the real-world effectiveness of any given context length depends heavily on how well the model actually uses the tokens it is given, not just how many it can technically accept.
Free on OpenRouter: the Pricing Play #
Recursive made Flint free to use at launch on OpenRouter, the model-routing marketplace that has become a common entry point for developers experimenting with new open-weight releases before committing to local deployment. That pricing decision is a growth play more than a long-term economic model. Free access removes the friction of evaluating a brand-new model against an existing agent harness, and it is the fastest way for a small lab to generate usage data, bug reports, and community fine-tunes in the days immediately following a release.
It also puts immediate pressure on the economics of the coding-agent tooling market more broadly. When a model with SWE-bench Verified scores in the mid-70s is available at no cost through a mainstream router, teams running high-volume agent loops, the kind that call a model dozens or hundreds of times to complete a single complex task, have a very visible incentive to at least benchmark Flint against whatever paid API they are currently using. Price has already become a central axis of competition among coding-focused models this year, and a free, open-weight entrant with credible benchmark numbers adds a new data point to that comparison.
Flint by the Numbers #
The table below summarizes Flint’s confirmed specifications and reported benchmark scores as disclosed in Recursive’s announcement and relayed by MarkTechPost and TokenPost.
| Specification | Reported Value |
|---|---|
| Total parameters | 39.8 billion |
| Model designation | 40B-A2.5B |
| Active parameters per token | ~2.5 billion (incl. output head) |
| Active model body | ~2.2 billion parameters |
| Total layers | 49 (2 dense + 47 MoE) |
| Context length | 262,000 tokens |
| License | Apache 2.0 |
| Launch price (OpenRouter) | Free at launch |
| Terminal-Bench 2.1 score | 54.9% |
| SWE-bench Pro v2 score | 89.7% |
| SWE-bench Verified score | 74.2% |
| Release date | October 21, 2026 |
Where Flint Fits Among Open-Weight Coding Models #
Flint enters a field that has gotten crowded fast. Open-weight coding models have multiplied over the past year as labs ranging from well-funded incumbents to small research-focused startups push releases aimed squarely at the agentic coding niche rather than general chat. MarkTechPost’s coverage of the launch placed Flint in direct comparison against other open coding models currently competing for the same developer attention, underscoring that the open-weight coding category now has enough entrants that head-to-head testing against peer models, not just against closed frontier APIs, is becoming standard practice for any new release.
That crowding is itself a signal. A year ago, a 40-billion-parameter MoE model with a sub-3-billion active footprint and SWE-bench Verified scores in the 70s would have been a standalone headline. Today it is one entrant in an increasingly specific sub-category: open, local-capable, agent-first coding models competing less on raw benchmark supremacy and more on cost, context length, and how well they integrate with the tool-calling conventions that agent harnesses expect. DeepSeek’s push into open-source inference tooling and Recursive’s Flint both reflect the same underlying pressure: labs that can’t out-spend the largest players on raw compute are competing instead on efficiency, licensing terms, and how cheaply their models can be run by everyday developers.
For teams evaluating Flint against that backdrop, the practical question is less “is this the best coding model available” and more “does this specific MoE efficiency and context-length combination fit my agent’s workload better than what I’m already running.” That is a narrower, more useful question, and it is the one Recursive appears to be optimizing for with Flint’s design choices.
Developer Demand for AI Coding Agents Is Already High #
Flint’s bet on agent-first design does not happen in a vacuum. It lands into a developer population that has already shifted heavily toward AI-assisted coding. According to the 2025 Stack Overflow Developer Survey, 84% of developers now use or plan to use AI tools in their development process, and 51% of professional developers report using AI tools daily. That level of baseline adoption is the backdrop against which any new coding model, including Flint, gets evaluated: the question is no longer whether developers will try an AI tool, but which one earns a permanent spot in their workflow.
Agent-specific adoption, the category Flint is built for, is further behind general AI tool use but growing from a real base. The same Stack Overflow survey found that 31% of developers currently use AI agents, according to Stack Overflow’s own analysis of the results, while 37.9% of developers say they do not use AI agents and do not plan to. That split points to a market still being actively won or lost, not one that has already settled into a stable pattern, which is exactly the kind of environment where a free, capable new entrant like Flint can shift behavior quickly.
Trust remains the more stubborn variable. Stack Overflow also reported that only 29% of technologists trust the accuracy of the AI tools they use, a figure that has stayed persistently low even as raw adoption climbs. That gap between usage and trust is the real test Flint’s benchmark numbers will face in practice: a 74.2% SWE-bench Verified score is impressive on paper, but it still means roughly one in four agentic tasks fails, and developers who have already internalized skepticism about AI accuracy will be watching closely for how Flint handles the failure cases, not just the successes.
| Developer AI Adoption Metric | Figure | Source |
|---|---|---|
| Developers using or planning to use AI tools | 84% | Stack Overflow 2025 Developer Survey |
| Professional developers using AI tools daily | 51% | Stack Overflow 2025 Developer Survey |
| Developers currently using AI agents | 31% | Stack Overflow 2025 Developer Survey |
| Developers who do not use and do not plan to use AI agents | 37.9% | Stack Overflow 2025 Developer Survey |
| Technologists who trust the accuracy of their AI tools | 29% | Stack Overflow 2025 Developer Survey |
Market Impact: Pressure on Anthropic, OpenAI, and Cursor #
Every free, high-performing open-weight coding model shifts the pricing conversation for the paid tools built on top of closed APIs. Coding assistants and agent platforms that charge subscription or usage-based fees have spent the past year justifying those prices on the basis of benchmark performance and reliability. A model like Flint, scoring competitively on SWE-bench while costing nothing to call through OpenRouter at launch, narrows the gap those platforms need to defend.
The pressure is not evenly distributed. Platforms that route between multiple model backends, rather than committing exclusively to one lab’s API, are well positioned to simply add Flint as another option and let cost-sensitive users route to it for lower-stakes tasks. Platforms built tightly around a single proprietary model have less room to maneuver, since adding a competitor’s open-weight model into their stack would undercut their own pricing story. GitHub Copilot’s recent consolidation around a smaller set of backend models is one example of how the major platforms are already managing this tension, trimming options rather than expanding them, even as the open-weight side of the market keeps adding new free entrants.
For code review and quality-assurance tooling specifically, a cheap, capable coding model changes the cost structure of running automated review passes at scale. Automated code review tools have already been competing heavily on both accuracy and cost this year, and a free model with an 89.7% score on SWE-bench Pro v2, even with the caveat that this figure comes from Recursive’s own reporting, gives smaller teams and individual developers a lower-cost option for running agentic review and bug-fixing passes that previously required a paid API subscription.
Historical Context: From Closed APIs to Open Local Agents #
The coding-model landscape has moved through a few distinct phases in a short span of time. Early code-focused LLMs were largely closed, API-only products, where developers had no visibility into model weights and no option to run inference locally. That started to shift as open-weight releases proved they could reach competitive benchmark scores, first in general-purpose chat and reasoning tasks, and more recently in the narrower, harder domain of agentic software engineering, where a model has to use tools, read error messages, and iterate across many turns rather than just produce a single correct answer.
Mixture-of-experts architectures were the mechanism that made this shift practical rather than theoretical. Dense models scaled to tens of billions of parameters became too expensive to run locally for most developers, even as their capabilities improved. MoE designs broke that tradeoff by decoupling total capacity from active inference cost, which is exactly the lineage Flint sits in: a model large enough to encode broad coding knowledge across its 39.8 billion total parameters, but cheap enough at inference time, with only about 2.5 billion parameters active per token, to run on hardware a single developer might already own.
What makes Flint’s release notable within that longer arc is the Eureka Machine claim. If AI-assisted research tooling genuinely contributed to Flint’s design, it marks a point where the MoE-for-local-agents trend and the AI-building-AI trend start to intersect in a shipped, publicly available product rather than staying confined to internal lab experiments.
What’s Still Unverified About Flint’s Performance Claims #
Not every claim circulating about Flint since its release has the same level of confirmation behind it. Social media and secondary coverage have floated a figure suggesting Flint can exceed 125 tokens per second on an Apple M4 Pro MacBook Pro, but that specific throughput claim traces back to third-party or social-media reporting rather than official material from Recursive or the model’s own card on Hugging Face. Readers should treat that number as unverified rather than as an official spec.
Broader hardware-compatibility claims are in a similar spot. Reports circulating in secondary coverage have suggested Flint works well across Apple Silicon, NVIDIA RTX systems, and common local-inference tools such as llama.cpp, Ollama, LM Studio, or vLLM, but none of those specific compatibility claims were clearly established in the official sources reviewed for this report. Given that Flint’s weights are published openly on Hugging Face under Apache 2.0, broad community compatibility work across those tools is plausible and likely already underway, but confirming exact performance on any specific hardware and runtime combination will take independent testing over the days and weeks following the release, not the first 24 hours.
What Comes Next: Five Predictions #
- Independent benchmark reproductions of Flint’s SWE-bench Pro v2 and SWE-bench Verified scores will surface within the next one to two weeks, and the gap between those reproductions and Recursive’s own reported figures will become the first real test of the model’s credibility.
- Community quantization and fine-tuning efforts will move quickly given the Apache 2.0 license, producing smaller or specialized Flint variants aimed at specific languages or frameworks within the first month after release.
- At least one major agent-tooling platform that routes between multiple model backends will add Flint as a selectable option for cost-sensitive users before the end of the year.
- Scrutiny of the Eureka Machine’s actual role in Flint’s development will increase, with the AI research community pushing Recursive for more technical detail on what the automated research system specifically contributed.
- Rival labs building open-weight coding models will respond with their own efficiency-focused releases emphasizing low active-parameter counts and free or heavily discounted initial access, continuing the pattern already visible across the open-weight coding field this year.
Frequently Asked Questions #
What is Recursive Flint?
Recursive Flint is an open-weight mixture-of-experts language model released by Recursive on October 21, 2026, designed specifically for coding agents. It handles codebase investigation, bug fixing, feature implementation, test writing, and multi-turn tool use, with weights published on Hugging Face under an Apache 2.0 license.
How many parameters does Flint have?
Flint has 39.8 billion total parameters, rounded to the 40B-A2.5B designation. Of those, only about 2.5 billion are active per token, including the output head, with roughly 2.2 billion active parameters in the model body itself.
Is Recursive Flint free to use?
Yes. Flint launched as free to use on OpenRouter. The model weights are also freely available on Hugging Face under the Apache 2.0 license, which permits commercial use, modification, and redistribution.
What is the Eureka Machine?
The Eureka Machine is described in reporting on Flint’s release as Recursive’s automated research system, which reportedly helped develop the Flint model. Recursive has not published a full technical breakdown of exactly what the system contributed, so specifics beyond this framing should be treated as reported rather than independently confirmed.
How does Flint perform on coding benchmarks?
Recursive reported a 54.9% score on Terminal-Bench 2.1, an 89.7% score on SWE-bench Pro v2, and a 74.2% score on SWE-bench Verified. These are self-reported figures relayed through MarkTechPost’s coverage; independent third-party reproduction was not available at the time of this report.
What context length does Flint support?
Flint supports a context window of 262,000 tokens, which gives coding agents enough room to hold multiple files, prior conversation turns, and tool outputs in a single context during multi-step tasks.
Can Flint run on a laptop?
Flint’s low active-parameter count, around 2.5 billion per token despite its 39.8 billion total size, is designed to make local inference on a single workstation or high-end laptop more feasible than it would be for a comparably sized dense model. Specific throughput claims on particular hardware, such as figures circulating for Apple Silicon devices, remain unverified pending official benchmarks from Recursive.
How does Flint compare to other open-weight coding models?
Flint enters an increasingly crowded field of open-weight models built for agentic coding tasks. Coverage of the release from MarkTechPost placed Flint in direct comparison against other current open coding models, reflecting a market where new entrants increasingly compete on efficiency, context length, and licensing terms rather than on raw parameter count alone.