A 65B Model Outscores a 501B Rival: Ricursive's Open-Weight Ripple-65B Preview Sets a New U.S. Bar for Agentic Coding

A 65-billion-parameter model just beat a 501-billion-parameter rival on a terminal-based agentic coding test. On November 4, Ricursive Intelligence — a chip-design lab founded less than a year ago — released its first public model, Ripple-65B Preview: a 65B dense Transformer, pretrained from scratch, open under Apache 2.0, scoring 80.52 on Terminal-Bench 2.1. The launch blog's headline is blunt: a new U.S. open-weight state of the art in agentic coding.

The number matters because it challenges two default assumptions of the last year of open-model discourse: that good models must keep getting bigger, and that they must keep getting more expensive. Ripple defies both — one-eighth the parameters of its nearest rival, and a total R&D bill of $32 million. The figures deserve discounting, and this article will do that carefully. But even after discounting, this is the most consequential open-model release of November so far.

The numbers first: 65B beats 501B

Ricursive's official model card reports 80.52 on Terminal-Bench 2.1. Terminal-Bench does not test multiple-choice questions; it asks a model to complete real programming jobs inside a terminal — installing dependencies, editing code, running tests, fixing errors — with no human in the loop. For coding agents, it is one of the closest public proxies for real work.

The comparison table is the eye-catching part. In the same table, Reflection's Beam 501B scores 80.1, Meta's Muse Spark Open 816B scores 76.4, Thinking Machines' Inkling 975B scores 63.8, and NVIDIA's Nemotron 3 Ultra 550B scores 56.4. Ripple leads the field with 65B parameters — 436B fewer than the runner-up and 485B fewer than the last-placed model. The launch blog stresses that this is a dense model, not a mixture of experts: 65B parameters means 65B active on every token, with no "large total, small active" accounting trick.

One detail is worth noting. The model card carries two rows for Terminal-Bench 2.1: the self-reported row at 80.5, and a row run under the official Terminus 2 harness, also at 80.5. Ricursive states openly in the card that switching to the official harness lowered scores for nearly every model (Muse Spark Open excepted) and describes its comparison as a best-effort attempt at fairness. Saying the awkward methodological part up front makes the headline number more credible, not less.

What Ripple actually is

Ripple-65B Preview is a 65B-parameter dense Transformer, pretrained from scratch on 12 trillion tokens of predominantly English and code text, with context support up to 1M tokens (1,048,576). It is not a chip-design model. Ricursive describes it as a general-purpose variant of the proprietary model that powers its AI chip-design platform, now released publicly.

The release ships in three forms: an instruction-tuned model in BF16, an NVFP4 checkpoint for local deployment on limited memory, and a BF16 base model. The license is Apache 2.0 — free to download, use commercially, and build on. The weights are on Hugging Face, and hosted APIs are live on Together AI, GMI Cloud, OpenRouter, and Fireworks. The blog makes a pointed local-deployment claim: at 65B, the model fits on an NVIDIA DGX Spark desktop machine. The target is not a datacenter-only giant, but a box on a developer's desk.

There is a speed figure too: 250 tokens per second on 2xB200 GPUs at batch size 8, before quantization or custom kernels. That figure comes from the official model card and has not been independently verified — noted here, to be checked later.

How $32 million was enough

The most headline-grabbing number in the release may not be 80.52 but $32 million. Ricursive says that is the full R&D cost from scratch — pretraining ladder development, data mixing, evals, debugging, synthetic data generation, post-training recipe development, and the final hero pretraining and post-training runs. The blog calls it roughly one-tenth the cost of the previous open-weight state of the art on agentic coding. The footnote gives the basis for the estimate: Reflection was reported to commit $150 million per month for compute at SpaceX's Colossus, and Beam reportedly took four weeks to pretrain and four weeks to post-train.

The "one-tenth" claim should be treated as an estimate, not an audited financial statement: the denominator comes from press reporting, not from the rival's books. But the cost structure itself contains several points that are genuinely useful for practitioners.

First, the laddering methodology. The team started from AI2's Olmo 3 ladder and tested each change at small scale for its effect on coding ability, working through versions v1.0 to v1.6: v1.0 adopted StepFun's batch-size and learning-rate scaling laws; v1.1 introduced their own ladder that smoothly scales architectural dimensions and depth; v1.2 switched from a post-norm baseline to pre+post norm; v1.3 added sigmoid gated attention; v1.4 tried a two-stream mHC architecture that worked at small scale but failed to improve at 4B and was rejected; v1.5 switched to global NoPE and added a final learning-rate cooldown to zero; v1.6 added value residuals. The final version switched to a custom pretraining dataset with substantially upsampled code. The official claim is that this ladder improved compute efficiency on code by 16x at 4B scale, growing to a 55x advantage for the full hero run. In other words, the same code capability for one-sixteenth of the compute of the Olmo 3 route.

Second, restraint in post-training. The team bought no post-training data at all, relying on its own synthetic data pipelines, quality filtering, and coverage metrics. The reinforcement-learning stage used only 1.4 million rollouts — the blog says roughly 70x fewer than Reflection Beam — to climb steeply from a strong SFT checkpoint to 80.5. The other side of spending less is "light post-training": the model card states the Preview went through relatively light post-training, focused on agentic coding, so general-purpose ability was not the main target.

Third, architecture choices made for efficiency. A thin-and-deep design: a narrow d_model of 5120, but 80 layers deep; overprovisioned attention heads, with a higher sliding-window-to-global layer ratio and a smaller window to compensate for the cost; plus FFN activation clipping, gated attention, global NoPE, and value residuals. Training held a solid 40% MFU (model FLOPs utilization) throughout pretraining and post-training, with simple sharding, no custom kernels, and no quantization in BF16. The team itself was strikingly small: it grew from one person to five over the course of development.

Read the table sideways: where it wins, where it loses

Terminal-Bench 2.1 alone suggests a clean sweep. Reading the full model card sideways tells a more complicated — and more honest — story.

On coding and agentic tasks, Ripple is genuinely strong. SWE-bench Pro v2.0 Hard comes in at 79.1, the best score in the table, ahead of Beam's 76.5 and Muse Spark Open's 72.4. But SWE-bench Verified is 76.5, below Beam's 81.6 and Muse Spark Open's 78.7 — third place. On the hardest tier of real software-engineering tasks it leads; on the standard verification set it is merely above average.

On general knowledge and reasoning, the weaknesses are clear. MMLU at 89.6, MMLU-Pro at 84.2, and GPQA Diamond at 85.2 all trail the rivals in the same table. DeepSWE 1.1 is just 44.3, far behind Muse Spark Open's 60.0. SciCode at 39.4 is also near the bottom. Math is the bright spot: AIME 2025 at 98.3, AIME 2026 at 95.0, and HMMT February 2026 at 90.5 all sit in the top tier. Instruction following (IFBench, 79.2) is mid-pack, and safety scores — FORTRESS adversarial at 83.8, StrongREJECT at 97.5 — are respectable without leading.

There is also a footnote that is easy to miss: only some scores are the official published figures from each lab's own model card. Missing evals were filled in by Ricursive using its own in-house evaluation flow (marked in italics in the table). The comparison baseline is therefore not fully uniform — some rival scores were measured by Ricursive itself. The model card says so, but readers will glide past it. The fair conclusion: Ripple has a genuinely competitive result in agentic coding, above all on the hardest SWE-bench Pro v2.0 Hard tier — but it is not an all-round champion, and it lags clearly on general knowledge, scientific code, and some agentic tasks.

Who is Ricursive?

Ricursive Intelligence is an AI lab that builds AI for chip design, founded in late 2025. Its founders, Anna Goldie and Azalia Mirhoseini, are the researchers behind AlphaChip, Google's tool for laying out chip floorplans with reinforcement learning. The model released this week is, in essence, a byproduct of its chip-design platform: the team first trained a model for its own platform, found it was also strong at general programming, and released a general-purpose variant.

That background explains two features of Ripple: why the architecture work is organized around training and serving efficiency on NVIDIA hardware, and why the team frames its long-term story as "closing the loop between models and the hardware that fuels them." According to TechCrunch's reporting, the company raised $335 million at a $4 billion valuation within four months earlier this year — a small headcount with deep funding, which is how a five-person team could attempt this at all. That fundraising figure comes from press reporting and has not been confirmed officially, so read it with a discount.

The timing also matters. Ripple landed the day after Thinking Machines released Inkling 2 Small, in the same week Cognition released SWE-2 Flash, with open models from Chinese labs arriving in the same window. The first week of November became a concentrated release window for open and semi-open coding models. Ripple's position in that window is "smallest, cheapest, strongest on one benchmark" — a clever piece of differentiation.

How developers can use it now

The most direct path is Hugging Face: the weights are a free download, and Apache 2.0 permits commercial use. For those who would rather not self-host, Together AI, GMI Cloud, OpenRouter, and Fireworks all serve it through APIs. Third-party coverage reports Together AI pricing at $0.20 per million input tokens and $0.60 per million output tokens — if accurate, an order of magnitude cheaper than comparable closed models, but treat the price as reported rather than verified and check the provider's own page before relying on it.

Local deployment is the other route worth trying. The NVFP4 checkpoint brings memory needs down to roughly 57GB, while the full BF16 weights run to about 130GB, according to third-party checks of the Hugging Face file listings — the former already fits high-end consumer multi-GPU setups or a DGX Spark desktop box. For anyone who wants a capable local coding agent without sending code to the cloud, this is one of the few options right now that is both strong on the benchmarks and small enough to run locally. One caution: 1M context is the card's advertised ceiling, and hosted providers may expose far less of it — third-party reporting notes OpenRouter currently lists around 16K. Check the channel you actually use.

One more warning: the word Preview in the name is not decoration. The model card states explicitly that post-training was relatively light and focused on agentic coding. General chat and long-form writing were not the optimization target. Used as a general chat model, it will probably underwhelm next to general-purpose models at the same scale; used as the base for a coding agent, it is being used as designed.

Why now: the November window for open coding models

Ripple did not appear in isolation. Thinking Machines released Inkling 2 Small the day before; Cognition released SWE-2 Flash the same week; open models from Chinese labs arrived in the same stretch. The first week of November has become a roll call for programming models worldwide.

The window is not an accident. Agentic coding has moved from the demonstration phase — "can it write code?" — into a contest over "can it keep working in a real repository?" The benchmarks have moved with it: Terminal-Bench and SWE-bench Pro, which require a model to complete multi-step tasks in a terminal on its own, have replaced older tests of single-function completion. Whoever posts a strong score on the new yardsticks gets a seat at the next round of toolchain decisions. Ripple timed its release for that selection window: before the model is fully mature and before the slots are taken, plant a first-place finish on the board.

The other backdrop is cost anxiety. For two years, a frontier training bill has run into the hundreds of millions of dollars, affordable only to a handful of giants. If Ripple's $32 million holds up — even partially — it changes the arithmetic for many smaller teams: instead of waiting to rent someone else's large model, train a good-enough small one yourself, following a published recipe. The open-source community's reaction already shows it: downloads and discussion on Hugging Face picked up fast after release, and local deployment guides and quantized builds are appearing in the community. For readers of this site, the practical signal is that the coming year will bring more strong coding models that run locally, and the selection criterion will shift from "who is biggest" to "who fits my task and my budget."

What it means for vibe coding

For people who write code with AI every day, Ripple's most direct value is not the score but the choice it creates. A 65B, Apache 2.0 model that is strong at coding and fits on local hardware makes three things cheaper: privacy, because code no longer has to leave your machine to reach a capable model; experimentation, because hosted pricing at a few dimes per million tokens makes running an agent all day affordable; and customization, because open weights can be fine-tuned to your own codebase and conventions instead of forever adapting to a general model.

But a cold shower is in order too: a strong model is not the same as a strong agent. Terminal-Bench measures a model on single tasks in a controlled environment. Real development adds tool use, long-context memory, multi-file collaboration, and test-feedback loops across an entire chain. There is not yet large-scale public evidence for how Ripple performs once wired into toolchains like Cursor or Claude Code. The model card answers "is this base model good?"; it does not answer "how does it run once you bolt the wheels on?" Until the community publishes reproduction reports from real repositories, the prudent stance is to treat it as a new base model worth trying first — not as a signal to switch your main tooling overnight.

There is also a longer-term thread. Ricursive's main business is chip design, and the model is one half of a "software-hardware co-design" strategy. If that strategy works, more small, strong, task-specific open models optimized for particular hardware may follow — models that behave less like general-purpose giants and more like chips: specialized, cheap, and fitted to a job. For independent developers, that may be better news than "yet another general-purpose giant": tools that get cheaper, narrower, and closer to the actual task.

How much to believe: three reservations

First, every benchmark figure comes from Ricursive itself. No independent lab has reproduced the 80.52 yet, and several rival scores were measured by Ricursive in-house. On tests as sensitive to harness, prompting, and sampling parameters as Terminal-Bench, there is real room for scores to move. The ranking only stands once third parties re-run it under the same harness and the community tries it at scale in real repositories.

Second, $32 million and the "one-tenth the cost" claim are estimates, not audited financials. The blog does not itemize whether headcount, compute at market rates, or the sunk cost of failed experiments are included. Read it as "this lab believes it was very efficient," not as "industry costs just fell by 90%."

Third, Ripple's strengths are concentrated, and so are its weaknesses. It proves that a small team with a clever recipe can dethrone giants on a single benchmark; it does not prove that 65B can do everything. The gaps on general knowledge, scientific computing, and some agentic tasks show the ceiling of this approach is still being tested. The Preview suffix leaves room for that — the vendor left it there deliberately.

Even so, the significance of this release is not what it ends but what it demonstrates: while everyone else competed on who has the biggest model and the most compute, a five-person team spent $32 million and 1.4 million RL rollouts to build an open model that ranks first on the hardest coding benchmark. That demonstration matters more than any single score. What to watch next is twofold: whether community reproduction can hold the 80.52, and whether Ricursive can turn "cheap and strong" from a single release into a sustained product line.

Sources: Ricursive Intelligence official launch blog; Ripple-65B Preview model card on Hugging Face. Benchmark scores and cost figures are vendor-reported and have not yet been independently reproduced.