Ripple 65B Preview vs Grok 4.7: Which Benchmark Do You Actually Believe?

Ripple 65B Preview launched on 4 November 2026 with a story about size: a 65-billion-parameter open-weight model from Ricursive Intelligence beating Meta's 816B Muse Spark Open, Thinking Machines' 975B Inkling and NVIDIA's 550B Nemotron 3 Ultra on agentic coding. Grok 4.7 tells a different story. It is a closed xAI model released on 21 September 2026, it scores 35 on Artificial Analysis's Intelligence Index v5.0.1 — the lowest of any frontier-adjacent model in this price bracket — and it still beats Ripple 65B Preview by 27 points on the one coding benchmark both labs published at the same version. Two models, two benchmark stories, pointing in opposite directions. The interesting question is not which model is better. It is which measurement you are willing to bet a production workload on.

The inversion, stated plainly

Grok 4.7's card reports DeepSWE v1.1 at 71.0. Ripple's card reports 44.3. Same benchmark, same version, both vendor-reported, no harness ambiguity to argue about. Grok wins by 26.7 points on software-engineering agent work.

Now the other direction. Ripple reports Terminal-Bench 2.1 at 80.52. Grok reports Terminal-Bench 4.0 at 38.0. Those are not comparable — 2.1 is an 89-task patch of the 2.0 set, 4.0 is a rebuilt task set with adversarial-cheat checks and an eight-hour timeout that collapsed every frontier score on contact — but the direction of the gap is so large that version alone probably does not explain it. Grok's 38.0 is low even for 4.0; Claude Opus 5.5 reports 66.4 there and GPT-6.1 Sol around 55.

So the same pair of models produces a 27-point win for Grok on one benchmark and a 42-point win for Ripple on another. One of those two exams is measuring something the other is not, and a buyer needs to know which one resembles their workload.

What Terminal-Bench and DeepSWE each reward

Terminal-Bench is a shell-task benchmark. The agent gets a container, a goal and a time limit, and is scored on whether the final state of the filesystem and services is correct. Version 2.1 fixed 28 of the 89 tasks for broken dependencies, resource mismatches and misspecification; version 4.0 throws out eight tasks, fixes nineteen more, and adds tamper-resistance checks specifically because agents were finding ways to pass without doing the work. A Berkeley RDI study showed an automated exploit agent reaching 100% on SWE-bench Pro and Terminal-Bench without solving a single task, by overwriting the parser or trojanising curl inside the container. Every version bump since has been an arms race against that.

DeepSWE is a different shape: long-horizon software engineering on real repositories, where the agent has to hold a plan across many edits. It rewards persistence and context management more than clever shell work. A model can be excellent at one and mediocre at the other, and the two labs here appear to have optimised for different halves.

That is the most useful thing in this comparison. If your agents live in containers doing systems work — builds, migrations, infrastructure repair — the Terminal-Bench ordering is the relevant one and Ripple's 80.5 matters. If your agents edit a large codebase over hundreds of turns, DeepSWE is closer to the job and Grok's 71.0 matters.

Grok 4.7's actual profile

Grok 4.7 is a reasoning model with four effort levels — low, medium, high and xhigh — where high is the default and reasoning cannot be switched off entirely. That is unusual, and it has a cost consequence: every call pays for thinking tokens whether the task needs them or not. The model carries a 500,000-token context window, accepts text and images, and returns text.

• Price — Grok $2.00 input / $6.00 output per million below 200K input, $4.00 / $12.00 above; Ripple has no list price, hosted rates near $0.20 / $0.60

• Context — Grok 500K vs Ripple up to 1M claimed

• Independent score — Grok 35 on AA index v5.0.1 at $7.77 per index task; Ripple unranked

• Output speed — Grok 72 tok/s measured; Ripple 250 tok/s claimed on 2×B200

• Licence — Grok proprietary, API only; Ripple Apache 2.0

• DeepSWE v1.1 — Grok 71.0 vs Ripple 44.3

• Release — Grok 21 September 2026 vs Ripple 4 November 2026

The 200,000-token threshold is the billing detail that catches people: crossing it rebills the entire request at the higher rate, not just the excess. A 210K-token call costs twice what a 199K-token call does. With a 500K window and reasoning always on, that is easy to trip accidentally.

The cheap-output trap

Six dollars per million output tokens is the lowest rate among the closed models in this comparison — Opus 5.5 is $20, Sol and Argon are $10 — and it is the number Grok's pitch leans on. It is also the number most likely to mislead.

Two things eat the advantage. First, reasoning is mandatory, so a meaningful share of what you are billed for is thinking you did not ask for. Artificial Analysis measures Grok 4.7 at $7.77 of compute per index task, which is six times GPT-6.1 Sol's $1.27 and higher than Opus 5.5's $10.04 only by a whisker — despite a headline output rate a third of Opus's. Second, the model reportedly consumes roughly twice the tokens per task as Grok 4.6 for similar work. Cheap tokens multiplied by more tokens is not a saving.

Ripple's economics are the opposite shape and just as easy to misread. There is no rate card at all: the weights are Apache 2.0 and the cost is GPUs. At 250 tokens per second on two B200s in BF16, throughput per dollar is excellent if you keep the GPUs busy and terrible if you do not. The hosted rates near $0.20 input and $0.60 output are somebody else's amortisation of exactly that trade.

Long-horizon work, where Grok's numbers are strongest

The rows Grok's launch emphasised were the marathon ones: SWE-Marathon v1.1 at 46.0, up from 31.9 for Grok 4.6, FrontierSWE V2 at 29.5, and CursorBench 4.0 at 46.3 against 40.4. Those are benchmarks about sustained effort inside a single long task, and they improved far more between 4.6 and 4.7 than the single-turn scores did. xAI's own framing — same price, longer horizons — is accurate.

Ripple's counter is architectural. An 80-layer dense model with a 1M window trained through 2M-token long-context stages is built to hold a large working set, and a 65B dense model has no expert-routing to go wrong at scale. Whether that translates into better long-horizon behaviour is exactly what no published benchmark answers, because Ripple has not been run on SWE-Marathon or FrontierSWE.

What to do with this

Do not pick between these two on the strength of a benchmark chart. Pick on the shape of the work and the shape of the bill.

Container-based systems work, an ability to run your own GPUs, and a licensing requirement that ends the conversation with a closed API: Ripple 65B Preview is the right experiment, and its 80.5 on Terminal-Bench 2.1 — a like-for-like comparison against the other open-weight models on that chart — is the evidence for it. Repository-scale editing over long horizons: Grok 4.7's 71.0 on DeepSWE is the strongest same-version signal in either direction, and its marathon scores back it up.

Grok 4.7 is routable today through OrcaRouter at xAI's list price with 0% markup, alongside more than 200 other models on one key — including the four effort levels, so a cheap triage call and an xhigh escalation can sit behind the same endpoint, and automatic failover if xAI degrades. That matters more than usual for Grok, because its per-task cost is dominated by token volume rather than list price; routing the easy calls to a cheaper model changes the blended bill far more than the $6 rate does. Ripple is not in the catalogue, so that particular split is not available for it.

The number that settles this comparison does not exist yet: Ripple 65B Preview has no DeepSWE re-run by a neutral harness and no Artificial Analysis entry. Until it does, the one honest thing to say is that Grok 4.7 is measurably better at long repository work and Ripple is measurably better at shell tasks, and the benchmark whose name you recognise is not automatically the one your workload resembles.