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.

Listen to this post · 11 min

Accessibility: the whole post is read aloud — Space plays or pauses, ← → skip 10 seconds, and you can change the speed. It keeps playing with your screen locked.

Share this post

In short

  • 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, nemotron-3.5-bolt, mimo-v2.6 — 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 alongside the Ollama page.
  • 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:

HardwareVerdict
8–16GB laptopNo
24GB gaming GPUOnly with heavy CPU offload, at painful speeds
64GB Mac (M-series, unified memory)The comfortable fit
Multi-GPU / server-class boxYes, comfortably

The dense architecture is the reason it's so heavy. Compare it with flint, the 40B MoE coding agent we covered in October: 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:

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 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.

ModelParametersDownloadContextLicenceHardware class
ripple-preview65B dense39–46GB1M (2M listed)Apache 2.064GB Mac / server
flint40B MoE23GB256KApache 2.032GB+ machine
nemotron-3.5-bolt74B-A9B MoE25GB256KNVIDIA open model licence32GB+ machine
mimo-v2.69B dense6.6–8.7GB256KMIT16GB 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 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:

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 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.

Questions people ask

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.

Models in this post — live on Inpherio

Have a GPU, a Mac or a spare PC?

Let it earn while you sleep.

Run open models for people who need them. You set the price and keep everything but the 15% fee.

Become a host

Building with AI?

Every open model, one API.

OpenAI-compatible. Priced by the people who run the hardware.

Start free See the marketplace

Read “ripple-preview on Ollama: Ricursive's 65B agentic-coding model, first look” at https://inpherio.co.uk/blog/ripple-preview-on-ollama-ricursive-s-65b-agentic-coding-model-first-lo