Ripple-65B Tested: How Good Is This Dense Open Model?

How good is Ripple-65B at agentic coding and reasoning?

Ripple-65B Preview is strong at agentic coding and uneven elsewhere. Ricursive Intelligence's 65B dense, Apache 2.0 model scores 80.5 on Terminal-Bench 2.1, ahead of several open models with roughly 8x to 15x more total parameters. It trails the strongest of those models on math, safety, knowledge and tool-use benchmarks, though on math it is close and ahead of some of them. In hands-on tests it found a planted bug in a full-stack app, built a physics-style simulation, and wrote a hard Databricks SQL query. Those are single runs, not a benchmark.

What is Ripple-65B?

Ripple-65B Preview comes from Ricursive Intelligence. It is a 65B parameter dense transformer pretrained from scratch on 12 trillion tokens of mostly English text and code. The model card lists support for up to 1M context length. The license is Apache 2.0.

The release includes a BF16 instruction-tuned model, an NVFP4 version, and a BF16 base model. The card says the model can fit on consumer-class hardware such as the NVIDIA DGX Spark. It also reports 250 tokens per second on 2xB200 at batch size 8, before quantization or custom kernels.

How is Ripple-65B built?

The team chose a dense design instead of mixture of experts. Their stated reason was simplicity: a team that grew from one to five people trained it at about 40% MFU with simple sharding, no custom kernels and BF16 throughout.

Key architecture choices from the model card:

• Thin and deep: d_model of 5120 across 80 layers.
• Gemma 3N-style layout instead of the Olmo 3 llama-like layout, for training stability at scale.
• Extra attention heads to help reasoning, offset by more sliding-window layers with a smaller window to control cost.
• Additions: FFN activation clipping, gated attention, global NoPE and value residuals.

The post-training chain runs midtraining, a long-context stage, SFT, long-context SFT, then mixed-domain RL. The card is explicit that this preview got relatively light post-training with a focus on agentic coding. Pretraining data was kept mostly natural. Synthetic data came in during midtraining so the team could iterate on it without blocking pretraining.

What do the published benchmarks show?

The lab compares Ripple against Nemotron 3 Ultra 550B, Inkling 975B, Muse Spark Open 816B and Reflection Beam 501B, all MoE models. Scores below come from the model card. Some competitor numbers are the lab's own in-house runs, and the card itself warns that agentic evals are hard to replicate.

The pattern is clear. Ripple leads on the two terminal and hard-SWE style evals, sits mid-pack on SWE-bench Verified, and trails on tool-use, science coding, safety and long-context retrieval. Math is close but not leading: it scores 98.3 on AIME 2025 against 100.0 for Muse Spark Open.

One more caveat from the card: Terminal-Bench 2.1 scores were generally lower for other models under the official Terminus 2 harness. Even there, Ripple's 80.5 sat above the competitors' listed scores, but harness choice clearly moves numbers.

Can it find a planted bug in a real app?

A reviewer, Fahad Miraza, ran a local Docker-based full-stack app: a retirement calculator covering 20 countries, with a backend, frontend and Redis-style caching. The app ran without errors but produced absurdly low retirement targets. One subtle bug was planted: the withdrawal rate was stored as 4 but used as if it were 0.04, so every target came out 100 times too small.

The goal given to the agent was simply to find and fix the bug. Ripple, driven through the Hermes agent, located it without hints. After a hard refresh, the US, UK and Poland figures looked plausible. The reviewer also noted that the reasoning trace was reasonably efficient and did not burn tokens on long detours.

This is a classic "plausible-looking wrong output" bug. It needs the model to trace a value across layers rather than spot a crash. One pass is not statistically meaningful, but it matches the model's agentic positioning.

How hard is it to run Ripple-65B?

Harder than the headline suggests. The reviewer first tried several hosted providers and hit max-token errors each time. He then self-hosted a quantized build on a machine with 96 GB of VRAM (an RTX Pro 6000 Blackwell). It used about 75 GB.

Setup took roughly 3 to 4 hours in total, including downloading and configuring everything on a fresh VM and rebuilding the test app. The provided inference code did not work on his GPU, so he rewrote it, then wrapped the model in a small server. These are preview-release rough edges, and they are worth budgeting for. The model card does point to an NVFP4 checkpoint and a Colab to help people start.

Can it generate a physics-style simulation from scratch?

The second test asked for a doner kebab simulation with no external libraries or assets. The output showed a tapered cone of layered meat, a top plate, a skewer rod, a drip tray and a burner panel with flickering blue flames and a glow. Fat dripped and splashed convincingly.

Weak spots were visible. The meat layers looked like flat stripes, and browning toward the burner and the burner itself could be better. For a no-asset code-generation task, the reviewer considered it a good result, especially the drip and splash behavior.

Can it write a complex Databricks SQL query?

The third test used a six-table grocery schema with arrays, structs and a map. The ask was a single Databricks query returning the top 10% of customers by net revenue per region and month.

The prompt contained deliberate traps: double-counting money across joins, ranking with percent rank, and filtering with QUALIFY. According to the reviewer, Ripple built the answer as a chain of small steps. It summed items and refunds separately before joining, and it used the array exists function for the relevant condition. It also handled region share, month-over-month change and alphabetical tie-breaks. The reviewer called it spot-on, while cautioning that results need verification in production.

Is Ripple-65B worth trying?

It is worth a look if you build coding agents and want an Apache 2.0 model that fits on a single large GPU or a DGX Spark class box. The dense design also keeps the memory story simple compared with a several-hundred-billion-parameter MoE.

Be careful about three things. The benchmark table is largely the lab's own, with its own in-house evals for missing entries. The tests above are three single runs by one reviewer. And this is a preview, so tooling and hosted availability may be rough. Weak spots like tool-use (MCP Atlas), safety and science coding matter if your workload leans on them.