# ripple-preview on Ollama: Ricursive's 65B agentic-coding model, first look

Ricursive Intelligence's Ripple-65B Preview landed on the Ollama library on 9 November — a 65B dense model trained for agentic coding, with up to 1M tokens of context. Here's what it needs and how to run it.

Published 2026-11-12 · https://inpherio.co.uk/blog/ripple-preview-on-ollama-ricursive-s-65b-agentic-coding-model-first-lo

Key points:
- ripple-preview is Ricursive Intelligence's Ripple-65B Preview: a 65B dense model built for agentic coding, on Ollama from 9 November 2026 under Apache 2.0.
- One size, 39–46GB download, up to 1M tokens of context — you need roughly 48GB+ of RAM/VRAM as a floor, and a 64GB Mac or server-class hardware to run it comfortably.
- Run it with `ollama run ripple-preview`; the Ollama page documents Ollama only, with DFlash 2 speculative decoding on the MLX (Apple Silicon) engine.
- The only quality number is Ricursive's own: 80.5 on Terminal-Bench 2.1. No independent benchmarks yet.
- Against MoE coding models like flint (23GB) and nemotron-3.5-bolt (25GB), it trades double the memory for a 4x longer context window.

Ripple-65B Preview — `ripple-preview` on the Ollama library — is a 65B dense model from Ricursive Intelligence, built for agentic coding and available from 9 November 2026. It's a general-purpose version of the model behind Ricursive's AI chip-design platform, released under Apache 2.0 with commercial use allowed. If you've been following this autumn's run of coding-agent models — [flint](/blog/flint-on-ollama-recursive-s-40b-coding-agent-moe-and-what-it-needs-to), [nemotron-3.5-bolt](/blog/nemotron-3-5-bolt-on-ollama-nvidia-s-local-coding-and-vision-model-fir), [mimo-v2.6](/blog/mimo-v2-6-on-ollama-xiaomi-s-9b-agent-coding-model-first-look) — this is the heavy end of that spectrum: the biggest, and by far the most memory-hungry, of the lot.

## What ripple-preview is

Ripple-65B Preview is Ricursive Intelligence's general-purpose release, and the pitch is specific: it's trained to work like a coding agent, carrying out multi-step tasks in a terminal, not just completing code snippets.

A few things make it unusual:

- **Agentic coding as the training target.** Ricursive says it used large-scale reinforcement learning to shape the model for multi-step terminal work — the loop of reading files, running commands, checking output, fixing things.
- **Dense, trained from scratch.** All 65B parameters are active on every token, pretrained on 12 trillion tokens. That's a genuine from-scratch dense release at a size most labs have moved away from in favour of MoE.
- **Long context.** Up to 1M tokens — enough, per Ricursive, for large codebases and long agent sessions.
- **Open licence.** Apache 2.0, commercial use allowed, with a [Hugging Face card](https://huggingface.co/ricursiveAI/Ripple-65B-Preview) alongside the [Ollama page](https://ollama.com/library/ripple-preview).
- **Capabilities on Ollama: tools and thinking.** So it works with tool-calling agent frameworks and produces reasoning traces, not just answers.

The "Preview" in the name is doing honest work: this is a first public cut of the model, not a finished product line.

## Sizes, memory and the hardware you'll need

There's one size on Ollama: `65b`, listed at **39–46GB download**. Both `latest` and `65b` tags point to the same model.

The rule of thumb we use throughout this blog: a model needs roughly its file size in RAM or VRAM, plus room for context. For ripple-preview that means:

- **39–46GB just to load the weights.**
- **Context on top.** With up to 1M tokens available (Ollama's variant table says 2M), a long agent session can add several more gigabytes. Budget generously.

That rules out most home setups outright:

| Hardware | Verdict |
|---|---|
| 8–16GB laptop | No |
| 24GB gaming GPU | Only with heavy CPU offload, at painful speeds |
| 64GB Mac (M-series, unified memory) | The comfortable fit |
| Multi-GPU / server-class box | Yes, comfortably |

The dense architecture is the reason it's so heavy. Compare it with [flint, the 40B MoE coding agent we covered in October](/blog/flint-on-ollama-recursive-s-40b-coding-agent-moe-and-what-it-needs-to): that was a 23GB download, because a mixture-of-experts model only activates a fraction of its parameters per token. Ripple's 65B are all active on every token, so it costs roughly twice the memory of flint despite being only ~60% larger on paper.

## How to run it locally

One command:

```bash
ollama run ripple-preview
```

That's it — `latest` and `65b` are the same model, so either tag works.

A few practical notes:

1. **The Ollama page documents Ollama only.** It gives no llama.cpp, LM Studio or vLLM instructions. There's a Hugging Face card, but we haven't verified what run instructions it carries — check there before assuming other engines are off the table. If you're weighing engines generally, our [vLLM vs Ollama comparison](/blog/vllm-vs-ollama-which-inference-engine-should-you-actually-run) covers the trade-offs.
2. **Mac users get a stated speed path.** On Ollama's MLX engine (Apple Silicon), Ripple uses DFlash 2 speculative decoding to generate faster. That's the one platform-specific performance note on the page, and it makes a 64GB Mac the most obviously supported home setup.
3. **Tools and thinking are listed capabilities.** That means it should plug into tool-calling agent frameworks — anything that speaks Ollama's tool API — and it produces reasoning traces you can inspect.

## What it's good at — and the one number we have

Ricursive reports **80.5 on Terminal-Bench 2.1** — a benchmark for agents doing real work in a terminal. That's the only quality number on the page, it's vendor-reported, and it comes from the launch post rather than an independent run. We've seen no third-party benchmarks as of release day, so treat it as a claim, not a fact. (This is the same pattern we saw with flint, nemotron-3.5-bolt and bonsai-2 — publisher numbers first, independent verification later, if it comes.)

Long context is the other headline. Up to 1M tokens — Ollama's variant table lists 2M — is 4x what the other recent coding models offer, and it changes what an agent session can look like: whole-repo context, long tool traces, fewer retrieval hacks. But remember the memory arithmetic: every token of context you actually use adds to the footprint on top of the model itself. A 64GB Mac running a 46GB model doesn't have room for a full 1M-token session.

The limits are worth stating plainly:

- **Text-only inputs.** No vision.
- **One size only.** No small sibling for modest hardware.
- **39–46GB footprint.** Most people reading this can't run it locally, full stop.
- **It's a specialist.** Agentic coding is the job. It's not positioned as a general chat model.

## How it compares with other local coding models

Here's how ripple-preview stacks up against the coding and agent models we've covered recently. One caveat: the figures for the other three are as we covered them in October and November 2026 — check the live Ollama pages before relying on them.

| Model | Parameters | Download | Context | Licence | Hardware class |
|---|---|---|---|---|---|
| ripple-preview | 65B dense | 39–46GB | 1M (2M listed) | Apache 2.0 | 64GB Mac / server |
| [flint](/blog/flint-on-ollama-recursive-s-40b-coding-agent-moe-and-what-it-needs-to) | 40B MoE | 23GB | 256K | Apache 2.0 | 32GB+ machine |
| [nemotron-3.5-bolt](/blog/nemotron-3-5-bolt-on-ollama-nvidia-s-local-coding-and-vision-model-fir) | 74B-A9B MoE | 25GB | 256K | NVIDIA open model licence | 32GB+ machine |
| [mimo-v2.6](/blog/mimo-v2-6-on-ollama-xiaomi-s-9b-agent-coding-model-first-look) | 9B dense | 6.6–8.7GB | 256K | MIT | 16GB machine |

The pattern is clear. Ripple is the only dense model of the big three, and it has by far the longest context — 1M versus 256K, a 4x gap. But it costs roughly twice the memory of the MoE coding models for the privilege, and it's the only one of the four with text-only inputs.

**What we'd pick:** if you have a 64GB Mac or a multi-GPU box and your work is long agentic coding sessions, ripple-preview is the interesting one to try — the context window alone justifies the experiment. If you have 32GB, flint or nemotron-3.5-bolt are the realistic agent options. If you have 16GB, mimo-v2.6. And if what you actually need is a solid coding model rather than an agent, [qwen2.5-coder:7b](/models/qwen2.5-coder:7b) remains the pragmatic default.

## No 64GB Mac? Your options

Most readers won't have the hardware for this one, and that's fine — there are two sensible paths.

If your machine doesn't fit the bill, smaller coding models run on modest hardware and are cheap to call through an OpenAI-compatible API when you don't want to run anything locally. qwen2.5-coder:7b, for instance, is callable from £0.063 per 1M output tokens:

(Live on Inpherio: https://inpherio.co.uk/models/qwen2.5-coder:7b)

If your hardware *does* fit — a 64GB Mac, a multi-GPU workstation, a server box sitting mostly idle — a 65B model with a 1M-token context is exactly the kind of thing that can earn its keep serving requests when you're not using it. [Become a host](/providers) and it can pay for itself between sessions.

We'll update this post when independent benchmarks, other engines, or a non-preview release appear. For the broader picture of what's worth running this month, see [our November overview](/blog/best-llm-right-now-what-s-trending-what-runs-what-we-d-pick-nov-2026).

## FAQ

**How much RAM does ripple-preview need?** The download is 39–46GB, and a model needs roughly its file size in RAM/VRAM plus room for context — so budget 48GB+ as a realistic floor, more if you want long agent sessions.
**Can ripple-preview run on a gaming GPU?** Not on a single consumer card. A 24GB GPU can only run it with heavy CPU offload at painful speeds; you need a 64GB Mac, a multi-GPU box, or server-class memory.
**What's ripple-preview's context window?** Ricursive says up to 1M tokens; Ollama's variant table lists 2M. Either way, every token of context adds memory on top of the 39–46GB model itself.
**Is ripple-preview open source?** It's Apache 2.0, so commercial use is allowed, and the weights are on Hugging Face as well as the Ollama library.
**Can I run ripple-preview with vLLM or LM Studio?** As of 10 November 2026, the Ollama page only documents Ollama. We haven't verified what run instructions the Hugging Face card carries, so check there before assuming other engines are unsupported.
