Ripple-65B Preview: A Small Dense Open-Weight Model Claims 80.5 on Terminal-Bench 2.1

Ricursive Intelligence has released Ripple-65B Preview, an Apache 2.0 open-weight model that its own Hugging Face model card says scores 80.5 on Terminal-Bench 2.1. That would put a 65-billion-parameter dense model ahead of several US open-weight systems that have eight to fifteen times more total parameters. The weights are public. The scores are the company's own and have not been independently reproduced. This post separates what is on the page from what anyone has reproduced.

If you follow open coding models, this sits next to our coverage of Reflection Beam 501B, Meta Muse Spark Open 816B and NVIDIA Nemotron 3 Ultra, the models Ripple is compared with.

TL;DR: claimed vs verified

What did Ricursive release?

The Hugging Face repository ricursiveAI/Ripple-65B-Preview was created on November 4, 2026. A base-model repository appeared on October 14, and quantized and speculative-decoding variants (NVFP4 and DFlash2) followed the same day as the main release. The tags list safetensors, custom code and the Apache 2.0 license. The weights total about 129.6 GB in BF16, matching 64.78 billion parameters.

The model card calls Ripple "a 65B parameter dense Transformer model pretrained on 12 trillion tokens with support for up to 1M context length." It describes a "Preview" with "relatively light posttraining, with a focus on agentic coding." Post-training stages listed are midtraining, long-context training, SFT, long-context SFT and mixed-domain RL, with 700 RL steps at 128K sequence length.

Ricursive says, in its launch post, that it started from the model ladder of Ai2's Olmo 3 and then changed the recipe. Its claim is a 16x compute-efficiency gain on code over the Olmo 3 ladder, rising to 55x for the full run. That is a claim about its own scaling ladder, not a comparison anyone else ran.

How is it built?

The card gives unusual detail for a first release:

• Dense, not MoE. Ricursive says it chose a modernized dense Transformer "rather than use Mixture-of-Experts (MoE) like other labs" to cut infrastructure complexity.
• Small team. The card says the team grew from 1 to 5 people during development, with about 40% MFU, simple sharding, no custom kernels and BF16 throughout.
• Thin and deep. 80 layers with a narrow d_model of 5120, and a switch from a Llama-like to a Gemma 3N-like architecture for training stability.
• Attention tweaks. More attention heads, a higher ratio of sliding-window to global layers with smaller windows, FFN activation clipping, gated attention, global NoPE and value residuals.
• Hardware. Co-designed for NVIDIA hardware. Reported speed: 250 tokens per second on 2x B200 at batch 8, before quantization or custom kernels.

For readers who want the dense-versus-MoE trade-off, the practical point is memory and simplicity. A dense 65B model uses all its weights on every token. A 550B MoE with 55B active parameters needs far more memory to hold, though it computes about as much per token. Ripple's size is what makes the local-machine claim plausible.

The benchmark table, with the caveats

Ricursive compares against four US open-weight models. It says all were tested at full BF16 and maximum effort, using official model card scores where available and "our own in-house eval flow for missing evals." Here are selected rows from its table, all from the Ripple model card:

Three things stand out when you read the full card rather than the headline.

First, Ripple leads on Terminal-Bench 2.1 but not everywhere. Muse Spark Open scores higher on DeepSWE 1.1 and MCP Atlas, Beam is higher on SWE-bench Verified and Pro v1.0, and the larger models lead on knowledge tests such as MMLU-Pro and GPQA Diamond. A "beats models 10x its size" line is true for some rows only.

Second, the card itself flags that harnesses matter. It says Terminal-Bench 2.1 scores "were universally lower (with the exception of Muse Spark Open)" under the official Terminus 2 harness at 128K with summarization, and calls its results "a best-effort attempt at a fair comparison." Some very low rival numbers, such as 0.2 for Nemotron and 1.8 for Inkling on DeepSWE 1.1, may reflect harness mismatch rather than ability. We cannot tell from the card.

Third, italicised cells are Ricursive's own runs. The table text we read does not mark which cells those are, so a reader cannot separate official scores from in-house ones without opening each rival's model card.

How does it compare with DeepSeek V4 Flash?

The card's own base-model table is the fairest place to check. It says the base "is comparable with DeepSeek V3.1 and V4 Flash on reasoning, math, and code," but on several knowledge rows V4 Flash is ahead, for example MMLU-Pro at 68.3 versus Ripple's 61.5. Our DeepSeek V4 Flash coverage has the background on that model. We found no independent write-ups of Ripple when we checked, so the card is the only source for these numbers.

The base model is a fairer test of the pretraining recipe. Ricursive says it kept pretraining data "clean with minimal synthetic data." On that table Ripple trails the 550B Nemotron on knowledge, which the card attributes to Nemotron's task-seeded synthetic data. That explanation is Ricursive's, and it is untested.

How to try it

The card points to Hugging Face for weights and a Colab for the NVFP4 checkpoint. A sketch of loading the BF16 model with Transformers, based on the repo's custom-code tag:

from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "ricursiveAI/Ripple-65B-Preview"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(
    repo, trust_remote_code=True, device_map="auto"
)

Only run trust_remote_code=True after reading the repository's code. The chat template uses ChatML-style tokens and supports tool calls with an execute_bash example. For a laptop-class box, use the NVFP4 checkpoint; our DGX Spark local LLM setup guide covers the hardware the card names.

A good first test is your own harness. Pick five tasks you care about, run them with Ripple and with the model you use now, and compare time to a passing result, not a leaderboard number. The Terminal-Bench method itself is explained in our Terminal-Bench 2.0 guide and harness engineering notes.

Which model for which job?

These picks follow Ricursive's own table, so treat them as a starting hypothesis and test them on your tasks.

Limits and open questions

• Preview status. The company calls post-training light. Expect changes.
• Text only. The pretraining corpus is text-only and predominantly English and code.
• No independent evals yet. We found no third-party reproduction when we wrote this.
• Safety rows. The card reports FORTRESS Adversarial 83.8 and Benign 95.5, and StrongREJECT 97.5. These are self-run too.
• Context. The card says 1M context, while the pretraining sequence length was 8K and the long-context stage ran at 2M for 6.5B tokens. Quality at the far end is unmeasured in what we read.
• Training cost. The model card gives no compute budget or dollar figure, so we do not cite one.

Why it matters

If the Terminal-Bench number holds up, the lesson is that a small team with a tight recipe can match much larger MoE systems on one agent task, at a size that fits local hardware. That matters for builders who want to run coding agents privately. It also matters for the US open-weight race, where our coverage of the Reflection AI answer to DeepSeek and Qwen tracked big-parameter efforts. If the numbers do not hold, it is still a useful Apache 2.0 base model with a documented recipe.

Our verdict for now: try it on your own tasks, and wait for independent runs before you switch a production workflow.

Related reading

• Reflection Beam 501B open weights
• Meta Muse Spark Open 816B: how to run it
• NVIDIA Nemotron 3 Ultra 550B
• Inkling from Thinking Machines: open weights
• Best DGX Spark local LLM setup
• Terminal-Bench 2.0 explained

Details come from the Ripple-65B Preview model card on Hugging Face as of November 4, 2026. All benchmark scores are self-reported by Ricursive Intelligence.