In this categoryLocal AI · 75
More guides
Local AIIntermediate

Ripple-65B Preview: The 65B Dense Model That Beats 10x Larger Open Models on Agentic Coding

Ripple-65B Preview is a 65 billion parameter dense language model from Ricursive Intelligence, released November 4, 2026 under Apache 2.0. It scores 80.52 on Terminal-Bench 2.1, ahead of several open-weight models many times its size, and ships in BF16 and NVFP4 builds, the NVFP4 checkpoint built to run on a single NVIDIA DGX Spark.

8 minIntermediate

Ripple-65B Preview is a 65 billion parameter dense language model from Ricursive Intelligence, released November 4, 2026 under Apache 2.0. It scores 80.52 on Terminal-Bench 2.1, ahead of several open-weight models many times its size, and ships in BF16 and NVFP4 builds, the NVFP4 checkpoint built to run on a single NVIDIA DGX Spark.

Ricursive Intelligence is a new lab, and Ripple-65B Preview is its first public model. It climbed into the top 20 of Hugging Face's overall trending list within a day of release, which is a fast start for a lab nobody had a model card for a week earlier. The pitch is unusual for 2026: instead of a mixture-of-experts model chasing parameter count, Ricursive trained a dense transformer and is betting that careful architecture and data choices close the gap with models ten times its size.

Written by Priya Raghunathan, local-AI hardware reviewer. I verify parameter counts, licenses, hardware requirements, and every command against the primary source before recommending a setup path.

At time of writing the Ripple-65B Preview model page shows 271 likes and 939 downloads. The only linked Space, akhaliq's ZeroGPU demo, has no likes yet, and Ricursive has not published a dedicated GitHub repo for the model itself. The one GitHub link on the model card points to Allen AI's Olmes eval harness, at 407 stars, which Ricursive forked internally to run the base-model benchmarks it couldn't source from other labs' own reporting.

Specs at a glance

FieldValue
PublisherRicursive Intelligence (ricursiveAI)
ArchitectureDense transformer, custom "Ricursive" model type
Total parameters64.78B (safetensors total)
Pretraining data12 trillion tokens, mostly English text and code
Context windowUp to 1,048,576 tokens on the full BF16 checkpoint
CheckpointsBF16 instruct, NVFP4 instruct, BF16 base, DFlash2 speculative draft
LicenseApache 2.0
Release dateNovember 4, 2026

Why dense instead of mixture-of-experts

Every other model Ricursive compares itself against, Nemotron 3 Ultra, Inkling, Muse Spark Open, and Reflection Beam, is a mixture-of-experts design running between 501B and 975B total parameters. Ripple-65B is a plain dense transformer, meaning all 64.78B parameters activate on every token rather than routing to a subset of experts. Ricursive says that choice was deliberate for a first model: it keeps the training and serving stack simple, with no custom kernels and no quantization during training, while a small team of one to five people scaled up the project.

The model also uses what Ricursive calls a thin-and-deep layout, a narrower hidden size of 5,120 stacked across 80 layers, plus a Gemma 3N style attention pattern instead of the Llama-style block their earlier Olmo 3 baseline used. On top of that they added extra attention heads, adjusted the ratio of sliding-window to full attention layers, and layered in a handful of smaller tweaks (FFN activation clipping, gated attention, no positional encoding in some layers, value residuals) aimed specifically at reasoning and multi-step agent tasks rather than raw perplexity.

How it stacks up against much larger models

Ricursive's benchmark table runs Ripple-65B against four larger open-weight models on the same evals, using each lab's own reported numbers where available and its own eval runs for the rest. Terminal-Bench 2.1, a test of multi-step command-line and agentic tasks, is where the size gap is most visible.

BenchmarkRipple-65B (65B)Nemotron 3 Ultra (550B)Inkling (975B)Muse Spark Open (816B)Reflection Beam (501B)
Terminal-Bench 2.1 (self-reported)80.556.463.876.480.1
SWE-bench Verified76.571.977.678.781.6
SWE-bench Pro v2.0 Hard79.130.72.052.376.5
AIME 202598.394.291.7100.099.6
MMLU-Pro84.286.887.387.976.5

At only 65B total parameters, the model can fit on consumer hardware such as the NVIDIA DGX Spark.

Ripple-65B Preview model card README (Hugging Face)

SWE-bench Pro v2.0 Hard is the starkest result in the table. Ripple-65B's 79.1 is closer to the much larger Reflection Beam's 76.5 than any of the mid-size mixture-of-experts models manage, with Inkling scoring a near-total 2.0 on that specific eval. Nemotron 3 Ultra, by contrast, leads most of the plain knowledge benchmarks like MMLU-Pro, which tracks with Ricursive's own explanation: Nemotron leaned heavily on synthetic training data tuned for traditional pretraining evals, a trade that doesn't carry over as well to agentic coding tasks.

Running it: two checkpoints for two very different setups

Custom model code required
Ripple-65B registers as a "ricursive" model type with its own modeling_ricursive.py and configuration_ricursive.py files rather than a transformers-native architecture. Any loader needs trust_remote_code enabled, or in SGLang's case the model class registered by hand, as shown below. Without that step, loading the checkpoint will fail.

The BF16 instruct checkpoint's safetensors files total roughly 129.6 GB, more than any single consumer GPU's VRAM. Ricursive's own serving example reflects that: it runs on two NVIDIA B200 GPUs through SGLang 0.5.19, paired with the separate DFlash2 draft model for speculative decoding.

bash - serve BF16 Ripple-65B on 2x B200 with SGLang
$export CUDA_HOME=/usr/local/cuda-13.0
$export PATH="$CUDA_HOME/bin:$PATH"
$
$CUDA_VISIBLE_DEVICES=0,1 uv run --script serve.py \
$ --model-path /path/to/target \
$ --speculative-draft-model-path /path/to/draft
$

That command runs serve.py from the model repo's inference/server folder, which Ricursive says installs its own dependencies through uv. Defaults are tensor parallel size 2, BF16 weights and KV cache, and a 1,048,576-token context window. The server exposes an OpenAI-compatible chat endpoint on 127.0.0.1:30000, including tool calling with strict JSON schemas.

For a single consumer-grade box, Ricursive points instead to the NVFP4 checkpoint, which keeps attention layers in BF16 and quantizes only the MLP layers, run through a bundled spark.py script meant for a Jupyter notebook on an NVIDIA DGX Spark. The script checks the GPU's reported compute capability and refuses to start on anything other than the DGX Spark's GB10 chip.

ripple.ipynb
from spark import Spark

engine = Spark(
    target="ricursiveAI/Ripple-65B-Preview-NVFP4",
    draft="ricursiveAI/Ripple-65B-Preview-DFlash2",
)
print(engine.chat("Explain NVFP4 quantization in two sentences."))
The DGX Spark path trades context for portability
This notebook path caps context at 131,072 tokens and runs one request at a time, far short of the 1M-token window and multi-user serving the two-B200 BF16 path supports. It's built for a single developer running Ripple-65B locally, not for serving traffic.

License and use

Ripple-65B Preview ships under Apache 2.0, so commercial use, modification, and redistribution are allowed without a separate agreement. Ricursive flags this as a Preview release with comparatively light posttraining focused on agentic coding, so expect rougher edges than a model several training cycles further along.

FAQ

What is ricursiveAI/Ripple-65B-Preview?

It is a 65 billion parameter dense language model, the first public release from the lab Ricursive Intelligence, trained on 12 trillion tokens and released under Apache 2.0 on November 4, 2026.

How many parameters does it have?

64.78 billion parameters total, per the model's safetensors total on Hugging Face, and every parameter activates on every token since it's a dense model rather than mixture-of-experts.

Can I run Ripple-65B on a single consumer GPU?

Not the BF16 checkpoint; its weights alone total about 129.6 GB. Ricursive's own BF16 example uses two NVIDIA B200 GPUs. For local use on a single machine, Ricursive publishes an NVFP4 checkpoint built to run on one NVIDIA DGX Spark, with a smaller 131,072-token context window.

Why does it need trust_remote_code?

Ripple-65B uses a custom architecture, registered as model type "ricursive" with its own modeling and configuration Python files in the repo, rather than an architecture already built into transformers. Loaders need to either enable trust_remote_code or register the model class directly, as Ricursive's own SGLang scripts do.

Is it free for commercial use?

Yes. Apache 2.0 permits commercial use, modification, and redistribution without additional permission.

Where to go from here

Local models run better with more VRAM. CompareRTX GPUs on Amazonbefore you upgrade.(affiliate link. We may earn a commission at no extra cost. Disclosure)

Watch related tutorials

Free weekly email

Weekly local AI drops

New models, what runs on your hardware, and the guides to set them up. One email a week, unsubscribe any time.

Tags
#ricursive ripple 65b#ripple 65b preview#run ripple 65b locally#dense model vs moe#terminal-bench 2.1 benchmark#nvfp4 dgx spark model