Ripple-65B is the best US-made open model you can run on one box, but it is not the best open coding model overall. It scores 80.5 on Terminal-Bench 2.1, a hair above Reflection's Beam (80.1), a model almost eight times its size. Off that row, Beam leads on five coding and agent tests, and its API gives you 1M tokens of context where Ripple's gives 16,384.
My verdict: 3.5/5. Pick Ripple for US-made Apache 2.0 weights that fit on a DGX Spark; call Beam if you just want an API. For a support agent, a ready-made teammate like eesel skips the model choice, and its CLI lets a coding agent load your help docs and test answers before go-live.
What is Ripple-65B, in one minute?
Ripple-65B Preview is an open-weight language model released on 4 November 2026 by Ricursive Intelligence, a lab that builds AI for chip design. Ricursive trained it from scratch and calls it "a general-purpose variant of the proprietary model that powers our AI chip design platform." If you want the full spec walk-through, my colleague's Ripple-65B explainer covers it; this post is the verdict.
The spec sheet, from the model card:
| Spec | Ripple-65B Preview |
|---|---|
| Parameters | 65B total, all active (dense, not mixture-of-experts) |
| Layers | 80, with 4 sliding-window layers to every 1 global layer |
| Training data | 12T tokens, text-only, mostly English and code |
| Context (claimed) | Up to 1M tokens |
| License | Apache 2.0 |
| Checkpoints | BF16 instruct, NVFP4 instruct (experimental), base, DFlash2 draft model |
| Reasoning | Always thinks in <think> tags, no on/off switch or effort levels |
| Full R&D cost | $32M, per Ricursive |
That last row is the part people are talking about. Ricursive says $32M covers its full research and development cost from scratch, and calls it "one-tenth the cost of the previous open-weight SOTA on agentic coding." The footnote shows that "one-tenth" is Ricursive's own estimate of Beam's compute bill, built from a press report and Reflection's training timeline, so treat it as a rough comparison rather than an audited one.
How did I review it?
I build the integrations behind eesel's AI agents, so I read a model card the way I'd read an API spec before wiring it into production: what the numbers are, where they came from, and what breaks when you actually call it. One thing eesel's years of putting agents on live helpdesks have shown me is that a leaderboard won't tell you what a model does on your own tickets, which is why every eesel rollout gets simulated against past tickets before it goes live.
For Ripple, I did not have API access to run my own test set on launch day, so this review is built from primary sources only:
- Ricursive's launch post, plus its Hugging Face model card with the inference scripts.
- The live listings on OpenRouter, GMI Cloud and Together AI, checked on 5 November 2026.
- The first day of developer reaction on Hacker News and X.
Ripple is not on Artificial Analysis yet, so every benchmark below is Ricursive's own number. I'll say which page each one came from, because, as you'll see, the two pages don't always agree.
How does Ripple-65B score against Beam and the other US open models?
On the two rows Ricursive leads with, Ripple wins. On most of the others, it doesn't. Here is the instruct table from the model card, trimmed to the coding and agent rows that matter for a coding-model buyer:
| Benchmark | Ripple-65B | Beam 501B | Muse Spark Open 816B | Inkling 975B | Nemotron 3 Ultra 550B |
|---|---|---|---|---|---|
| Terminal-Bench 2.1 (self-reported) | 80.5 | 80.1 | 76.4 | 63.8 | 56.4 |
| SWE-bench Pro v2.0 Hard | 79.1 | 76.5 | 52.3 | 2.0 | 30.7 |
| SWE-bench Verified | 76.5 | 81.6 | 78.7 | 77.6 | 71.9 |
| SWE-bench Pro v1.0 | 61.42 | 66.1 | 58.2 | 54.3 | 46.9 |
| DeepSWE 1.1 | 44.3 | 43.3 | 60.0 | 1.8 | 0.2 |
| MCP Atlas | 71.67 | 80.8 | 89.2 | 76.0 | 62.2 |
| τ³-bench banking | 31.27 | 36.1 | 14.4 | 23.7 | 22.6 |
| SciCode | 39.4 | 49.2 | 58.5 | 46.1 | 44.6 |
Two things jump out. First, the Terminal-Bench lead over Beam is 0.4 points, which is a tie in any honest reading. Second, Beam beats Ripple on five coding and agent rows, and Muse Spark Open, which I covered in my Muse Spark Open review, takes DeepSWE, MCP Atlas and SciCode.
That said, a 65B model matching a 501B one on its best row is still a real result. Beam has 23B active parameters per token and Ripple has all 65B active, so the comparison is less lopsided than "8x smaller" suggests, but in memory terms Ripple is far easier to host.
Which numbers should you trust?
Ricursive is upfront about the messiness. The model card says competitor scores are "official model card scores where available," and the rest are its own in-house runs. It also notes that Terminal-Bench 2.1 scores came out "universally lower (with the exception of Muse Spark Open)" on the official Terminus 2 harness, so it reports both.
On the same Terminus 2 harness, Ripple's lead over Beam grows to almost 10 points (80.5 vs 70.8). That is the most interesting number in the release, and also the one I'd verify first, because the Beam figure there is Ricursive's own run, not Reflection's.
The other wrinkle: the launch chart and the model card disagree on some competitor scores. On SWE-bench Pro v2.0 Hard, the launch post shows Muse Spark Open at 72.4 and Inkling at 39.6, while the model card has 52.3 and 2.0. Ripple's own numbers match on both pages. It's a preview launch and these will probably get reconciled, but until they do, I'd treat the competitor columns as approximate.
What does Ripple-65B cost?
Ripple is cheap to call, with one big catch. The prices below are each provider's own listing, checked 5 November 2026:
| Route | Input / 1M | Output / 1M | Cached read / 1M | Context |
|---|---|---|---|---|
| GMI Cloud | $0.20 | $0.60 | $0.05 | 1,000,000 listed |
| OpenRouter (served by GMI) | $0.20 | $0.60 | $0.05 | 16,384, max output 14,745 |
| Together AI | Coming soon | Coming soon | n/a | 1M listed |
| Hugging Face weights | Free (Apache 2.0) | Your hardware | n/a | Up to 1M on 2x B200 |
The catch is that 16K window. A coding agent like Claude Code or the tools in my terminal AI coding guide can blow through 16,384 tokens before it has finished reading the repo. Through OpenRouter today, Ripple is too short-sighted for the agentic coding it was built for. When I captured the page, it also showed a single provider at 53.69% uptime and 73 tokens per second, which is normal for day two but not something to put in production yet.
Here's how a session of 10M input and 1M output tokens prices out against the open rivals, using OpenRouter's list prices:
| Model | Input / output per 1M | Cost for 10M in + 1M out | Context on OpenRouter |
|---|---|---|---|
| Ripple-65B Preview | $0.20 / $0.60 | $2.60 | 16,384 |
| Beam 1.0 501B | $0.25 / $1.00 | $3.50 | 1,048,576 |
| Qwen3.8 27B | $0.15 / $1.875 | $3.38 | 1,024,000 |
| DeepSeek V4.1 Flash | $0.045 / $0.50 | $0.95 | 1,048,576 |
| Inkling | $1.00 / $4.05 | $14.05 | 524,288 |
| Muse Spark Open | $1.25 / $4.25 | $16.75 | 1,048,576 |
So Ripple is $0.90 cheaper than Beam on that session, with 64 times less context. For most API buyers that trade isn't worth it. DeepSeek V4 Flash stays the budget pick, and Qwen 3.8 is the obvious non-US comparison Ricursive left off its chart. So is Kimi K3.
Can you actually run it on your own hardware?
Yes, and this is where Ripple earns its place. A dense 65B model is small enough to sit on one machine, and Ricursive ships the scripts to do it. What the launch-day marketing glosses over is how much each route asks of you:
- BF16 on 2x B200. The server README uses SGLang 0.5.19 with the DFlash2 draft model and a 1M context default. The card quotes
250tokens per second at batch 8. - NVFP4 on a DGX Spark. The NVFP4 checkpoint is labelled experimental, keeps attention in BF16, and the local script runs one request at a time at a 128K context.
- Community GGUF. AtomicChat's quant is
38.8 GBat Q4_K_M, but stock llama.cpp, Ollama and LM Studio can't load it until a llama.cpp patch lands. - No MLX build. Ricursive's co-founder posted that you can run it "on a MacBook Pro," but no official guide covers Apple Silicon yet.
A Hacker News commenter put the dense-model trade-off well:
"it's a 65B dense model and inference will be prohibitively slow on consumer grade hardware"
And the other side, from someone with the right hardware:
"Speaking as someone who has High-Memory Mac Studios, it is great that there is finally a model that will run at usable speeds with high quality."
Two smaller gotchas for anyone wiring it into an agent. The chat template "does not implement a thinking on/off switch or reasoning-effort levels," so every reply pays for a reasoning pass. And forcing a tool call needs strict schemas: the card warns that "Non-strict required calls produced extra argument fields." OpenRouter's endpoint only accepts tool_choice of none or auto for now.
What are developers saying about it?
The first day of reaction splits cleanly. The training cost gets praise from nearly everyone, and the "state of the art" framing gets pushback. From the X side:
"this is like the avengers of open model SOTA"
That was swyx reacting to the $32M full R&D figure. On Hacker News, where the thread hit 182 points, the most replied-to complaint was the narrow category:
"Category narrowing to this degree really has diluted the term "SOTA" quite a lot"
Several commenters pointed out that the chart compares only US open models and leaves out Qwen. One put Ripple's Terminal-Bench number next to Alibaba's:
"This model scores 80.5 on Terminal Bench 2.1 For reference Qwen 3.8 Flash Next (which is bigger than this model but probably cheaper to run due to MoE) scores 84.3, and Qwen 3.8-27B scores 73.0."
And the comment that, to me, explains who this model is really for:
"There are several situations where some of us are explicitly prohibited from using models from companies not under the jurisdiction of the United States."
That's the real market. If your security team has ruled out Chinese-lab weights, the alternatives at this size were thin, and Ripple is now the strongest US open model that fits on a single workstation.
Should you use Ripple-65B for a support agent?
I wouldn't make it my first pick, and the reason is in Ricursive's own table. τ³-bench banking is the closest thing on the card to a customer-service test: an agent following policies and calling tools for a bank customer. Ripple scores 31.27 there, behind Beam's 36.1. Add the always-on reasoning (slower first replies), the light post-training "with a focus on agentic coding," and the 16K hosted context, and it's built for a different job. My guide to the best LLM for support goes deeper on what matters there.
The bigger point is that a model is infrastructure. For a support team, the hard part is everything around it: reading the helpdesk, learning from past tickets, knowing when to hand off. That's what eesel is for. It's an AI teammate you hire for a job, like the AI helpdesk teammate, rather than a model you host. Three customers show how that plays out:
- SE Ranking runs one eesel agent per product on Zendesk and handled
4,650conversations in a month, handing refunds, trial extensions and Tier 2 questions to the team. - Timengo uses it on Freshdesk to draft replies to technical tickets from about
5,300past tickets and help articles, and eesel never replies to a customer on its own there. - SamCart runs separate agents on Freshdesk and website chat, answering from about
280help center articles.
If you like driving tools from a terminal, the eesel CLI lets a coding agent like Claude Code, Codex or Cursor upload approved knowledge, like exported help articles and policies, then ask the agent test questions with eesel chat and check the answers before anything goes live. Connecting the helpdesk itself still needs someone with admin access to approve it. More on that pattern in the AI agent CLI guide, and the MCP server explainer covers the other way in.
The catches before you switch
- The hosted context is 16K. Fine for a chat, too small for repo-scale agent work until GMI or Together lift it.
- The benchmarks aren't independent yet. No Artificial Analysis entry, and the launch chart and model card disagree on some competitor scores.
- Local setup is NVIDIA-first. Official paths need B200s or a DGX Spark; Mac users wait on community builds.
- It always thinks. No way to turn reasoning off for fast, simple replies.
- It's a preview. Ricursive calls the post-training "relatively light," and the NVFP4 build is experimental.
Verdict: who should run Ripple-65B?
My rating: 3.5/5. Ripple is an impressive first model from a five-person training team, and the $32M full-cost figure matters for where open models go next. But the headline win is a 0.4-point tie, and a buyer comparing models on their own merits will find Beam ahead on more rows.
- Run it if you need Apache 2.0 weights from a US lab, you have a DGX Spark or a pair of B200s, and your agent lives in a terminal. That's a real niche, and Ripple owns it.
- Skip it if you're calling an API. Beam 1.0 costs
$0.25/$1.00with a 1M window, and DeepSeek V4 Flash is far cheaper if lab origin doesn't matter to you. - Wait a month if you're on a Mac. Once llama.cpp support merges and someone posts real tokens-per-second numbers, the local case gets much clearer.
For the wider field, my Inkling review covers the biggest US open model. The GLM-5.3 Flash review covers a cheaper Chinese option.
The Kimi K3 alternatives roundup ranks the open models side by side. On the closed side, Claude Sonnet 5.5 is still the model most coding agents default to, with GPT-5.6 close behind.
Try eesel
If you came here because you're choosing a model to power a support agent, you can skip that step. eesel is an AI teammate that plugs into Zendesk, Freshdesk or Gorgias, learns from your past tickets and help center, and gets tested on your real conversations before it answers anyone. SE Ranking went from setup to 4,650 conversations a month across three products. Plans start at $299/month for 500 credits on the pricing page, with a free trial. Try eesel and run it against your own queue first.
