Ripple-65B: what Ricursive's open-weight coding model wins, and where it trails

What is Ripple-65B?

Ripple-65B Preview is the first public model from Ricursive Intelligence, a Palo Alto lab co-founded by Anna Goldie and Azalia Mirhoseini that builds AI for chip design. It was released on 4 November 2026. Ricursive calls it "a general-purpose variant of the proprietary model that powers our AI chip design platform."

The short version of the spec sheet:

• Size: 64.8B parameters, all active on every token. That makes it a dense transformer model, not a mixture of experts.
• Training: pretrained from scratch on 12 trillion tokens of text and code, mostly English. No images, no audio.
• Context: up to 1M tokens supported, with 2M positions allowed in the config.
• License: Apache 2.0 on every checkpoint, so commercial use is fine.
• Focus: Ricursive says the Preview had "relatively light posttraining, with a focus on agentic coding."

It ships as four Hugging Face repos: the instruction-tuned BF16 model (about 130 GB), an NVFP4 version labeled "Experimental" (about 57 GB), a base model with no post-training, and a 4B "DFlash2" draft model that speeds up generation through speculative decoding.

I build integrations and API features at eesel, so when a model like this drops, the first thing I read isn't the launch chart. It's the config file, the chat template and the serving scripts, because that is where you find out what you can actually use on Monday. Everything below comes from those files, the model card and the provider pages, checked on 5 November 2026.

What is new about Ripple-65B?

Three things set it apart from the other US open-weight releases this year.

It is dense when everyone else went MoE. Reflection Beam, Meta Muse Spark Open, Inkling and Nemotron 3 Ultra all use mixture-of-experts designs, where only a slice of the model runs per token. Ripple runs all 65B every time. Ricursive's argument, from the model card, is that a dense model "reduce[s] pretraining and posttraining infrastructure complexity," which let a team that grew from 1 to 5 people train it with "simple sharding, no custom kernels, and no quantization." The shape is unusual too: thin and deep, with a narrow 5,120-wide hidden layer stacked 80 layers tall, and four short-window attention layers for every full one.

It claims to be cheap to make. Ricursive says it spent $32M on the whole project, and the blog is specific that this is "our full R&D cost starting from scratch, including pretraining ladder development, data mixing, evals, debugging" and the final runs, not just one training run. The "one-tenth the cost" comparison is softer than it sounds. Its footnote rests on a TechCrunch report that Reflection committed $150M a month for compute, plus Reflection's statement that Beam took about eight weeks. So it is Ricursive's estimate of a competitor's spend, not a number Reflection published.

It needed fewer reinforcement learning runs. Ricursive says it reached its Terminal-Bench score with 1.4M rollouts, "roughly 70x fewer rollouts than Reflection Beam." It also says it bought no post-training data and built its own synthetic data pipelines instead.

What do Ripple-65B's benchmarks say?

Ripple-65B scores 80.5 on Terminal-Bench 2.1, the headline number, which tests whether a model can finish real tasks inside a terminal. That edges out Reflection Beam at 80.1 and beats Muse Spark Open (76.4), Inkling (63.8) and Nemotron 3 Ultra (56.4) on each lab's self-reported scores.

That chart is the whole pitch: score against size, with Ripple sitting far to the left of the curve. It also places smaller US models like Nemotron 3.5 Bolt (53.9) and Nemotron 3.5 Super (66.7) on the same line. On size-adjusted coding, Ripple is clearly ahead.

The full table on the model card tells a more mixed story. Here are the rows that matter for coding agents, Ricursive's own numbers:

Four things stand out when you read the table closely.

1. It leads on 2 of 22 rows. Terminal-Bench 2.1 and SWE-bench Pro v2.0 Hard. On SWE-bench Verified and Pro v1.0, Reflection Beam is ahead. On DeepSWE, MCP Atlas and SciCode, Muse Spark Open is.
2. The rerun helps Ripple most. When Ricursive reran Terminal-Bench 2.1 on the official Terminus 2 harness, Beam dropped from 80.1 to 70.8 while Muse Spark Open rose to 78.7. The card says scores "were universally lower" on that harness except for Muse, and calls its results "a best-effort attempt at a fair comparison." That is honest, and it also means the wider gap comes from Ricursive's own test runs.
3. Several rival scores are Ricursive's runs, not the rivals'. The card marks in-house results in italics, and those cover most of the low numbers, like Inkling's 2.0 on SWE-bench Pro v2.0 Hard. Ricursive's launch blog shows different values for some of those same cells (39.6 for Inkling, 72.4 for Muse), so treat those rows with care until the tech report lands.
4. Chinese open-weight models are left out. The comparison is framed as "U.S. open-weight," so there is no DeepSeek, Qwen or Kimi in the instruct table. If your shortlist includes DeepSeek V4.1 Flash or Qwen 3.8 Flash Next, you will have to run your own comparison.

None of these benchmarks has been checked by an outside lab yet. Until someone reruns them, the safe reading is "a 65B dense model that competes with the best US open-weight models on coding," not "the best open-weight coding model."

How much does Ripple-65B cost?

The weights are free under Apache 2.0. Hosted, Ripple-65B costs $0.20 per million input tokens and $0.60 per million output tokens, with cached input at $0.05. That is the same on GMI Cloud directly and on OpenRouter, where GMI Cloud is the only provider.

Here is how that compares with nearby models, using OpenRouter's list prices on 5 November 2026:

Ripple is the cheapest US open-weight option on output in that table. Two things on the listing matter more than the price, though.

• The hosted context is 16K. OpenRouter caps it at 16,384 tokens with a 14,745-token output limit, even though the model card and GMI's own page say 1M. A coding agent working in a real repo burns through 16K fast, so check this before you wire Ripple into anything.
• One provider means thin capacity. With GMI Cloud as the only host, OpenRouter's uptime panel showed about 51% over the previous day when I checked. Ricursive also said Ripple would come to Together AI and Fireworks. On 5 November, Together's page still read "This model is coming soon to Together's Serverless API."

Can you run Ripple-65B locally?

Yes, on NVIDIA hardware, and this is the most interesting part of the release. Ricursive ships two documented setups, and the context window you get depends on which one you pick.

On a DGX Spark. The NVFP4 repo includes a notebook and a spark.py script for NVIDIA's desktop AI box. It loads the NVFP4 weights (4-bit for the feed-forward layers, BF16 for attention) plus the DFlash2 draft model, and serves one request at a time at a 128K context. The script refuses to run on anything that isn't a GB10 chip. Ricursive doesn't publish a tokens-per-second figure for the Spark.

On two B200 GPUs. The BF16 repo has a server setup on SGLang 0.5.19 that serves the full 1M context, with Ricursive quoting "250 tok/s on 2xB200 batch=8 prior to quantization or custom kernels." Four GPUs give you two independent copies.

On a Mac or anything else. There is no official path. The co-founder's launch post said "You can run Ripple-65B locally and efficiently on a MacBook Pro," but no MacBook, MLX or llama.cpp instructions appear in the blog or any of the four model cards. Community GGUF conversions showed up on Hugging Face within a day; Ricursive hasn't tested them.

Speed is the open question. A dense model reads every weight for every token, so it leans hard on memory bandwidth, which is the Spark's weak spot. That came up within hours of launch:

"What tok/s are you getting on the Spark? 65B dense on ~273GB/s of memory bandwidth has to crawl in an agent loop."

Lloyd Wilson, X

The draft model is Ricursive's answer to that, since speculative decoding lets the small model guess several tokens that the big one checks in a single pass. Whether that gets agent loops to a usable speed on a Spark is something nobody had measured publicly by 5 November.

How do you call Ripple-65B from code?

Both GMI Cloud and OpenRouter expose an OpenAI-compatible chat endpoint, so any SDK or agent framework that speaks that format works. On OpenRouter the model ID is ricursiveai/ripple-65b-preview:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ricursiveai/ripple-65b-preview",
    "messages": [{"role": "user", "content": "Write a bash one-liner that finds the 10 largest files in a repo."}],
    "temperature": 0
  }'

A few details from the chat template that are worth knowing before you build on it:

• Tool calling is native. Tools go in the system prompt and calls come back as JSON inside <tool_call> tags, which SGLang's ripple parser turns into standard tool_calls. If you force a call with tool_choice: "required", set strict: true, because Ricursive found that "non-strict required calls produced extra argument fields."
• Reasoning is always on. The template wraps thinking in <think> tags and "does not implement a thinking on/off switch or reasoning-effort levels." You pay output tokens for that thinking on every call.
• No sampling defaults. Ricursive publishes no recommended temperature; its own examples use 0.

If you plan to drive Ripple from a coding agent like Claude Code or an agentic coding CLI, the 16K hosted context is the limit you will hit first. Self-hosting is the way around it today.

What are developers saying about Ripple-65B?

The main Hacker News thread reached 181 points and 61 comments on launch day. Two themes dominated: the benchmark framing, and whether a 65B dense model is practical at home.

On the framing, the most common complaint was that the comparison stops at US models:

"Category narrowing to this degree really has diluted the term "SOTA" quite a lot"

advael, Hacker News

Others pointed at the size of the lead itself:

"Still they score 0.42 percentage points higher than the second-best model on their chosen benchmark, so it's hardly a meaningful lead."

yorwba, Hacker News

The counterpoint came from people for whom "US-made" is a real requirement, not a marketing label:

"US Gov won't let Chinese models be hosted on any internal infra ... So there is absolutely a market for US-made or non-Chinese models there."

Onawa, Hacker News

On running it at home, opinion split. One commenter expected that "inference will be prohibitively slow on consumer grade hardware" and read the release as aimed at chip-design teams in air-gapped setups, which fits Ricursive's own business. Owners of high-memory Mac Studios were more upbeat, since 130 GB of weights sits well under what their clusters hold. Nobody had posted measured speeds by the morning of 5 November.

The cost claim got the warmest reception. swyx called the release "the avengers of open model SOTA" and quoted the footnote that the $32M covers the whole R&D effort, which was the detail most people found striking.

Should you use Ripple-65B for customer support?

Probably not as the brain of a support bot, and the reason is fit, not quality. Ripple-65B is a coding model with light post-training. The rows in Ricursive's own table closest to support work are middling: 31.27 on τ³-bench banking, which tests policy-following conversations with a customer (Beam scores 36.1), and 71.67 on MCP Atlas, which tests tool use (Muse Spark Open scores 89.2). The one strong case is data control: if customer data can never leave your network, an Apache 2.0 model on your own hardware is a real option, and Ripple is one of the smallest strong ones.

Even then, the model is the easy part. To answer tickets well you also need knowledge base connections, escalation rules, guardrails against made-up answers, and a way to check replies before customers see them. That is the trade-off in build vs buy for AI support, and it is most of the work.

That gap is what eesel fills. eesel is an AI teammate platform, and its AI helpdesk teammate joins your existing helpdesk, learns from your help center and past tickets, and works in your queue. I've seen confident-sounding bots give wrong answers on live queues, which is why every eesel rollout runs against historical tickets first, so you can read what it would have said before it touches a customer.

Timengo is a good example on the technical end. It sells secure email and Digital Post software in Denmark, and eesel drafts its technical support replies in Danish from about 5,300 past tickets and help center articles, preparing around 300 Freshdesk tickets in a month. SE Ranking runs three products on Zendesk with one eesel agent each, which handled 4,650 conversations in one month.

And if you were looking at Ripple because you like working from a terminal, the eesel CLI fits that habit. A coding agent can use it to upload approved knowledge like exported help articles and macros, edit the teammate's instructions, and ask test questions to check the answers before anything goes live. Connecting the helpdesk itself still needs someone with admin access to approve it. There's more on that workflow in managing agents from the terminal.

Who should use Ripple-65B?

Here's my take after reading every file Ricursive published:

• Try it if you want a coding model you can own outright. Apache 2.0, a single-box local path and $0.60 per million output tokens hosted make it cheap to test against your own repo, and it is a natural candidate for teams that can only run US-made models.
• Self-host it if you need long context. The hosted 16K limit rules out serious agent work today; the 1M context only comes with your own GPUs.
• Wait if you need proof. There is no tech report yet, the benchmark sources disagree on some cells, and no outside lab has rerun the numbers. A few weeks of independent testing will settle a lot.
• Look elsewhere if price is the whole decision. DeepSeek V4.1 Flash is cheaper on both input and output, and Kimi K3.1 Pro has been tested more widely. For a broader shortlist, see the best AI coding assistant tools.

The fair summary: Ripple-65B Preview shows that a small team with a dense 65B model can land in the same range as US open-weight models eight to fifteen times its size on coding, for a reported $32M. That's a real result. "State of the art" only holds inside a narrow category, and the way to find out whether it holds for your work is to run it on your own tasks.

Try eesel

If you came to Ripple-65B hoping an open model could take tickets off your team, you can skip building the support layer yourself. eesel's AI helpdesk teammate plugs into Zendesk, Freshdesk, Gorgias and more in minutes, learns from your past tickets, and shows you how it would have answered them before it goes live. Plans start at $299 a month, and there's a free tier to test on.

Try eesel for free.