Ripple-65B Preview: 39GB to 46GB in Ollama, Apache 2.0, and 64 KiB of KV Cache per Token

Ricursive's Ripple-65B Preview is a dense Apache 2.0 coding model, 39GB to 46GB in Ollama. Memory arithmetic, the 1M vs 2M context gap, and what to test.

Ollama v0.40.16, published November 9, added Ripple-65B Preview from Ricursive Intelligence as ollama run ripple-preview: a 65B-parameter dense Transformer under Apache 2.0, with the default tag listed at 39GB to 46GB. Ollama v0.40.16 release notes · Ollama tag list The Hugging Face repository was created on November 4, llama.cpp merged support on November 5, and Ricursive’s launch post is dated November 11. Hugging Face model API · llama.cpp PR #31692 · Ricursive’s launch post

S5 Labs has not run the model. Ricursive Intelligence (ricursiveAI on Hugging Face) is not Recursive, whose Flint coding model we covered in October. The names are spelled differently on the two model cards, and we found nothing connecting the companies.

What the repository and config state

ItemValue
Parameters64,782,689,360 in BF16; the card describes a dense Transformer
Licenseapache-2.0 in the card metadata; the repository is not gated
Shape80 layers, hidden size 5120, 80 attention heads, 8 KV heads, head dimension 128
Attention64 sliding-window layers with a 1,024-token window; every fifth layer, 16 in all, uses full attention
BF16 weights16 safetensors shards, about 129.6 GB
TransformersCustom RicursiveForCausalLM code loaded through auto_map, so it needs trust_remote_code
Training12T text-only tokens, predominantly English and code, pretrained at 8K sequence length
Post-trainingThe card says the Preview has had “relatively light” post-training, with a focus on agentic coding

Sources: model card (license, training), model API (parameters, shards), config.json (the rest).

Ricursive’s organization also holds an NVFP4 instruct checkpoint, a pretrain-only base model and DFlash2, a 4.04B-parameter draft model for speculative decoding. Organization listing The NVFP4 README says the MLP layers are quantized and attention stays in BF16. Its six shards total about 57.2 GB, and it gives no accuracy comparison, hardware requirement or serving instructions. NVFP4 repository

The card says 1M tokens of context and the config says 2M

The model card advertises support for up to 1,048,576 tokens, and the launch post and Ollama’s readme both say up to 1M. Model card · Launch post · Ollama library page Three other places say 2M: the config sets max_position_embeddings to 2,097,152, the card’s training table lists two long-context stages at a 2M sequence length (6.5B and 13.5B tokens), and every Ollama tag lists a 2M context window. config.json · Ollama tag list

Ricursive does not reconcile the two figures, and we found no published long-context memory or quality test on local hardware. The only long-context benchmark in the card’s table is AA-LCR, where Ripple’s 75.0 is behind three of the four larger models it is compared with, and the card does not give the context length tested. The two 2M stages add up to 20B tokens, against 12T of pretraining at 8K, so test long-range recall before you build on either figure.

The KV cache costs 64 KiB per token on the 16 full-attention layers

Our KV cache explainer uses 2 × layers × KV heads × head dimension × bytes per element. Only the full-attention layers grow with context, so for Ripple that is 2 × 16 × 8 × 128 × 2 = 65,536 bytes per token. This is S5 Labs arithmetic from the config, and we found no measured figure to check it against.

Context (tokens)BF16 KV cache, full-attention layers
32,7682 GiB
131,0728 GiB (about 8.6 GB)
1,048,57664 GiB (about 68.7 GB)
2,097,152128 GiB (about 137 GB)

The assumptions are a BF16 cache, one sequence, and a runtime that caps the 64 sliding layers at their 1,024-token window, where they add a roughly constant 256 MiB. The llama.cpp merge commit describes sliding-window attention as mandatory, which supports that cap there. llama.cpp PR #31692 The table leaves out runtime overhead, any KV quantization a runtime applies, and anything a runtime stores for the value residuals, which the card lists among its architecture additions (use_valres is true in the config).

Subtracting Ollama’s listed build sizes from three common memory sizes, with Ollama’s GB and the machine’s GB treated as the same unit, gives the room left for everything else:

MemoryLeft after the 39GB buildLeft after the 46GB build
48 GB9 GB2 GB
64 GB25 GB18 GB
128 GB89 GB82 GB

On 48 GB, the 39GB build leaves 9 GB for the operating system, the runtime and the cache, and a 131,072-token cache is about 8.6 GB of that, so plan for a much shorter context. On 64 GB, a 131,072-token cache leaves roughly 9 to 16 GB uncounted, and a 1M-token cache is larger than the machine’s whole memory. On 128 GB, a 1M-token cache leaves about 13 to 20 GB uncounted, and a 2M-token cache exceeds the memory before any weights load.

These are budgets on paper, and we found no measured footprint. Our Local LLM Machines guide covers the general method. On unified-memory machines the operating system and open applications draw from the same pool, as we noted for RTX Spark.

The card names a different NVIDIA product: at 65B total parameters, it says, the model “can fit on consumer hardware such as the NVIDIA DGX Spark.” It gives no memory figure, precision or speed for that machine. The only speed on the card is Ricursive’s 250 tokens per second on two B200 datacenter GPUs at batch size 8, before quantization or custom kernels. Model card

Ollama’s default tag is not a named quant

TagListed size
latest, 65b39GB to 46GB
65b-q4_K_M39GB
65b-nvfp4 (MLX)46GB
65b-gguf-bf16130GB
65b-mlx-bf16 (MLX)138GB
65b-bf16130GB to 138GB

Source: Ollama tag list.

The default tag’s digest differs from both the q4_K_M and nvfp4 digests, and the page does not say which build a given platform receives. We found the same pattern with Flint in October. If you need to know what you benchmarked, pull a named tag. Ollama’s 46GB 65b-nvfp4 is also a different artifact from the 57.2 GB Hugging Face NVFP4 repository, and neither page explains the difference.

Ollama’s readme says Ripple uses DFlash 2 speculative decoding on its MLX engine and gives no speedup figure. Ollama library page The DFlash2 card documents SGLang flags only. DFlash2 repository

Ricursive’s benchmark table, and where Ripple trails

Ricursive reports 80.52 on Terminal-Bench 2.1 and compares Ripple with four models of 501B to 975B total parameters. Every number below is from Ricursive’s card, and the rows are its Coding & Agentic section in the card’s order. The card italicizes scores that come from Ricursive’s in-house eval flow, which it used where no official model card score was available, and the italics are carried over here.

BenchmarkRipple-65BMuse Spark Open 816BBeam 501B
Terminal-Bench 2.1, self-reported80.576.480.1
Terminal-Bench 2.1, Terminus 280.578.770.8
SWE-bench Verified76.578.781.6
SWE-bench Pro v1.061.4258.266.1
SWE-bench Pro v2.0 Hard79.172.476.5
DeepSWE 1.144.360.043.3
SciCode (Inspect AI)39.458.549.2
tau3-bench banking31.2714.436.1
AutomationBench (Public)36.442.439.3
MCP Atlas71.6789.280.8

Nemotron 3 Ultra 550B and Inkling 975B, both below Ripple in the two Terminal-Bench rows, are left out for width. Ripple trails Beam on six of the ten rows. It trails Muse Spark Open on five, by 15.7 points on DeepSWE 1.1, 17.5 on MCP Atlas and 19.1 on SciCode, with smaller gaps on SWE-bench Verified and AutomationBench. It leads none of the card’s Knowledge and Math rows.

The card says scores under the official Terminus 2 harness, at a 128K sequence length with summarization, were lower for every model except Muse Spark Open. Ripple’s own figure is 80.5 in both rows, and the page does not explain why. The card also says the compared models ran at full BF16 and maximum effort. The NVFP4 repository carries no evals, so no published score covers a quantized build.

The 80.1 for Beam matches what Reflection published, per our Beam article; the 70.8 is Ricursive’s rerun. We found no independent replication and no leaderboard entry. On licensing, Ripple is ungated under Apache 2.0, while Muse Spark Open was gated under Meta’s own license when we covered it.

llama.cpp support and two user reports

PR #31692 added a new ricursive architecture to llama.cpp. The author reports matching the vendor code on a tiny random model and on the first 10 real layers, and discloses that Claude Code wrote the code, which the author checked and tested. llama.cpp PR #31692 Two comments in the thread come from other users.

A user on a Strix Halo mini PC with a Vulkan build got an error saying the pre-allocated cache_k_l4 tensor sat in a buffer that cannot run SET_ROWS. The PR author guessed that a single KV tensor is capped by Vulkan’s maxStorageBufferRange, which the full-attention layers would exceed at 1M to 2M context. The report gave no context length, and the thread does not confirm a fix. Layer index 4 is the first full-attention layer in the config, which by our reading is consistent with the guess without confirming it.

A second user, with three Radeon AI PRO R9700 cards on ROCm 7.2.1, measured 8.4 tokens per second on Q8_0 and 10.8 on Q6_K (llama-bench, tg128) and judged the output correct. The tests ran at PR commit ebe7f66, before the then-current head commit (cccba7f), which the commenter said did not build on its own. That is one multi-GPU setup, and the only local speed figure we found.

Two API behavior changes in v0.40.16

The same release changes two OpenAI-compatible behaviors. /v1/responses now respects truncation and no longer truncates silently by default, and /v1/models returns an empty list instead of null when no models are installed. The release page has no migration notes and does not say what an over-length request returns now, so an agent that relied on silent trimming in long sessions may behave differently after the upgrade. Ollama v0.40.16 release notes

What to test first

  • Pull a named tag, ripple-preview:65b-q4_K_M or 65b-nvfp4 on MLX, and record the digest with your results.
  • Set the context length explicitly, since we could not confirm what Ollama allocates by default. Measure memory at 32,768 and 131,072 tokens and compare with the table above. The gap is the overhead we could not find a published figure for.
  • Before trusting 1M, put a fact early in a long session and ask for it late. On Vulkan, raise the context in steps and note where allocation fails.
  • Run your own coding tasks on the quantized build. The published scores are Ricursive’s, and none covers a quant.
  • Send one over-length request to /v1/responses on a staging box, then set truncation deliberately.
  • For a hosted route, the launch post lists Together AI, GMI Cloud, OpenRouter and Fireworks. We did not open those pages; check price and context limit there.

With named builds listed at 39GB and 46GB, Ripple is worth testing for terminal-style agent work, where Ricursive’s table shows its best results, on any machine where the arithmetic above leaves room. Do not plan a local deployment around the 1M figure, and keep your hosted coding model until someone outside Ricursive reproduces the scores.

Reference guide

The Open Models guide compares open-weight models by license, hardware and task fit.

The Local LLM Machines guide compares machines for running models locally.

Continue reading.

Insight11 min read

Recursive Flint: An Apache 2.0 Coding MoE With 2.5B Active Parameters and a 23 GB Ollama Build

Recursive's Flint is a 39.8B MoE coding model with about 2.5B active parameters, Apache 2.0 weights and a 23 GB Ollama build. What the vendor numbers omit.

Insight7 min read

Kimi K2.7 Code: Moonshot Cuts Thinking Tokens 30%, But the Benchmarks Are All Its Own

Moonshot's Kimi K2.7 Code cuts reasoning tokens ~30% and undercuts the frontier on price, but every headline benchmark is first-party and unverified.

Insight3 min read

Alibaba's Qwen3.5-9B: A 9-Billion Parameter Model Beating 120-Billion

Alibaba's new small model series proves that running frontier-class AI on a laptop isn't a distant dream — it's happening now.