Ripple-65B VRAM: 64 KiB of KV per Token

Ricursive Intelligence put Ripple-65B Preview on Hugging Face on 4 November 2026. It's a 65B dense model under Apache 2.0, built for agentic coding, and Ricursive says it scores 80.52 on Terminal-Bench 2.1. That beats Reflection Beam 501B (80.1) and Meta's Muse Spark Open 816B (76.4), both mixture-of-experts models with far more parameters.

The pitch is that it runs on your desk, on an NVIDIA DGX Spark. What makes that possible is mostly the KV cache. Only 16 of its 80 layers keep a cache that grows with context. Below are the real checkpoint sizes, the cache maths from config.json, what the official Spark script actually configures, and what the hosted version costs per agent session if you'd rather not buy hardware.

Table of contents

• What Ripple-65B Preview is
• Checkpoint sizes
• Why the KV cache stays small
• Fitting it on a DGX Spark
• Hosted cost per agent session
• Catches before you download 130 GB
• FAQ
• Sources

What Ripple-65B Preview is

Ricursive calls the shape "thin-and-deep". It started from an Olmo 3 baseline and moved to a Gemma 3N-like layout, then added gated attention, FFN activation clipping, global NoPE and value residuals. The launch post puts the whole project at $32M, including all the research runs, with a team that grew from 1 to 5 people.

The instruct model went through what the card calls "relatively light posttraining, with a focus on agentic coding". So it's a coding agent first. Knowledge scores trail the big MoE models: MMLU-Pro is 84.2 against 87.9 for Muse Spark Open.

Terminal-Bench is its best result. On SWE-bench Verified and MCP Atlas, Beam is ahead. Some cells in Ricursive's table come from its own eval runs rather than the other labs' cards, and the card admits agentic scores shift with the harness.

Checkpoint sizes

These are safetensors totals from the Hugging Face API, not estimates.

The NVFP4 file is bigger than a plain 4-bit estimate. At half a byte per parameter, 64.78B parameters would be 30.17 GiB. Ricursive calls its quantization "conservative": only the MLP layers go to NVFP4, while attention, embeddings and the output head stay in BF16. That's 23 GiB more than the naive number. Plan hardware from the 53.28 GiB file, not from a rule of thumb.

Neither checkpoint fits a single consumer card. The NVFP4 weights alone are larger than a 32 GB RTX 5090, and NVFP4 is a Blackwell-only format, so 24 GB Ada and Ampere cards are out either way.

Why the KV cache stays small

In config.json, layer_types repeats four sliding_attention layers, then one full_attention layer, 16 times. The sliding layers only ever look back 1,024 tokens, so their cache stops growing at 1,024 tokens. Only the 16 full layers grow with your context.

Per full layer, per token, in BF16: 2 (K and V) x 8 KV heads x 128 x 2 bytes = 4 KiB. Across 16 layers that's 64 KiB per token. The 64 sliding layers add a fixed 256 MiB once their windows fill.

For comparison, Nanbeige4.3-33B, a model half Ripple's size, keeps 208 KiB per token because every layer is full attention. That's 3.25x Ripple's per-token cost. The AI VRAM calculator now has a Ripple-65B preset set to the 16 full-attention layers, so its KV figure matches the table above, minus the fixed 256 MiB of sliding-window cache. Its INT4 weight figure will read 30.17 GiB. Swap in the real 53.28 GiB when you size a card. The method behind these numbers is in our local LLM VRAM guide.

Fitting it on a DGX Spark

A DGX Spark has 128 GB of unified memory, which is 119.21 GiB. Ricursive's own Spark path is a notebook plus spark.py in the NVFP4 repo. It loads the NVFP4 target with the BF16 DFlash2 draft and starts SGLang's offline engine with these memory settings:

--dtype bfloat16 --kv-cache-dtype bfloat16 --tp-size 1
--context-length 131072 --max-total-tokens 139264 --mem-fraction-static 0.78
--max-running-requests 1 --disable-radix-cache

So the official Spark setup caps context at 128K, serves one request at a time, and refuses a quantized KV cache. The script also refuses to start on anything but a GB10 GPU (compute capability 12.1).

Add it up for that setup: 53.28 GiB of weights, 7.52 GiB of draft and 8.25 GiB of cache at 128K comes to 69.06 GiB. The rest goes to the CUDA context, activations and the draft's own cache. The 0.78 fraction gives SGLang about 92.98 GiB for weights and cache, so 128K is comfortable.

The full 1M context doesn't fit. NVFP4 weights plus 1M of cache is 117.53 GiB, and with the draft it's 125.06 GiB, more than the whole Spark. At 512K the total is 93.06 GiB with the draft, right at the 0.78 line, and nothing Ricursive ships has been tested there. Treat 1M as a datacenter feature. The card's speed figure, 250 tok/s, is for two B200s at batch 8 in BF16, not for the Spark.

To run the official path, the notebook wants Python 3.12, CUDA Toolkit 13 and these pinned packages:

python3.12 -m venv ~/.venvs/ripple-spark
~/.venvs/ripple-spark/bin/pip install jupyterlab
# the notebook's first cell then installs, from the cu130 index:
# sglang==0.5.19 torch==2.13.0+cu130 transformers==5.12.1 flashinfer-python==0.6.18

Hosted cost per agent session

Ricursive lists Together AI, GMI Cloud, OpenRouter and Fireworks as hosts. Together's pricing page, read on 7 November 2026, has Ripple-65B Preview at $0.20 input, $0.02 cached input and $0.60 output per million tokens.

I used the same session as our other agent-cost posts: 60 turns, a 120K cached prefix, 3K new input tokens and 1.5K output tokens per turn. That's 7.2M cached tokens, 180K fresh and 90K out.

The same session on Together costs $0.468 with Reflection Beam 1.0 ($0.40 / $0.04 / $1.20) and $1.69 with Muse Spark Open ($1.25 / $0.15 / $4.25). So Ripple matches Beam on Terminal-Bench at half the session cost. NVIDIA's Nemotron 3.5 Super VL is slightly cheaper at $0.216, but it isn't in Ricursive's comparison table. Plug your own token mix into the API cost calculator, which now lists Ripple under Together AI.

At $0.234 a session, a Spark only pays for itself if you run a lot of sessions or the code can't leave your machine. At list price, one Spark buys a great many hosted sessions.

Catches before you download 130 GB

It needs custom code. The repos ship modeling_ricursive.py and need trust_remote_code. Ricursive publishes no GGUF, so Ollama and LM Studio can't load it from the official files. Community conversions may appear, but none of the scores above were measured on them.

The Spark path is a notebook, not a server. spark.py says it runs "no HTTP server". To hook it up to Claude Code, OpenCode or Hermes Agent, you'd have to run SGLang's server yourself with Ricursive's model file. The BF16 repo has an inference/server folder for that.

Tool calling has a quirk. The notebook says tool_choice="required" needs strict=True and additionalProperties=False in the schema. Without those, this SGLang version added extra argument fields in Ricursive's tests. The chat template also has no thinking on/off switch and no reasoning-effort levels.

English and code only. Pretraining was "predominantly-English" text and code, and the model doesn't take images. Ricursive publishes no Hindi or multilingual instruct results, so test it on your own prompts before you rely on it for Hinglish.

FAQ

Can it run on two RTX 5090s? Maybe, but nobody has published that setup. Two 32 GB cards give 64 GB, which holds the 53.28 GiB NVFP4 weights with about 6 GiB left for cache and runtime, so short contexts at most. Ricursive's script only supports a single GB10.

What is the DFlash2 draft for? Speed. It's a 4.04B model that proposes blocks of 16 tokens that Ripple then checks, so you get more tokens per step with the same output distribution. You can skip it to save 7.52 GiB; spark.py has a speculative=False option.

Is the base model useful? For fine-tuning, yes. Ripple-65B Base Preview is a pretrain-only checkpoint with no midtraining or synthetic QA data. Ricursive says it's comparable with DeepSeek V3.1 and V4 Flash on reasoning, math and code.

Sources

• Ricursive Intelligence, Ripple-65B-Preview model card (huggingface.co/ricursiveAI/Ripple-65B-Preview, read 7 November 2026): architecture, training stages, benchmark tables, 250 tok/s figure, base-model notes.
• Ricursive Intelligence, config.json in the BF16 and NVFP4 repos: layer types, sliding window, KV heads, head size, quantization config.
• Ricursive Intelligence, Ripple-65B-Preview-NVFP4 and DFlash2 model cards, plus inference/local/spark.py and ripple.ipynb in the NVFP4 repo: quantization scope, draft parameters, Spark launch flags, pinned packages, tool-calling notes.
• Ricursive Intelligence, "Introducing Ripple-65B Preview" (ricursive.com/ripple, read 7 November 2026): $32M cost, hosting partners, Terminal-Bench comparison.
• Hugging Face model API for the three repos (read 7 November 2026): safetensors file sizes and parameter count.
• NVIDIA, DGX Spark product page (read 7 November 2026): 128 GB unified memory.
• Together AI pricing page (read 7 November 2026): Ripple-65B Preview, Reflection Beam, Muse Spark Open and Nemotron 3.5 Super VL rates.
• KV cache sizes, GiB conversions and session costs are calculated by ToolMintX from the values above.