← All issues

A 65B coder on one GPU: what it did

Issue #22 · November 7, 2026 · ~5 min read

Welcome back to Zero to MVP Weekly. One signal, one tool, one MVP idea — five minutes, every Saturday. Three open-weight models came out this week, from 65 billion parameters to 2.8 trillion. Only one of them fits on the GPU under my desk, so that's the one I tested.

1. The signal of the week

Open weights you can actually run.

Three open models in four days, at three very different sizes:

  • Kimi K3.1 Pro (Moonshot): the weights are out, as promised. 2.8 trillion parameters, 104 billion active per token, 1M context. Moonshot puts it at 65.7 on Terminal-Bench 4.0, next to Opus 5.5's 66.4. The license is MIT-style with two catches: a company selling inference with over $20 million a year in revenue needs a separate deal, and a product with over 100 million monthly users must show the model's name.
  • Ripple-65B Preview (Ricursive Intelligence, a chip-design company founded by the authors of Google's AlphaChip): a dense 65B coding model under Apache 2.0, trained from scratch for $32 million. It claims 80.5 on Terminal-Bench 2.1, ahead of US open models up to fifteen times its size.
  • Inkling 2 Small (Thinking Machines): 594 billion parameters, 17 billion active. For now it runs only on their platform; Apache 2.0 weights are planned for next week, once safety testing is done.

What to do with it: stop asking which one scores highest, and ask two other questions. Does it fit in your memory, with the context you need? And how long will you wait before the first word of the answer? Kimi is a cluster model: for most of us it means a cheaper API, not a download. Ripple fits on one 32 GB card. Inkling's weights aren't out yet.

One honest caveat: every benchmark above is the vendor's own. Ripple compares itself only with US open models, so DeepSeek, Kimi and GLM aren't in its table, and the closest US model is only 0.4 points behind.

2. My take

To me, the most interesting part isn't the models themselves. It's how fast the gap between open and closed models is shrinking. And open weights now matter not only to enthusiasts, but also to companies that want control over their infrastructure, predictable costs and independence from API providers.

3. Tool of the week

Ripple-65B on one 32 GB GPU.

  • What it is: an open coding model you can run on a single graphics card. llama.cpp added support on November 5; I built it from the pull request before that.
  • My setup: a Radeon Pro W7800 with 32 GB, a 26 GB quantization and a 128K context, which together fill 31.3 of the 32 GB. The Pi agent, a sandbox with no internet, and hidden checks the model can't see.
  • Speed: about 15 tokens per second, about 12 with 32,000 tokens already in the context. Reading the prompt is the slow part, around 250 tokens per second: give it 26,000 tokens of code and you wait almost two minutes for the first word.
  • Where it works: three terminal tasks, three passed. A C project with a chain of three build errors, fixed in five and a half minutes. A lost git branch recovered from dangling objects in nine minutes, with the decoy experiment left alone. A Python service with five breakages, fixed in five and a half minutes, then sixteen more minutes of checking and cleaning up.
  • Where it breaks: big tasks. I gave it the tower defense game that cheap cloud models built in 10 to 70 minutes. It spent 46 minutes thinking and wrote no files. With a doubled limit, 80 minutes and still nothing. Asked to write in parts, it produced its first file at minute 41. I stopped there.
  • My verdict: for focused jobs, like fixing a build, sorting out git or getting a service back up, you can use it locally today. For whole projects, not yet. It's a Preview, so let's see what the final version brings.

The video: Ripple 65B: A Chip Lab Beat Every US Open Model. I Tested It

4. MVP idea of the week

"Will it fit, and how long will I wait?"

  • Problem: every open model launch says "runs locally." Nobody tells you what that means on your card: does the model fit with the context you need, how fast does it generate, and how long until the first word on a real prompt? People download 30 GB to find out.
  • Solution: pick a model, a quantization, a context size and your hardware. Get the memory fit, the generation speed at an empty and a full context, and the wait before the first token for 10K, 25K and 50K tokens of prompt.
  • For whom: developers with one 16–48 GB GPU or a 32–128 GB Mac, choosing a local coding model.
  • Minimal v1: a static page with a table built from real llama-bench runs, plus one command users run to submit their own row.
  • Demand check: post the first row (Ripple: 26,000 tokens of prompt, 1:44 to the first word) under this week's model threads, and count how many people submit their own numbers in a week.
  • Why now: three open releases in four days, a 65B model that fits on one card next to a 2.8T one that doesn't, and "runs on a DGX Spark" claims nobody has measured.

5. Useful links

— Nick

P.S. Outside this newsletter, I help startups and companies build things: MVPs, AI integrations, local or cloud LLM deployments. If you're working on something like that and could use a hand, write to me at nick@blokhin.us.

Get the next one in your inbox.

One signal, one tool, one MVP idea — every Saturday. Free.