The Cost Frontier Just Shifted

For years, the open-weight leaderboard has been a MoE arms race: Reflection Beam 501B, Meta Muse Spark Open 816B, Thinking Machines Inkling 975B, NVIDIA Nemotron 3 Ultra 550B. Each release pushed total parameters higher, active parameters higher, training compute higher. The implicit bet: scale wins, and Mixture-of-Experts is the only way to scale efficiently.

Ricursive Intelligence, a U.S. full-stack AI lab founded in 2024, just falsified that bet [S1]. Their Ripple-65B Preview — a dense 65B parameter Transformer trained from scratch on 12 trillion tokens — scores 80.52 on Terminal-Bench 2.1, edging out Reflection Beam 501B (80.1) and decisively beating Muse Spark Open 816B (76.4), Inkling 975B (63.8), and Nemotron 3 Ultra 550B (56.4) [S1][S2]. All self-reported, all at full BF16 precision, all on the same benchmark.

The kicker: full R&D cost was $32M [S1]. Ricursive estimates this at one-tenth the cost of the prior open-weight agentic coding leader. That figure covers everything: ladder experiments, data mixing, evals, synthetic data pipelines, debugging, and the final hero pretraining and posttraining runs. A team that scaled from 1 to 5 people. No custom kernels. No quantization during training. 40% MFU with simple sharding [S1][S2].

Grandma-test difficulty: 3/5 — Requires model download (~130 GB BF16, ~33 GB NVFP4) and compatible serving stack; NVFP4 runs on DGX Spark-class hardware

Try-it time: 15 minutes to first token on OpenRouter/Together AI; hours for local NVFP4 setup

Worth your time: 4/5 — Strong Look: redefines the cost/performance frontier for local agentic coding

Architecture: Dense Wins When Co-Designed

The MoE orthodoxy says dense models can’t compete on efficiency. Ricursive’s counterargument: co-design the architecture for your training and serving platform, and dense wins [S1].

Ripple-65B uses a thin-and-deep aspect ratio: narrow d_model (5120) but 80 total layers [S2]. This is a deliberate departure from the Llama-like wide-and-shallow pattern. The team moved to a Gemma 3N-like architecture for training stability at scale [S2]. Key architectural choices:

  • Overprovisioned attention heads for reasoning, compensated by increased sliding-window-to-global layer ratio and reduced SWA window size [S2]
  • Gated attention (arXiv:2505.06708) for improved gradient flow
  • Global NoPE (arXiv:2501.18795) — removing positional embeddings from global attention layers
  • Value residuals (arXiv:2410.17897) for training stability
  • FFN activation clipping — also used in OpenAI’s gpt-oss [S1][S2]

The result: 65B total = 65B active parameters. No routing overhead. No expert imbalance. No MoE-specific infrastructure. On 2x B200, the model hits 250 tok/s at batch=8 before quantization [S2][S3]. The NVFP4 checkpoint (MLP layers quantized, attention in BF16) targets NVIDIA DGX Spark-class devices for local deployment [S3].

Laddering: 16x Compute Efficiency at 4B, 55x at 65B

Ricursive didn’t guess the recipe. They laddered it [S1][S2]. Starting from Olmo 3’s model ladder (AI2), they ran a series of controlled interventions at small scale (4B and below), only promoting changes that held:

| Ladder Version | Intervention | Result | |—|—|—| | v1.0 | StepFun batch size & LR scaling laws | Baseline | | v1.1 | Smooth architectural dimension scaling | Improved | | v1.2 | Pre+post norm (vs post-norm) | Neutral at 4B, gains at 4B+ | | v1.3 | Sigmoid gated attention | Improved | | v1.4 | 2-stream mHC | Rejected — failed at 4B | | v1.5 | Global NoPE + LR cooldown to zero | Improved | | v1.6 | Value residuals | Improved | | Final | Custom 12T code-upsampled dataset | 16x CE gain at 4B, 55x at 65B |

The compounding effect is critical: the compute efficiency advantage increases with scale. Olmo 3’s ladder has a shallower slope; Ripple’s ladder steepens. At hero scale, the same code performance costs 55x less compute [S1][S2].

Post-Training: RL Efficiency Over Brute Force

The prior SOTA, Reflection Beam, reportedly used 100M+ RL rollouts [S1][S3]. Ripple hit 80.5 Terminal-Bench 2.1 with 1.4M rollouts — roughly 70x fewer [S1][S3].

How? A mixed RL recipe designed for compute efficiency [S1]:

  • Truncated importance sampling (OpenReview:xsonlP8DRV) — bounds variance, stabilizes updates
  • Score centering (arXiv:2609.20807) — normalizes rewards across tasks
  • Linear length penalty (Microsoft MAI Thinking) — discourages verbose, low-signal trajectories
  • High-quality long-horizon synthetic environments — no purchased post-training data; all synthetic pipelines built in-house [S1][S3]

Tasks were continuously added as the model improved — a curriculum approach rather than a static benchmark chase [S1]. The team explicitly notes that replicating benchmark scores is challenging due to harness variance (Terminal-Bench 2.1 scores dropped universally on official Terminus 2 at 128K with summarization, except Muse Spark Open) [S2].

What Ripple-65B Doesn’t Win

The model card is unusually candid about weak spots [S2][S3]:

| Benchmark | Ripple-65B | Best Rival | Gap | |—|—|—|—| | SciCode | 39.4 | Muse Spark Open 58.5 | -19.1 | | DeepSWE 1.1 | 44.3 | Muse Spark Open 60.0 | -15.7 | | MCP Atlas | 71.67 | Muse Spark Open 89.2 | -17.5 | | GPQA Diamond | 85.2 | Muse Spark Open 89.0 | -3.8 | | SWE-bench Verified | 76.5 | Reflection Beam 81.6 | -5.1 |

SciCode (scientific coding) and DeepSWE (deep software engineering) are the largest gaps. MCP Atlas (model-context-protocol tool use) also trails. GPQA Diamond (hard science reasoning) is competitive but behind the MoE giants. SWE-bench Verified (real-world GitHub issues) trails Reflection Beam and Inkling [S2][S3].

The pattern is clear: **Ripple dominates agentic terminal coding (Terminal-Bench), but trails on scientific reasoning, deep multi-file engineering, and broad tool-use ecosystems**. The dense 65B capacity ceiling shows against models with 400B+ active parameters [S2][S3].

Deployment Reality: What You Can Run Today

| Artifact | Size | Target Hardware | Availability | |—|—|—|—| | BF16 Instruct | ~130 GB | 8x H100 / 4x B200 | Hugging Face [S2] | | NVFP4 Instruct | ~33 GB | DGX Spark, RTX 5090 (24-32 GB) | Hugging Face [S2][S3] | | BF16 Base | ~130 GB | Fine-tuning / research | Hugging Face [S2] | | DFlash2 Drafter | ~2 GB | Speculative decoding | Hugging Face [S2] |

Hosted (zero-setup): OpenRouter, Together AI (coming soon), GMI Cloud, Fireworks [S1][S3].

Local NVFP4: The 33 GB NVFP4 build fits on a single DGX Spark (Grace + GPU) or high-end consumer GPU with 24-32 GB VRAM. Ricursive provides a Colab notebook for quick testing [S3].

Licensing: Apache 2.0 across all artifacts — unrestricted commercial use, modification, redistribution [S1][S2][S3]. No Llama-style user caps. No Muse Model License restrictions.

What This Means for the Open-Weight Frontier

Three takeaways:

  1. Dense is not dead — it was under-optimized. Co-designing architecture, data, and infrastructure for a specific hardware target (NVIDIA) yielded a 55x compute efficiency gain at hero scale. The MoE complexity tax (routing, expert balance, custom kernels, sharding) is real — and avoidable if you’re willing to ladder carefully.
  1. $32M is a new floor for frontier open-weight models. Not $300M. Not $1B. A 5-person team with thoughtful laddering, synthetic data pipelines, and RL efficiency. This should expand the set of labs that can meaningfully contribute to the open frontier.
  1. Local agentic coding just got a credible flagship. A 65B dense model with 1M context, Apache 2.0, NVFP4 for DGX Spark, and Terminal-Bench 80.5 is the first US open-weight model that makes “run a SOTA coding agent on your desk” a coherent proposition — not a quantized shadow of a cloud model [S1][S2][S3].

The Verdict

Ripple-65B Preview is a landmark result for compute-efficient open-weight training. It proves that dense architectures, when co-designed with laddering and targeted RL, can punch 8-15x above their parameter weight on agentic coding. The $32M cost and 5-person team are arguably more important than the benchmark score — they demonstrate a reproducible methodology.

For practitioners: if your workload is terminal-centric agentic coding (Terminal-Bench domain), Ripple-65B is now the US open-weight leader. If you need scientific coding (SciCode), deep multi-repo engineering (DeepSWE), or broad MCP tool ecosystems — the larger MoE models still lead. Choose the model for the task, not the parameter count.

The open-weight frontier just became more accessible. That’s the real story.

Sources

  1. [S1] Introducing Ripple-65B Preview, a Frontier Open-Weight Model — Ricursive Intelligence (2026-11-04)
  2. [S2] ricursiveAI/Ripple-65B-Preview Model Card — Hugging Face (Ricursive Intelligence) (2026-11-10)
  3. [S3] Ricursive AI Releases Ripple-65B Preview: A 65B Dense Open-Weight Model Scoring 80.5 on Terminal-Bench 2.1 — MarkTechPost (2026-11-04)