Ripple-65B Preview

Ricursive Intelligence

Parameters

65.0B

Architecture

Dense Transformer decoder with hybrid sliding-window/global attention (GQA); Gemma 3N-like, thin-and-deep design (d_model 5120, 80 layers) with FFN activation clipping, gated attention, global NoPE, and value residuals

Released

04.11.2026

License

Apache License 2.0

Open Weights Commercial Use Multimodal BF16 Ripple English

Input Modalities

text

Output Modalities

text

Context (native)

2,097,152 tokens

Context (extended)

—

Openness Index Score 100.0/100

About

Ripple-65B Preview is a 65B-parameter dense (non-MoE) Transformer instruction-tuned language model from Ricursive Intelligence (HuggingFace org ricursiveAI), pretrained from scratch on 12 trillion tokens of a predominantly-English and code corpus at 8K sequence length, with support for up to 1Mi (1,048,576 tokens) of context. The launch blog (ricursive.com/ripple) describes Ripple-65B Preview as the general-purpose variant of the proprietary model powering Ricursive's AI chip-design platform.

Model family and training recipe

Ripple-65B follows the Ripple v1 model ladder, derived from an initial Olmo 3 baseline with iterative improvements to pretraining scaling laws, architecture, data, and post-training; the ladder improved Compute Efficiency (CE) on code by 16x relative to the Olmo 3 ladder, increasing to 55x for the full hero run. The org reports a full-stack R&D cost of roughly $32M for developing and training the model (launch blog, incl. ladder development, data mixing, evals, synthetic data generation, and the final hero runs). The training recipe (from the card's stage table):

  • Pretrain: 12T tokens, 877,500 steps, 8K seqlen, batch 1408 -> 3072 — 12T text-only predominantly-English + code corpus; pretraining kept "clean" with minimal synthetic data.
  • Midtrain: 200B tokens, 8,000 steps, 64K seqlen, batch 384 — synthetic-data-heavy stage added here so the pretraining data stayed clean.
  • Long Context: 6.5B tokens, 389 steps, 2M seqlen, batch 8.
  • SFT: 183B tokens, 7,274 steps, 128K seqlen, batch 192.
  • LC SFT: 13.5B tokens, 802 steps, 2M seqlen, batch 8.
  • RL (mixed domain): 700 steps, 128K seqlen, batch 2048.

The Preview release went through deliberately light post-training with a focus on agentic coding. Ripple-65B Base Preview is the pretrain-only sibling checkpoint (no midtraining/synthetic QA data); this repo contains the BF16 instruction-tuned model.

Architecture

Ripple-65B is a thin-and-deep dense Transformer: narrow d_model (5120) with 80 total layers (config.json; FFN intermediate size 40960). Config.json swaps the Olmo 3 llama-like block for a Gemma 3N-like architecture for training stability at scale: 64 of 80 layers are sliding-window attention (SWA, window 1024) and 16 are full attention (4:1 ratio). Attention is GQA with 80 query heads over 8 KV heads, head_dim 128, deliberately overprovisioned in head count with an increased SWA-to-global ratio and reduced SWA window compensating the extra cost. Additional reasoning-oriented components added relative to Olmo 3: FFN activation clipping (ffn_clamp_threshold 20.0), gated attention (use_gated_attention: true), global NoPE (no RoPE on global layers; local SWA layers carry rope_theta 10000.0), and value residuals (use_valres: true). Vocab 100352, tie_word_embeddings: false, rms_norm_eps 1e-06, embed scale 71.55, max_position_embeddings 2,097,152, auto class RicursiveForCausalLM (model_type ricursive), safetensors in BF16.

Ripple-65B was codesigned for NVIDIA hardware: ~40% MFU throughout pretraining/posttraining with simple sharding, no custom kernels, and no quantization (BF16); serving reaches ~250 tok/s on 2xB200 (batch=8) prior to quantization or custom kernels. At 65B total parameters it fits consumer hardware such as the NVIDIA DGX Spark, and the org ships an NVFP4 checkpoint plus a colab for local development.

Ecosystem

Artifacts: BF16 instruct model (this repo), NVFP4 quantization (Ripple-65B-Preview-NVFP4), base model (Ripple-65B-Base-Preview), DFlash2 variant (Ripple-65B-Preview-DFlash2); Apache 2.0 license. Launch platform availability (via launch blog): Hugging Face, Together AI, GMI Cloud, OpenRouter, Fireworks. On HF: 5 finetunes, 43 quantizations, no official HF Inference Provider; downloads last month 5,087, 414 likes.

Benchmarks (agentic coding first)

Ripple-65B Preview scores 80.52 on Terminal-Bench 2.1 (self-reported headline; the comparison table prints 80.5 for both the self-reported and the Terminus-2 row), positioned on agentic coding above 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). Other instruct-model scores from the card: SWE-bench Verified 76.5, SWE-bench Pro v1.0 61.42, SWE-bench Pro v2.0 Hard 79.1, DeepSWE 1.1 44.3, MCP Atlas 71.67, AutomationBench (Public) 36.4, tau3-bench banking 31.27, SciCode (Inspect AI) 39.4; knowledge/math: MMLU 89.6, MMLU-Pro 84.2, GPQA Diamond 85.2, AIME 2024 97.1 / 2025 98.3 / 2026 95.0, HMMT Feb 2026 90.5, IFBench 79.2, AA-LCR 75.0, StrongREJECT 97.5, FORTRESS Adversarial 83.8, FORTRESS Benign 95.5.

Evaluation methodology (as stated on the card): all models tested at full BF16 with maximum effort levels; table mixes official model-card scores with Ricursive's own in-house eval flow (marked italicized in the card); Terminus 2 used for SWE-bench Pro v2.0 Hard and DeepSWE 1.1 on Ripple, OpenCode otherwise unless harness specified. Replication of agentic evals is explicitly called out as unstable (e.g. TB 2.1 scores lower with official Terminus 2 at 128K + summarization), so results are a "best-effort" fair comparison.

Maintainer: Ricursive Intelligence (ricursive.com, contact info@ricursive.com). Base-model pretraining evals (MMLU 83.7, MMLU-Pro 61.5, HumanEval 70.9, GSM8K 88.5, etc.) belong to the Ripple-65B-Preview-Base artifact and are not attributed to this instruct record.

Training Data Pretrained from scratch on a 12T token, text-only predominantly-English and code corpus at 8K sequence length with minimal synthetic data kept out of pretraining; significantly more synthetic data was added during midtraining (200B tokens), followed by a light posttraining recipe (midtraining, long-context training, SFT, long-context SFT, mixed-domain RL) with a focus on agentic coding.

Benchmark Scores

Benchmark Score Date Standing
SciCode
63.62%
—
#11/27
better than 62%
Terminal Bench 2.1
coding_agent
88.80%
—
#17/44
better than 63%
AutomationBench (Public)
general_agent
55.67%
—
#5/11
better than 60%
GPQA Diamond
stem_reasoning
82.79%
—
#49/80
better than 39%
SWE-bench Verified
coding_agent
87.27%
—
#18/60
better than 71%
DeepSWE 1.1
coding_agent
57.42%
—
#23/34
better than 33%
SWE-bench Pro
coding_agent
68.47%
—
#15/77
better than 82%
SWE-bench Pro v2.0 Hard
coding_agent
100.00%
—
#1/5
better than 100%
AIME 2025
stem_reasoning
97.59%
—
#3/24
better than 91%
AIME 26
stem_reasoning
94.64%
—
#20/45
better than 57%

Hardware Requirements

Estimated VRAM per quantization at 4,096 tokens context

Quantization Weights KV Cache Total VRAM On your hardware
FP16 — 16-bit 130.0 GB 10.1 GB 146.6 GB Which GPUs can run it? Calculate on your GPU
INT8 — 8-bit 65.0 GB 5.0 GB 73.3 GB Which GPUs can run it? Calculate on your GPU
INT4 — 4-bit 32.5 GB 2.5 GB 36.6 GB Which GPUs can run it? Calculate on your GPU
FP4 — 4-bit 32.5 GB 2.5 GB 36.6 GB Which GPUs can run it? Calculate on your GPU

Only datacenter GPUs — FP16 needs 146.6 GB. For consumer hardware, choose the INT4 build with a multi-GPU setup.

Consumer GPUs that fit this model with a single card (INT4):

Architecture

Decoder Block ×80 input Embedding vocab 100K · d 5120 Sliding Window Attn Hybrid 80:8 · dₕ 128 · win 1024 ×64 Full Attention Hybrid 80:8 · dₕ 128 · win 1024 ×16 Dense FFN silu · d 41K Final Norm LM Head vocab 100K output
Attention
Hybrid Attention (80:8)
Layers
80
Hidden size
5120
Context
2.1M tokens
RoPE θ
10K
Parameters
65000M

Source: Hugging Face config.json · RicursiveForCausalLM · exact layer pattern · model repo

Type: decoder-only dense transformer with hybrid sliding-window attention
Attention: hybrid sliding-window (1024) + full attention layers (4:1, every 5th full), GQA 80/8 heads, gated attention with full-precision gates, value residuals, global NoPE on full-attention layers
Decoder: dense

Training Pipeline

  1. 1
    pretraining

    Pretrain

    Pretrained from scratch on a 12T text-only, predominantly-English and code corpus at 8K sequence length. The pretraining data was kept clean with minimal synthetic data, focusing on high-quality natural data rather than aggressively targeting evals. Ripple-65B Base Preview is the pretrain-only checkpoint without any midtraining or synthetic QA data.

  2. 2
    other

    Midtraining

    Continuation phase between pretraining and SFT that the card documents as 'midtraining', the first stage of its standard post-training recipe. Significantly more synthetic data was added during midtraining than in pretraining, which allowed the team to quickly iterate on the synthetic data recipe without blocking pretraining. The Base Preview checkpoint, by contrast, contains no midtraining or synthetic QA data.

  3. 3
    cpt

    Long Context

    Long-context extension stage listed in the stage table between midtraining and SFT, extending the sequence length to 2M. The card names 'long context' as part of the standard post-training recipe but documents no further details beyond the stage-table numbers.

  4. 4
    sft

    SFT

    Supervised fine-tuning stage of the standard post-training recipe, run at 128K sequence length. The Preview release has gone through relatively light posttraining with a focus on agentic coding. No further methodological detail is given beyond the stage-table numbers.

  5. 5
    sft

    LC SFT

    Long-context SFT stage named explicitly in the post-training recipe ('long context SFT'), run at 2M sequence length. No further details are documented beyond the stage-table numbers.

  6. 6
    rl

    Mixed Domain RL

    The recipe concludes with 'mixed domain RL' at 128K sequence length. Token count is not reported in the stage table (listed as N/A). This is the final stage of the standard post-training recipe, which for the Preview release was relatively light with a focus on agentic coding.

Comments (0)

No comments yet

Be the first to share your thoughts!

What now?

You have read the full card for Ripple-65B Preview — here is where to go next.