# Ricursive Ripple-65B Sets US Open-Weight Coding SOTA

*Updated on November 4, 2026*

For the past eighteen months, US open-weight model labs have chased agentic coding performance by scaling sparse Mixture-of-Experts (MoE) architectures past 500 billion to nearly 1 trillion parameters, often burning upwards of $150 million per month in cluster compute. On November 4, 2026, full-stack AI and silicon lab Ricursive Intelligence upended that scaling orthodoxy by releasing Ripple-65B Preview, a 65-billion-parameter dense Transformer that sets a new US open-weight state-of-the-art on TerminalBench 2.1 (`80.52`) while costing just `$32 million` in total end-to-end R&D.

Trained from scratch on `12 trillion tokens` with native support for a `1-million-token` context window, Ripple-65B Preview is the general-purpose open-weight release of the internal model Ricursive built to power its automated AI chip design platform. Despite having an order of magnitude fewer total parameters than competing US open-weight releases, Ripple-65B Preview outperforms `Reflection Beam 501B` (`80.1`), `Meta Muse Spark Open 816B` (`76.4`), `Thinking Machines Inkling 975B` (`63.8`), and `NVIDIA Nemotron 3 Ultra 550B` (`56.4`) on TerminalBench 2.1.

Importantly for enterprise and local developers, choosing a modernized `65B` dense architecture over a massive MoE envelope means the entire model fits comfortably in memory on local workstations such as the `NVIDIA DGX Spark`, where compute FLOPs are plentiful but memory capacity and bandwidth constrain 500B+ MoE weight loading.

Ricursive achieved these results by co-designing its model architecture and reinforcement learning recipe around hardware efficiency: maintaining `40% Model FLOPs Utilization (MFU)` across both pretraining and post-training without custom kernels or quantization, and reaching `80.52` on TerminalBench 2.1 in just `1.4 million` reinforcement learning rollouts—roughly `70x fewer rollouts` than Reflection Beam.

<a aria-hidden="true" id="executive-fast-facts"></a>  Fast Facts

- **Model &amp; Availability**: `Ripple-65B Preview` (`65B` dense Transformer, `80 layers`, `d_model = 5120`, `12T` pretraining tokens, `1M` context length), detailed in the [Ricursive Ripple-65B technical release](https://www.ricursive.com/ripple) and available on Hugging Face, Together AI, GMI Cloud, OpenRouter, and Fireworks.
- **Total R&amp;D Cost**: `$32 million` all-in from scratch (covering scaling ladder experiments, synthetic data generation, SFT/RL recipe development, and the final training run)—roughly `1/10th` the cost of prior US open-weight SOTA runs.
- **TerminalBench 2.1 SOTA**: Scores `80.52%`, beating `Reflection Beam 501B` (`80.1%`), `Meta Muse Spark Open 816B` (`76.4%`), `Thinking Machines Inkling 975B` (`63.8%`), and `NVIDIA Nemotron 3 Ultra 550B` (`56.4%`).
- **RL Sample Efficiency**: Reached `80.5+` on TerminalBench 2.1 using only `1.4M` RL rollouts (`~70x` fewer rollouts than Reflection Beam) using zero purchased post-training datasets.
- **Scaling Ladder Efficiency**: Compounded architectural upgrades (`pre+post norm`, `sigmoid gated attention`, `global NoPE`, `value residuals`, and `FFN activation clipping`) delivered `16x` higher code compute efficiency than the Olmo 3 baseline ladder at the 4B scale.

## Benchmark Comparison: Ripple-65B vs. 500B–975B US Open-Weight Models

Why did Ricursive choose a thin-and-deep dense Transformer (`80 layers`, `d_model = 5120`) instead of a sparse MoE architecture? While MoE models reduce FLOPs per token during inference at massive cloud concurrency, they introduce severe all-to-all communication bottlenecks during multi-turn reinforcement learning rollouts and require hundreds of gigabytes of VRAM just to hold inactive experts.

| Model Name | Total Parameters | Architecture Type | TerminalBench 2.1 Score | Est. Training / R&amp;D Cost | Local Workstation Viability (128GB Unified RAM) |
|---|---|---|---|---|---|
| **Ricursive Ripple-65B Preview** | **65B** | **Dense Transformer (80L)** | **80.52 (US Open SOTA)** | **$32M (Full R&amp;D)** | **Yes (Runs natively on DGX Spark / 128GB)** |
| **Reflection Beam 501B** | 501B | Sparse MoE | 80.10 | ~$300M+ cluster commitment | No (Requires multi-node H100/B200) |
| **Meta Muse Spark Open 816B** | 816B | Sparse MoE | 76.40 | Hundreds of millions | No (Datacenter cluster only) |
| **Thinking Machines Inkling 975B** | 975B | Sparse MoE | 63.80 | Hundreds of millions | No (Datacenter cluster only) |
| **NVIDIA Nemotron 3 Ultra 550B** | 550B | Hybrid MoE | 56.40 | Enterprise cluster | No (Datacenter cluster only) |

Starting from the Allen Institute for AI's `Olmo 3` model ladder, Ricursive executed six sequential architectural ladder iterations (`v1.0` through `v1.6`) validated at the 4B scale before committing to the 65B hero run:

- **Ladder v1.0 &amp; v1.1**: Applied StepFun batch-size and learning-rate scaling laws while transitioning to a thin-and-deep aspect ratio (`80 layers`, narrow `5120` hidden dimension) with overprovisioned attention heads and a higher sliding-window-to-global attention ratio.
- **Ladder v1.2 &amp; v1.3**: Switched from post-norm to combined `pre+post norm` (which unlocked gains starting at 4B scale) and introduced `sigmoid gated attention`, while rejecting 2-stream mHC (`v1.4`) when small-scale gains failed to hold at 4B.
- **Ladder v1.5 &amp; v1.6**: Replaced standard positional encodings on global layers with `global NoPE` (No Positional Encoding), added a learning-rate cooldown to zero, and integrated `value residuals` alongside `FFN activation clipping`.

## Steep Ascent RL: 70x Fewer Rollouts With Synthetic Environments

Instead of purchasing third-party human-annotated coding trajectories or running tens of millions of brute-force RL rollouts, Ricursive built an internal synthetic environment generator with automated quality filtering and coverage metrics. Their reinforcement learning loop combines **truncated importance sampling**, **score centering**, and a **linear length penalty** that discourages verbose token spinning inside terminal sessions, dynamically injecting harder multi-step repository debugging tasks as the policy checkpoint improved.

  Next Steps

1. **Deploy Ripple-65B Preview on Local 128GB Hardware**: Download the open weights from Hugging Face to run quantized or FP8 local agentic coding workflows on single-node workstations (such as NVIDIA DGX Spark or dual-GPU Linux rigs) where 500B+ MoE models cannot fit.
2. **Test Multi-File Terminal Tasks via OpenRouter or Together AI**: Benchmark Ripple-65B Preview against your existing Claude Code or Codex workflows on long-horizon bash, compiler, and test-suite repair tasks using its `1M` context window.
3. **Adopt Linear Length Penalties in Internal RL Pipelines**: If your team fine-tunes domain-specific coding or tool-use agents, incorporate score centering and linear length penalties to prevent RL policies from inflating token counts.