Ripple-65B Preview: 80.52 on Terminal-Bench, Apache 2.0, 16K API

Ricursive Intelligence released Ripple-65B Preview on November 4, 2026: a 65-billion-parameter dense Transformer with open weights, Apache 2.0, and a vendor-reported 80.52 on Terminal-Bench 2.1. The company calls it U.S. open-weight state of the art for agentic coding, ahead of Reflection Beam 501B at 80.1 and Meta Muse Spark Open 816B at 76.4 — models seven to fifteen times larger in total parameters.

The benchmark is the headline. The three numbers that actually change what you can do are 129.6 GB of BF16 weights, an Apache 2.0 license with no commercial threshold, and a reported $32M total R&D cost. That combination makes "a terminal agent you can fine-tune and ship without a lawyer" a realistic option for a small team. It also comes with three traps that will cost you a day each if you read the launch post and stop there.

What actually landed on Hugging Face

Four repositories went up on release day. The differences determine your hardware bill, so start here.

• Ripple-65B Preview — the instruction-tuned BF16 checkpoint, 16 safetensors shards totalling 129.57 GB, Apache 2.0, not gated.- Ripple-65B Preview NVFP4 — an experimental 4-bit build at 57.22 GB across 6 shards, quantizing the MLP layers while keeping attention in BF16.- Ripple-65B Base Preview — the pretrain-only checkpoint: no midtraining, no synthetic QA data, also 129.57 GB.- Ripple-65B Preview DFlash2 — an 8.08 GB draft model for speculative decoding, 4.04B parameters, drafting blocks of 16 tokens.

The architecture is a deliberate throwback. Where most labs at this size have moved to mixture-of-experts, Ricursive built a dense model, thin and deep: d_model 5,120, 80 layers, 80 attention heads sharing 8 key-value heads, a 100,352-token vocabulary, and a hybrid pattern of 1,024-token sliding-window layers plus global layers. FFN activation clipping, gated attention, global NoPE and value residuals came out of laddering up from an Olmo 3 baseline. Training ran 12T tokens of pretraining at 8K, 200B of midtraining at 64K, 6.5B of long-context extension at 2M, 183B of SFT at 128K, and 700 RL steps. The team reports 40% MFU with no custom kernels.

Trap 1: the 1M context lives in the weights, not in the API

The model card advertises context "up to 1M" tokens. The config lists max_position_embeddings at 2,097,152. The first commercial endpoint, on Together AI, serves 16,384 tokens with a 14,745-token output ceiling. Together's own model page describes the model as having a "128K-token context window."

Nobody is lying; the numbers describe different things, and the arithmetic explains it. With 80 layers, 8 KV heads, head dimension 128 and BF16 storage, each layer costs about 4,096 bytes of cache per token — roughly 0.33 MB across all layers. At 16,384 tokens that is about 5.4 GB. If every layer attended globally at a million tokens, it would be about 344 GB of KV cache on top of 130 GB of weights. The sliding window is what makes 1M conceivable: if a minority of layers are global, a million tokens costs roughly 69 GB instead of 344 GB. Large, but servable on a multi-GPU node. The exact split comes from the hybrid layer pattern in config.json, and that split — not the headline — is your memory bill.

So treat them as two facts. One million tokens is an architectural capability that exists in the weights and needs a serious node to serve. Sixteen thousand is what the first hosted endpoint sells: enough for most agent loops, not enough for repository-scale reasoning or long-document work.

Trap 2: "runs locally" means 57 GB, not 130

The launch post says the model can run on hardware like NVIDIA DGX Spark. That has hardened in coverage into "runs on a MacBook." The download sizes tell you which artifact each claim is about. The BF16 instruct checkpoint is 129.57 GB before any KV cache — a 192 GB-class accelerator or a multi-GPU split. The NVFP4 build is 57.22 GB, which fits a 128 GB unified-memory machine with room for a working context, and it is explicitly labelled experimental with attention left in BF16. The 250 tok/s figure is a datacenter number: 2×B200 at batch 8, before quantization. On a Spark you trade throughput for the box being on your desk.

Trap 3: the score is self-reported, and it does not travel

Every number in Ricursive's table was produced by Ricursive's eval flow. As of November 5 there was no Artificial Analysis entry and no third-party reproduction of 80.52. That is normal for a one-day-old preview, not suspicious — but it means you should treat the table as a claim about a real artifact, not a measurement.

What makes the table more credible than the usual vendor sheet is a second column. Ricursive re-ran the comparison under the official Terminus 2 harness at 128K with summarization. Ripple held at 80.5 while rivals moved: Muse Spark rose from 76.4 to 78.7, Reflection Beam dropped from 80.1 to 70.8, Inkling from 63.8 to 56.2, Nemotron from 56.4 to 55.1. A lab that publishes the harness where its own score is flat and its competitors' scores collapse is doing something most launch posts avoid. The gradient runs the right way, and the numbers are still the lab grading its own homework.

The claim also stops travelling as soon as you leave the terminal. On DeepSWE 1.1, Ripple scores 44.3 against Muse Spark's 60.0. On MCP Atlas it is 71.67, behind Muse Spark at 89.2 and Inkling at 76.0. On SciCode it is last of the five at 39.4. The pattern is consistent: strong at long-horizon terminal work and multi-step software tasks, ordinary at scientific code generation and tool-protocol breadth. If your workload is an agent clicking through a shell, this release is aimed at you. If it is an MCP-heavy assistant, it is not.

One more qualifier worth not skipping: "U.S. open-weight state of the art" excludes DeepSeek, Qwen and every non-U.S. lab. It is a claim about the best open-weight model trained inside the United States, not the best open-weight model.

The base model is the more honest document

The Base Preview card contains a sentence the launch post does not lead with: the pretrained checkpoint is "comparable with DeepSeek V3.1 and V4 Flash on reasoning, math, and code," while Nemotron 3 Ultra "dominates on traditional pretraining evals." The numbers back the modesty. Base MMLU-Pro is 61.5 against 68.3 for DeepSeek V4 Flash 284B and 79.1 for Nemotron 3 Ultra 550B. Base GPQA Diamond is 38.4 against V4 Flash's 44.4.

Read the two tables together and the story sharpens. Ripple's pretrained prior is respectable but mid-pack for a 12T-token run — the smallest pretraining budget in its own comparison set, against 20T for Nemotron and 32T+ for V4 Flash. Almost all of the agentic-coding advantage comes from the post-training stack. Ricursive says it reached 80.5 in 1.4M RL rollouts, roughly 70x fewer than Reflection Beam needed. That is a more interesting result than the benchmark table, and a more fragile one: a heavy RL climb on synthetic long-horizon environments is exactly the kind of recipe that transfers unevenly to tasks the lab did not train against.

What a call costs

The first hosted endpoint lists $0.20 per million input tokens and $0.60 per million output, with cached input reads at $0.05. A realistic agent call — a 16,000-token prompt returning 2,000 tokens — is $0.0032 in and $0.0012 out, about $0.0044. Push 10 million tokens a day at an 80/20 split and you are at roughly $2.80.

Caching is the lever worth pulling. A repeated 16,000-token system prompt costs $0.0008 at the cached rate instead of $0.0032 — a 4x cut on input, which for an agent that re-sends the same tool definitions every turn is most of the bill. At that price the experiment is cheap; the risk is architectural, not financial.

Who should try it this week

Try it now if you are building a terminal or shell agent, you want an Apache 2.0 checkpoint you can fine-tune without a negotiated agreement, and a 16K window is enough for your loop. The dense architecture is a genuine serving advantage on modest hardware — no expert routing, no all-to-all, predictable latency.

Wait if you need long context from a hosted endpoint, if your work is MCP-heavy or scientific code, or if you need any number that was not produced by the lab that trained the model.

Three things would settle it: a harness run by someone who did not train the model, a host serving more than 16,384 tokens, and a non-preview checkpoint. Ricursive has been explicit that post-training here was light and that the internal variant behind its chip-design platform is the product it is really building. Until then, the headline is a claim and the download is real — and the gap between them is exactly where the next month of evaluation happens.