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
| Item | Value |
|---|---|
| Parameters | 64,782,689,360 in BF16; the card describes a dense Transformer |
| License | apache-2.0 in the card metadata; the repository is not gated |
| Shape | 80 layers, hidden size 5120, 80 attention heads, 8 KV heads, head dimension 128 |
| Attention | 64 sliding-window layers with a 1,024-token window; every fifth layer, 16 in all, uses full attention |
| BF16 weights | 16 safetensors shards, about 129.6 GB |
| Transformers | Custom RicursiveForCausalLM code loaded through auto_map, so it needs trust_remote_code |
| Training | 12T text-only tokens, predominantly English and code, pretrained at 8K sequence length |
| Post-training | The 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,768 | 2 GiB |
| 131,072 | 8 GiB (about 8.6 GB) |
| 1,048,576 | 64 GiB (about 68.7 GB) |
| 2,097,152 | 128 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:
| Memory | Left after the 39GB build | Left after the 46GB build |
|---|---|---|
| 48 GB | 9 GB | 2 GB |
| 64 GB | 25 GB | 18 GB |
| 128 GB | 89 GB | 82 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
| Tag | Listed size |
|---|---|
latest, 65b | 39GB to 46GB |
65b-q4_K_M | 39GB |
65b-nvfp4 (MLX) | 46GB |
65b-gguf-bf16 | 130GB |
65b-mlx-bf16 (MLX) | 138GB |
65b-bf16 | 130GB 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.
| Benchmark | Ripple-65B | Muse Spark Open 816B | Beam 501B |
|---|---|---|---|
| Terminal-Bench 2.1, self-reported | 80.5 | 76.4 | 80.1 |
| Terminal-Bench 2.1, Terminus 2 | 80.5 | 78.7 | 70.8 |
| SWE-bench Verified | 76.5 | 78.7 | 81.6 |
| SWE-bench Pro v1.0 | 61.42 | 58.2 | 66.1 |
| SWE-bench Pro v2.0 Hard | 79.1 | 72.4 | 76.5 |
| DeepSWE 1.1 | 44.3 | 60.0 | 43.3 |
| SciCode (Inspect AI) | 39.4 | 58.5 | 49.2 |
| tau3-bench banking | 31.27 | 14.4 | 36.1 |
| AutomationBench (Public) | 36.4 | 42.4 | 39.3 |
| MCP Atlas | 71.67 | 89.2 | 80.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_Mor65b-nvfp4on 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/responseson a staging box, then settruncationdeliberately. - 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.
