Ripple-65B Preview: Specs, Benchmarks, Price and How to Run It Locally

A chip-design startup just shipped one of the most interesting open coding models of the year. Ripple-65B Preview from Ricursive Intelligence is a 65-billion-parameter dense model, released on 4 November 2026 under Apache 2.0.

Ricursive says it beats far bigger US open models on agentic coding, including Reflection’s 501B Beam and Meta’s 816B Muse Spark Open. It also says the whole project cost about $32 million.

This guide covers the specs, every benchmark (and which ones it loses), API prices, the exact files to download, how to run it on a DGX Spark, Mac or PC, and the catches you should know first.

Who Made Ripple-65B and Why It Matters

Ricursive Intelligence is a Palo Alto lab founded by Anna Goldie and Azalia Mirhoseini. Both worked at Google Brain, where they were known for AlphaChip, a reinforcement learning method for chip floorplanning.

The company launched in December 2025 with a $35 million seed round led by Sequoia. A $300 million Series A at a $4 billion valuation followed, led by Lightspeed with NVIDIA’s NVentures taking part (as reported by OfficeChai).

Its main product is AI for chip design. Ripple is a general-purpose version of the model that powers that platform, and it is the lab’s first public language model.

Why people are paying attention

• Dense, not MoE: most big open models are mixture-of-experts. Ripple uses all 65B parameters on every token, which makes it simpler to serve and to quantize.
• Small for its scores: it is compared against US open models that are 8 to 15 times bigger in total parameters.
• Cheap to build: Ricursive puts the full R&D bill at about $32M, which it says is roughly one-tenth of what the previous US open coding leader cost.
• Few RL rollouts: the lab says it reached its Terminal-Bench score with about 1.4 million reinforcement learning rollouts.

Note: the comparison set only includes US open-weight models. Chinese open models such as DeepSeek, Qwen and Kimi are left out of Ricursive’s tables, so “state of the art” here means “among US open models”.

Ripple-65B Preview Specs

Everything below comes from the Hugging Face model card and the launch blog. Training numbers are vendor-reported.

Benchmarks: Wins and Losses

Ricursive’s own table has 22 rows, and Ripple leads on only two of them. That is still impressive for its size, but it is not a clean sweep.

Source: Ricursive’s model card and launch table as summarised by eesel.ai and DEV Community. “n/a” means that figure was not in the sources I could verify.

The model card also lists strong general scores: MMLU 89.6, AIME 2025 98.3, HMMT Feb 2026 90.5, IFBench 79.2 and AA-LCR 75.0. All are vendor-reported.

Warning: no outside lab has verified these numbers yet. Several rival scores are Ricursive’s own reruns, and VentureBeat spotted a launch graphic that gave Inkling a different SWE-bench Pro score than the card. Treat the Terminal-Bench lead (0.4 points) as a tie.

API Pricing vs Other Open Models

On OpenRouter, Ripple costs $0.20 per million input tokens and $0.60 per million output tokens, with cached input at $0.05. GMI Cloud serves every request; Together AI listed it as “coming soon” and Fireworks had no confirmed rate.

Prices are OpenRouter list prices quoted by eesel.ai on 5 November 2026 and can change. For more on Inkling, see my Inkling 2 Small guide.

Which Files to Download

Ricursive published four official repos. Community GGUF and MLX builds appeared within a day, but Ricursive has not tested them.

How Much Memory Do You Need?

A dense 65B model has to read every weight for every token, so memory bandwidth matters as much as capacity. These sizes come from the AtomicChat GGUF repo; add a few GB for context (KV cache).

• Two 16 GB cards (like my 2x RTX 5080): AD-IQ3_XXS (28 GB) should split across both GPUs with a short context. That is my estimate from file sizes, not a measured run.
• Single 16 GB card: you would have to offload most layers to system RAM. With a dense model that gets slow, likely only a few tokens per second (estimate).
• Measured speed: the only public figure is from the GGUF uploader: plain Q4_K_M on one GH200 96 GB did 309 tok/s prompt processing and 40.6 tok/s generation.

Tip: the repo says AD-IQ3_S matches the plain Q4_K_M’s quality while being 6.4 GB smaller, and AD-IQ4_XS has about 2.5x lower KL divergence than plain Q4_K_M at nearly the same size. Prefer the “AD” files. My VRAM requirements guide explains how context adds to these numbers.

Option 1: Use It Through the API

This is the fastest way to try Ripple, and it needs no hardware. OpenRouter and GMI Cloud both expose an OpenAI-compatible chat endpoint.

1. Get an OpenRouter key. Sign up at openrouter.ai, add credit and create an API key.
2. Use the model ID. It is ricursiveai/ripple-65b-preview.
3. Send a request. Use the curl example below, or any OpenAI SDK with the base URL set to OpenRouter.
4. Give it room to think. Reasoning is always on, so set max_tokens high (4,096 or more) or answers get cut off.

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 script that finds files over 100 MB"}],
    "temperature": 0,
    "max_tokens": 4096
  }'

Ricursive publishes no recommended sampling settings. Its own examples use temperature 0.

Note: when I checked the OpenRouter page it showed a 1M context, 8 tokens/s throughput and 78% uptime from the single provider. VentureBeat reported a 16,384-token cap at launch, so check the live listing before you plug it into a coding agent.

Option 2: Run a GGUF With llama.cpp

Ripple uses a new ricursive architecture. Upstream llama.cpp does not support it yet; support is proposed in PR #31692. Until it merges, stock llama.cpp, LM Studio and Ollama cannot load these files.

1. Build llama.cpp from the PR branch. Clone llama.cpp, fetch the PR and build the server (drop the CUDA flag on a Mac).
2. Download one GGUF. Pick a file from the table above in AtomicChat/Ripple-65B-Preview-GGUF. For split files, point llama.cpp at the first part.
3. Start the server with the template. Add --jinja so the built-in chat template (tools and <think> reasoning) is used.
4. Connect your app. llama-server exposes an OpenAI-style API on port 8080 that Open WebUI, OpenCode or your own scripts can use.

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

On two GPUs, llama.cpp splits layers across both cards automatically. If you run out of memory, lower -c first, then pick a smaller file. Not sure which runner suits you? My vLLM vs llama.cpp vs Ollama comparison covers the trade-offs, and MLX vs GGUF helps Mac users choose a format.

Option 3: DGX Spark and B200 Servers

DGX Spark (official script)

The NVFP4 repo includes a notebook and a spark.py script. It loads the NVFP4 weights plus the DFlash2 draft model and wraps SGLang inside Python.

from spark import Spark

engine = Spark(
    "ricursiveAI/Ripple-65B-Preview-NVFP4",
    "ricursiveAI/Ripple-65B-Preview-DFlash2",
)
print(engine.chat("Find files over 100 MB", max_tokens=4096))

• GB10 only: the script checks for compute capability 12.1 and refuses other GPUs.
• 128K context, one request at a time.
• No HTTP server: agents that expect an OpenAI endpoint need a small wrapper.
• Defaults: chat() uses max_tokens 256 and temperature 0, so raise max_tokens.

2x B200 (full 1M context)

The BF16 repo includes an SGLang 0.5.19 server recipe for Linux with CUDA 13. Ricursive cites 250 tokens/s at batch size 8 on two B200s before quantization (vendor-reported). Four GPUs give two independent copies.

The server returns reasoning in message.reasoning_content, separate from message.content. SGLang’s ripple tool parser converts <tool_call> tags to standard tool_calls.

Limits, Licence and Unknowns

• It is a Preview. The NVFP4 build is labelled Experimental, and no final release date is announced.
• No tech report yet. The training data and full recipe are not public.
• Text only. No image or audio input, unlike Inkling 2 Small or Kimi K3.1.
• Light post-training. Ricursive focused RL on coding, so math, safety and general chat may lag (its own charts show Meta and Reflection ahead on safety and automation).
• Custom code. Transformers needs trust_remote_code=True (model_type ricursive, file modeling_ricursive.py). Read that file before running it.
• One hosted provider. Capacity and uptime are limited for now.
• Odd metadata: the NVFP4 repo sidebar says “40B params”, which is likely how Hugging Face counts packed 4-bit weights; the card itself says 65B.

The Apache 2.0 licence lets you use, modify, fine-tune and sell products built on Ripple, as long as you keep the licence and notices. There is no extra acceptable-use licence on top.

Troubleshooting

My Take

Ripple is the most interesting US open model for local coders right now, mainly because of its size and licence. A 65B dense model at 4-bit fits a 48 GB setup, while Beam, Muse and Inkling need server racks.

The benchmark story is more modest than the headline. It ties Beam on Terminal-Bench and loses on SWE-bench Verified, MCP Atlas and SciCode, and none of it is independently verified yet.

My advice: try it through OpenRouter today for a few cents. If you own a 48 GB+ machine, wait a few days for the llama.cpp PR to merge, then grab an AD-Q4 GGUF. I will update this post when the merge lands and when independent benchmarks appear.

Want a coding agent to drive it? See my OpenCode vs Claude Code comparison, and my best GPU for local LLMs guide if you are shopping for hardware.

FAQ

Is Ripple-65B open source?

The weights are open under Apache 2.0, including commercial use. The training data and full recipe are not published, so it is open-weight rather than fully open source.

Who makes Ripple-65B?

Ricursive Intelligence, a Palo Alto chip-design AI lab founded by former Google Brain researchers Anna Goldie and Azalia Mirhoseini.

Can I run Ripple-65B on a 24 GB GPU?

Only with a 2-bit GGUF such as AD-IQ2_XXS (20 GB) and a short context, using the patched llama.cpp build. Quality drops at 2-bit, so 32-48 GB is a better target.

Does Ripple-65B work in Ollama or LM Studio?

Not yet. Both rely on llama.cpp, which needs PR #31692 merged before the ricursive architecture loads.

How much does the Ripple-65B API cost?

$0.20 per million input tokens, $0.60 per million output tokens and $0.05 per million cached input tokens on OpenRouter.

Is Ripple-65B better than DeepSeek or Qwen for coding?

Nobody knows yet, because Ricursive only compared it with US open models. Wait for independent leaderboards before switching.

Does Ripple-65B support images?

No. It is a text-only model with tool calling and always-on reasoning.

What context length does it support?

Up to 1M tokens on Ricursive’s 2x B200 recipe. The DGX Spark script is limited to 128K, and hosted providers may cap it lower.

Sources

• Ricursive Intelligence: “Ripple-65B Preview, a Frontier Open-Weight Model” (ricursive.com/ripple)
• Hugging Face model cards: ricursiveAI/Ripple-65B-Preview and Ripple-65B-Preview-NVFP4
• Hugging Face: AtomicChat/Ripple-65B-Preview-GGUF (file sizes, llama.cpp PR #31692, speed figure)
• OpenRouter: ricursiveai/ripple-65b-preview listing (pricing, provider, context)
• Ricursive Intelligence on X: launch posts (Terminal-Bench, SWE-Bench Pro v2.0 Hard, DeepSWE)
• OfficeChai: Ricursive Intelligence releases Ripple-65B Preview (company background, funding)
• eesel.ai: Ripple-65B Preview benchmarks, price and how to run it (benchmark and price tables)
• DEV Community: “Ripple-65B Is an Open Coder With 1M Context. Its DGX Spark Script Stops at 128K”