Ripple-65B Preview’s weights are out. What it takes to run, and how good it is

What Ricursive released

Ricursive Intelligence published Ripple-65B Preview on November 4, 2026. RuntimeWire calls it the first public model from a chip-design startup founded by Anna Goldie and Azalia Mirhoseini, and Ricursive calls it “a general-purpose variant of the proprietary model that powers our AI chip design platform.”

Its model card describes a dense model of 65 billion parameters, trained from scratch on 12 trillion tokens, with up to 1M tokens of context. The license is Apache 2.0. Dense matters here. In the large mixture-of-experts models it’s compared with, most parameters sit idle for each token; in Ripple all 65 billion do the work. That keeps the download small and makes each token harder work on consumer hardware.

Ricursive says the whole effort cost $32M, which it estimates is “one-tenth the cost of the previous open-weight SOTA on agentic coding.” The card says the Preview “has gone through relatively light posttraining, with a focus on agentic coding.”

How good it is

These are Ricursive’s numbers, from its card. Where a lab hadn’t published a score, Ricursive ran the test itself, so some of the rivals’ figures are its own. Higher is better.

Benchmark	Ripple 65B	Reflection Beam 501B	Muse Spark Open 816B	Inkling 975B
Terminal-Bench 2.1, self-reported	80.5	80.1	76.4	63.8
Terminal-Bench 2.1, Terminus 2	80.5	70.8	78.7	56.2
SWE-bench Verified	76.5	81.6	78.7	77.6
SWE-bench Pro v2.0 Hard	79.1	76.5	52.3	2.0
DeepSWE 1.1	44.3	43.3	60.0	1.8
MCP Atlas	71.67	80.8	89.2	76.0

So the headline is narrow. Ricursive claims the “U.S. open-weight state-of-the-art” on one test, by 0.42 points over Beam, and rivals lead several others. The table leaves out Chinese models. Qwen3.8 27B’s card lists 73.0 on Terminal-Bench 2.1 and 42.2 on DeepSWE 1.1 at 28 billion parameters, and Flint lists 54.9 on Terminal-Bench 2.1. Each of those is its maker’s own result.

Ricursive itself warns that replicating these scores “has been challenging,” and calls its results “a best-effort attempt at a fair comparison.” We found no independent evaluation by November 5.

What you need to run it

Ricursive publishes two builds of the finished model, the full weights and NVFP4. The smaller ones below come from third parties, who also wrote their hardware suggestions. “Same top token” is how often AtomicChat measured a build picking the same next token as the full model.

Build	Size	Suggested hardware	Same top token
Full BF16 weights (Ricursive)	129.6 GB	Two NVIDIA B200 GPUs, in Ricursive’s recipe	100%
NVFP4 (Ricursive, marked experimental)	57.2 GB	DGX Spark	Not published
GGUF Q8_0	68.8 GB	128 GB Macs, DGX Spark	99.0%
GGUF AD-Q5_K_M	47.9 GB	64 GB Macs	97.3%
GGUF AD-Q4_K_M	40.4 GB	48 GB Macs, two 24 GB GPUs	95.9%
GGUF AD-IQ3_XXS	28.0 GB	32 GB, such as an RTX 5090	91.2%
GGUF AD-IQ2_XXS	20.0 GB	24 GB, such as an RTX 3090 or 4090	80.8%
MLX 8-bit	69 GB	Macs with 96 GB or more	Measured differently
MLX 4-bit	37 GB	Macs with 64 GB or more	Measured differently

AtomicChat says its suggestions leave room for “a moderate context,” and that long contexts need more memory. Speed is the catch. The MLX builds’ maker measured a 256 GB M5 Ultra Mac Studio at 22 to 23 tokens a second on 4-bit and about 12.5 on 8-bit, with a fresh 32K-token prompt taking about a minute. Mirhoseini says it runs “locally and efficiently” on a MacBook Pro, but neither that post nor the launch page names a memory size or a speed.

How to run it

On a Mac, with MLX. The conversions are unofficial, and mlx-lm doesn’t know the architecture yet, so the build carries its own Python file and needs --trust-remote-code. That runs someone else’s code on your computer. The card says the file is about 280 lines and asks you to read it first.

pip install "mlx-lm>=0.32.2"
mlx_lm.server --model frogggias/Ripple-65B-Preview-MLX-4bit --trust-remote-code

The server listens on port 8080 and speaks the OpenAI API. Its card notes that reasoning arrives inside the reply’s text as <think>…</think>.

On a Mac or PC, with GGUF. Ripple isn’t in stock llama.cpp, and AtomicChat says “stock llama.cpp, LM Studio and Ollama do not load these files yet.” Pull request 31692 is still open, so build from it, then start the server. On a Mac, drop -DGGML_CUDA=ON.

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git fetch origin pull/31692/head:ripple && git checkout ripple
cmake -B build -DGGML_CUDA=ON
cmake --build build -j --config Release --target llama-server llama-cli
./build/bin/llama-server -m Ripple-65B-Preview-AD-Q4_K_M.gguf --jinja -c 32768 -ngl 99 --alias ripple --port 8080

On a DGX Spark. Ricursive’s NVFP4 repository has a notebook and a script for it. The script sets a context of 131,072 tokens and refuses other GPUs. The 1M context is the default in Ricursive’s two-B200 recipe, which it says reached 250 tokens a second at a batch size of 8.

Hosted, with nothing to install. OpenRouter serves it through GMI Cloud at $0.20 per million input tokens and $0.60 per million output, as ricursiveai/ripple-65b-preview. On November 5, Together AI listed the same prices under a “Launching soon” banner, and Fireworks offered it on dedicated GPUs only. Hosted means your code goes to that provider.

Give it real work

Ricursive ran many of its own tests through OpenCode, so that’s a sensible agent to start with. For a local server, add a provider to opencode.json, as OpenCode’s docs describe. The key under models must match the ID your server exposes: ripple with the --alias above, or the repository name with mlx_lm.server.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server (local)",
      "options": { "baseURL": "http://127.0.0.1:8080/v1" },
      "models": { "ripple": { "name": "Ripple-65B Preview (local)" } }
    }
  }
}

For the hosted version, run /connect in OpenCode, choose OpenRouter and enter your key. Models.dev already lists the model there.

Context will likely be your limit. AtomicChat’s example uses 32,768 tokens, while Ollama’s guide recommends at least 64,000 for coding tools, so raise -c if you have the memory. Keep the agent’s permissions tight, too, and test tool calls before you trust it with a long job. A Hacker News commenter who ran the hosted model on their own benchmark wrote “4/8 tools failed” and that “the tool call failure rate is not acceptable.” That is one person’s test.

Enjoy runs OpenCode beside Claude Code, Codex and the other labs’ agents, and its model picker lists every model OpenCode has set up, local ones included. So when a plan runs low, you can switch the conversation to Ripple and keep going. You can also put routine upkeep on a schedule, which runs only while your computer is awake and Enjoy is open.

What isn’t known

• What “Preview” means. Neither page defines it or gives a date for a final version.
• MacBook speed. We found no published measurement on any MacBook by November 5.
• Sampling settings. Community cards say Ricursive publishes no defaults for the Preview.
• Independent scores. Everything in the table above comes from Ricursive, and the commenters on Hacker News questioned its choice of rivals and tests.

If you have 64 GB or more and want the top US open model on Terminal-Bench by Ricursive’s count, Ripple is worth a download. On a smaller machine, Flint and Qwen3.8 27B still ask for less.