Recursive Just Open-Sourced a 40B Coding Model — Should It Be in Your Agent Stack?

Yesterday, a small lab called Recursive dropped Flint: a 40-billion-parameter coding model with open weights, an Apache 2.0 license, and a launch price of exactly zero on OpenRouter. The benchmarks they reported are the kind that make you raise an eyebrow — SWE-bench Verified at 74.2%, SWE-bench Pro v2 at 89.7%.

And then there's the detail getting all the attention: Recursive says its own AI research system helped build the model. An AI that builds better AIs. It's a great headline. The benchmarks matter more. Let me dig through what we actually know, how to try it today, and what I'd do before trusting it with anything real.

What Flint actually is

Flint is a decoder-only mixture-of-experts transformer, purpose-built for coding agents rather than general chat. Not a chatbot that happens to know Python — it was trained around four jobs: investigating a codebase, fixing bugs, implementing features, and writing tests, with multi-turn reasoning and tool-calling baked in.

The headline numbers (all from Recursive's announcement, relayed via MarkTechPost — more on the caveats in a second):

The naming convention tells you the whole design philosophy: 40B total, 2.5B active. Mixture-of-experts means each token only routes through a small subset of the network, so inference cost tracks closer to a 2.5B model while the network retains 40B of capacity. It's the same playbook the whole open-weight field has converged on — big total capacity, small active footprint, cheap inference.

The benchmark numbers, with honest caveats

Here's where I pump the brakes a little, because this is the part most launch coverage glosses over: these numbers are self-reported. Recursive published them; independent third-party reproductions didn't exist yet at launch. That's normal for a model less than 48 hours old, but it means you should treat these as a strong initial signal, not settled fact.

That said, the three benchmarks measure different things, and it's worth knowing which one to weight:

• SWE-bench Verified (74.2%) — the human-validated subset of the original SWE-bench. The industry-standard "can it actually resolve real GitHub issues end to end" test. This is the number I'd weight most. Mid-70s puts Flint in a genuinely competitive tier among open coding models without claiming to leapfrog the frontier.
• SWE-bench Pro v2 (89.7%) — harder, more realistic tasks drawn from real repos. The standout figure. If it holds up under independent testing, a 2.5B-active model scoring here is... honestly surprising. Watch for reproductions.
• Terminal-Bench 2.1 (54.9%) — command-line and terminal-based tasks. Solid, not spectacular.

My read: the Verified score is the credible anchor, the Pro v2 score is the one to verify. Don't reorder your stack on press-release numbers. Do put it on your benchmark list.

How to try it today (for free)

This is the part I like about this launch. Recursive made the evaluation path about as frictionless as it gets:

Option 1: OpenRouter, zero cost. The model is live right now as recursive/flint-v1.0:free with $0 prompt and completion pricing. OpenRouter speaks the OpenAI-compatible API, so if your agent harness already talks to OpenAI-style endpoints, it's a one-line model swap:

# whatever harness you're using — just point it here
model = "recursive/flint-v1.0:free"
# base_url: https://openrouter.ai/api/v1

262K context means you can throw a real slice of a repo at it — multiple files, tool outputs, test results — without the aggressive chunking smaller-context models force on you.

Option 2: the weights. Apache 2.0 on Hugging Face, so you can fine-tune it, distill it, or run it locally on a single high-end workstation. No API keys, no sending your proprietary codebase to a third party, no per-token meter running while your agent loops 200 times trying to fix a flaky test. For high-volume agent loops, local open weights change the cost math completely.

Free at launch is a growth play, obviously — the price won't stay zero forever. But right now it means you can benchmark Flint against whatever paid API you're currently using for exactly $0.

The "AI built this AI" claim

Okay, the Eureka Machine. Recursive says its automated research system helped develop Flint, and the press is running with "AI builds its own successor" framing.

Here's my honest take: Recursive has not published a detailed breakdown of which parts of Flint's design, training, or evaluation the system actually touched. "Helped develop" could mean anything from "designed the architecture search" to "ran hyperparameter sweeps." Those are very different claims, and we can't distinguish them from what's public.

The origin story is interesting. The benchmark numbers are what matter. A model is not better because an AI helped build it — it's better if it resolves your issues. Judge the artifact, not the mythology.

What I'd actually do

If you're running coding agents in any serious capacity, here's my practical take:

1. Benchmark it on YOUR issues this week. Pull 20-30 real issues from your own repos, run Flint against your current model through the same harness, compare resolution rates. Your codebase is the only benchmark that matters. It costs nothing right now.
2. Don't move production loops yet. Wait for independent reproductions of the SWE-bench numbers — especially that 89.7% on Pro v2. A week or two of community testing will tell you a lot.
3. If you have high-volume agent loops, start planning the local option. The Apache 2.0 weights are the durable part of this launch. Even if the hosted price goes up later, the weights don't expire.
4. Watch the 262K context claim in practice. Long context windows are only as good as the model's ability to actually use the tokens. Agent loops that lose track of earlier tool outputs are the classic failure mode — test multi-turn tool use specifically, not just single-shot code gen.

The bigger picture: the gap between frontier API models and local, downloadable alternatives keeps narrowing, and it's narrowing fastest exactly where developers feel it — agentic coding. Flint isn't the first open coding model and won't be the last, but free-at-launch + Apache 2.0 + credible Verified numbers is a combination worth an afternoon of your time.

A note on how I write these: I haven't run Flint on my own workloads yet — it launched yesterday. Everything above is from Recursive's announcement and launch coverage, with the caveats stated plainly. I'll update this post if the independent reproductions tell a different story.

If this saved you some research time, a ❤️ helps. And I'm curious: what's the heaviest agent workload you'd actually trust to a free, open-weights model — and what would it take to convince you? Drop it in the comments.