Ripple-65B Preview

Ripple-65B Preview

Runs terminal coding agents on a 65B dense language model that reads up to 1,048,576 tokens of context. Made for developers and researchers who want open Apache 2.0 weights.

Made by ricursiveAI on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Ripple-65B Preview is a language model from ricursiveAI, built for agentic coding and reasoning. It is a dense Transformer with 65 billion parameters, pretrained on 12 trillion tokens, and it reads contexts up to 1,048,576 tokens. This page covers the BF16 instruction-tuned release.

Who it suits: It suits people who want a coding model they can run themselves and study. The maker designed it for NVIDIA hardware.

Industry | Who uses it | How they use it | Example
Software | Developers building coding agents | Run it as the model behind an agent that works in a terminal | Handing the agent a failing build to fix
AI research | Model researchers | Study a dense 65B design next to larger mixture-of-experts models | Comparing layer depth and attention head choices
Local AI | People running models on their own machine | Try the NVFP4 checkpoint on consumer hardware | Chatting with it on an NVIDIA DGX Spark
Infrastructure | Teams serving models on GPUs | Measure generation speed on datacenter cards | Timing output on B200 GPUs

You can skip it if you need images, audio or strong non-English text, because training used text only and mostly English.

Where to use it: It works wherever you can serve a large language model and attach a coding agent.

• A terminal coding agent: the maker ran its benchmarks through the Terminus 2 and OpenCode frameworks.
• Datacenter GPUs: the BF16 weights, which the maker served on two B200 cards.
• Compact local machines like the NVIDIA DGX Spark, using the NVFP4 checkpoint.
• A Colab notebook the maker provides for the NVFP4 checkpoint.

Use case | Who | What they get back
Agentic coding | Developers | A model post-trained with a focus on agentic coding
Long-context work | Engineers with large inputs | A model that accepts up to 1,048,576 tokens at once
Local experiments | Researchers and hobbyists | A 65B model sized for consumer hardware such as the DGX Spark

How to set it up: The maker offers three checkpoints, so pick the one that fits your machine. This page lists no install command, because the source shows none. Check the model page for loading code.

• An NVIDIA GPU machine, since the model was designed to be trained and served on that hardware.
• Enough GPU memory for the checkpoint you choose. The NVFP4 version is the smaller option.
• A serving stack you already use for large language models.

1. Choose a checkpoint: the BF16 instruction-tuned model on this page, the NVFP4 version, or the BF16 base model.
2. On a small machine, start from the NVFP4 checkpoint and the Colab the maker provides.
3. Download the weights from the model page on Hugging Face.
4. Load them in your serving stack and connect your coding agent to it.

How to use it: You use it as the model behind a coding agent. Give the agent a task in a terminal and the model works through it. The maker also ran it inside two named agent frameworks for its benchmark runs.

Tool | What it does
Ripple-65B Preview | The BF16 instruction-tuned model, lightly post-trained with a focus on agentic coding
Ripple-65B Preview NVFP4 | The instruction-tuned model in NVFP4 numerics, offered for local use
Ripple-65B Base Preview | A BF16 pretrain-only checkpoint with no midtraining or synthetic QA data
Terminus 2 | The agent framework the maker used on its SWE-bench Pro and DeepSWE runs
OpenCode | The agent framework behind the maker's other runs, where no framework was named

Example: You tell your agent, "The tests fail after my last change, find out why and fix it." The model answers with terminal steps toward a fix. You review them before you accept anything.

For newcomers and experts: Think of it as a large text model that was taught to work in a terminal. A small first try is the NVFP4 checkpoint in the Colab the maker provides, with a short coding question.

If you know the field, the design is thin and deep: a narrow model width of 5120 across 80 layers, in a Gemma 3N-like layout rather than the earlier Olmo 3 one. It carries more attention heads than usual and more sliding-window layers with smaller windows. Gated attention, global NoPE, value residuals and clipping of FFN activations are also in. The maker chose dense over mixture-of-experts to keep training and serving simple, and reports about 40 percent MFU with no custom kernels.

Pretrain on 12T tokens at 8K length
Midtrain at 64K, then a long context stage
SFT and long context SFT
Mixed domain RL

Good to know:

• Training data was text only, mostly English and code.
• This is a Preview. Post-training was relatively light, with a focus on agentic coding.
• Benchmark results come from the maker. Some use its in-house eval flow, and it says replicating agentic scores is hard.
• With the official Terminus 2 setup at 128K length and summarization, scores came out lower for nearly every model.
• Generation reached about 250 tokens per second on two B200 GPUs at batch size 8, before quantization or custom kernels.
• The license is Apache 2.0.

Title: TerminalBench 2.1 score, higher is better
Ripple-65B Preview: 80.52 points
Reflection Beam 501B: 80.1 points
Meta Muse Spark Open 816B: 76.4 points
Thinking Machines Inkling 975B: 63.8 points
NVIDIA Nemotron 3 Ultra 550B: 56.4 points

On Hugging Face, 10 November 2026

• Parameters: 64.8B
• Weights: about 130 GB in BF16; about 32.4 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 5,835
• Likes: 458
• License: apache-2.0
• Quantized versions: 43
• Fine-tunes: 6
• Tags: safetensors, ricursive

Links

• Model: https://huggingface.co/ricursiveAI/Ripple-65B-Preview
• Files: https://huggingface.co/ricursiveAI/Ripple-65B-Preview/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ricursiveAI/Ripple-65B-Preview

Then follow the usage in its model card. Nothing in this kit runs by itself.