Ripple-65B Preview: Apache 2.0 Weights, a 1M-Token Claim and a 16K API

Ripple-65B Preview, released by Ricursive Intelligence on 4 November 2026, is two different products depending on how you reach it. The download is 129.6 GB of Apache 2.0 weights whose model card advertises context “up to 1M” tokens. The first commercial endpoint carrying the same checkpoint advertises 16,384. Both numbers describe the same model, and the distance between them is the most useful thing a developer can know about this release before spending a day on it.

The lab’s headline is narrower than the launch post makes it sound and more interesting than the coverage so far has noticed. Ricursive claims a U.S. open-weight state of the art on agentic coding — 80.52 on Terminal-Bench 2.1 — from a 65B dense model trained for a reported $32M. That is a real claim about a real artefact: the weights are downloadable, ungated, and licensed for commercial use without a negotiated agreement. It is also, as of 5 November, entirely vendor-reported. Artificial Analysis has no entry for the model.

What actually landed on Hugging Face

Four repositories went up on 4 November, and the distinctions matter because they change what hardware you need:

• Ripple-65B Preview — the BF16 instruction-tuned 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, quantising 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 against the target model.

The architecture is a deliberate throwback. Where every other lab at this size has gone mixture-of-experts, Ricursive built a dense Transformer, thin and deep: d_model 5120, 80 layers, 80 attention heads sharing 8 key-value heads, a 100,352-token vocabulary, and a 1,024-token sliding window applied across a hybrid layer pattern. FFN activation clipping, gated attention, global NoPE and value residuals round out the modifications the team picked up while laddering from an Olmo 3 baseline.

The training stack is published in more detail than most cards bother with: 12T tokens of pretraining at 8K sequence length, 200B tokens of midtraining at 64K, 6.5B tokens of long-context extension at 2M, 183B tokens of SFT at 128K, and 700 RL steps at 128K. The team went from one person to five during development, and reports 40% MFU with no custom kernels.

One naming caution, because search results are already muddling it: Ricursive Intelligence is the chip-design lab whose launch post describes co-optimising hardware, software and models. It is not Recursive, the self-improving-AI startup behind Flint. The two companies are unrelated, and coverage that blends them is wrong.

The benchmark claim, and how far it travels

Terminal-Bench 2.1 is where the launch lives or dies, and the number is 80.52. Ricursive puts it ahead of Reflection Beam 501B at 80.1, Meta Muse Spark Open 816B at 76.4, Thinking Machines Inkling 975B at 63.8, and NVIDIA Nemotron 3 Ultra 550B at 56.4 — all of them between seven and fifteen times larger in total parameters.

What makes that table worth more than the usual vendor sheet is a second column. Ricursive re-ran the comparison under the official Terminus 2 harness at 128K with summarisation, and reports that scores moved almost everywhere except its own: Ripple held at 80.5, Muse Spark rose 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. It is still a lab grading its own homework — every number in that table was produced by Ricursive’s eval flow — but the gradient runs the right way.

The claim 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, behind Beam at 49.2 and Muse Spark at 58.5. The pattern is consistent: Ripple is strong at long-horizon terminal work and multi-step software tasks, and ordinary at scientific code generation and tool-protocol breadth. If your workload is an agent clicking through a shell, the claim is aimed at you. If it is an MCP-heavy assistant, it is not.

And the framing is doing quiet work. “U.S. open-weight state of the art” is a qualifier, not a prefix to skip. It excludes DeepSeek, Qwen and every other non-U.S. lab, so 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 up. 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, well below V4 Flash at 44.4.

Read those 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 is coming from the post-training stack: the midtraining data mix, the long-context extension, and 700 RL steps that Ricursive says reached 80.5 in 1.4M 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.

Why the context number is two numbers

The model card says 1M. The config says max_position_embeddings 2,097,152. The hosted endpoint says 16,384 with a 14,745-token output ceiling. Nobody is lying; these are three different things, and the arithmetic explains why the first host picked the number it did.

KV cache is where long context gets paid for. With 80 layers, 8 KV heads, a head dimension of 128 and BF16 storage, each layer costs 4,096 bytes of cache per token — 2,048 for keys and 2,048 for values. Across all 80 layers that is roughly 0.33 MB per token. At the endpoint’s 16,384 tokens, that is about 5.4 GB. At a million tokens with every layer attending globally, it would be roughly 344 GB of cache sitting on top of 130 GB of weights.

That is what the sliding window is for. Most of Ripple’s layers attend within a 1,024-token window; a minority attend globally, and only those grow with context. If 16 of the 80 layers are global, a million tokens costs about 69 GB of cache instead of 344 GB — large, but servable on a multi-GPU node. The precise split is set by the hybrid layer pattern in config.json, and it is the first thing to check with whatever serving stack you use, because that split, not the headline, is your memory bill.

So treat the two numbers as two facts. One million tokens is an architectural capability that exists in the weights and would need a serious node to serve. Sixteen thousand is what the first commercial endpoint offers — enough for most agent loops, not enough for repository-scale reasoning or long-document work. If your reason for trying Ripple-65B Preview was the 1M context, the hosted route does not give it to you today, and self-hosting is the only path that does.

Local means 57 GB, not 130

The launch post says the model “can fit on consumer hardware such as the NVIDIA DGX Spark,” and the coverage has hardened that into “runs on a MacBook.” The download sizes tell you which artefact each claim is about.

• The BF16 instruct checkpoint is 129.57 GB. On its own, before any KV cache or runtime overhead, that needs a 192 GB-class accelerator or a multi-GPU split.

• The NVFP4 build is 57.22 GB. That fits a 128 GB unified-memory box with room for a working context — and it is labelled experimental, with attention left in BF16.

• The DFlash2 drafter adds 8.08 GB and buys speculative decoding, not quality.

The 250 tok/s figure is a datacenter number: 2×B200 at batch 8, before quantisation and custom kernels. On a Spark you are trading throughput for the fact that the box is on your desk. Neither figure is wrong; they just belong to different machines, and the local story only works with the quantised checkpoint.

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. Worked through on a realistic agent call — a 16,000-token prompt against the full window, returning 2,000 tokens — that is $0.0032 in and $0.0012 out, or about $0.0044. Put 10 million tokens a day through it at an 80/20 input-output split and you are at $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 the input side — which for an agent that re-sends the same tool definitions every turn is most of the bill.

Where OrcaRouter fits: we do not carry Ripple-65B Preview today, so there is no markup to compare and no reason to pretend otherwise. What the preview does change is the case for keeping an unproven model off your production path while you measure it. Route the incumbent your traffic already depends on through one key — 200+ models, provider list price passed through at 0% markup, automatic failover when a provider wobbles — and put Ripple beside it in an offline eval rather than in front of users. If the numbers hold, the routing DSL moves a slice of traffic without a second integration; if they do not, the fallback was never in question.

Who should try it, and what would change the picture

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 lawyer, and a 16K window is enough for your loop. The dense architecture is a genuine advantage for anyone serving on modest hardware — no expert routing, no all-to-all, predictable latency — and a 65B dense model at 80.5 on Terminal-Bench is a result worth reproducing on your own tasks rather than arguing about.

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. There is no independent evaluation yet: no Artificial Analysis entry and no third-party reproduction of the 80.52. For a Preview release a day old, that is normal rather than suspicious — but it means every figure in this piece that came from Ricursive is labelled as theirs for a reason.

Three things would settle it. A second harness run by someone who did not train the model. A host serving more than 16,384 tokens, which would tell us whether the 1M context claim survives contact with a scheduler. And a non-preview checkpoint, since Ricursive has been explicit that post-training here was light and 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 will happen.