Ripple-65B runs a coding agent on one 48 GB card, slowly and cleanly
Ripple-65B at 4 bits on one RTX A6000: about 15 tokens/s, a planted bug fixed in 6 turns. A 24 GB RTX 3090 runs it at 2 bits, with one wrong test.
Can a team run a new open 65-billion-parameter coder on one card it rents by the hour? Yes, if the card has 48 GB and you can wait. Ripple-65B Preview, from the US lab Ricursive Intelligence, ran on one RTX A6000 on our cloud with a 4-bit file of 38.8 GB. It wrote about 15 tokens (roughly words) per second. It fixed a bug we planted in a toy repository in 6 turns and 35 seconds, and every tool call it made was valid. For anyone who deploys models, that is an Apache 2.0 coding agent you control, on hardware you can rent today. A 24 GB RTX 3090 runs it too, at 2 bits and faster, but one of its three coding answers came with a wrong test. The 48 GB card gave the clean result.
A from-scratch open coder, and a community that ported it in two days
Ricursive trained Ripple from scratch and gave it away under Apache 2.0, with no form to fill in. The weights went up on Hugging Face on 4 November. The authors say it was trained on 12 trillion tokens and reads prompts of up to about a million.
Their headline number is on Terminal-Bench 2.1, a test of agents working in a command line: 80.5, which in their own table is a 0.4-point lead over Reflection Beam, a 501B model. Effectively a tie, and self-reported: the authors themselves call it a "best-effort attempt". On most other rows of the same table a rival is ahead. On SWE-bench Verified, built on real GitHub issues, Ripple scores 76.5 against 81.6 for Reflection Beam. A strong open result, not a claim to beat the best closed coders.
Ricursive's own builds target data-center hardware most teams do not own. The route to one card came from the community. A port of Ripple into llama.cpp, a free program for running models on your own card, was merged on 5 November. Nik Bogatyrev submitted it, and AtomicChat's card says AtomicChat wrote it. AtomicChat published llama.cpp files the same week, from 129.6 GB at full precision down to 18.5 GB. Our part was the deployment, the prompts, the sandboxed agent task and the memory tests on two real cards.
Dense means about 15 tokens per second, and that is the deal
Every rival in Ricursive's table is a mixture of experts: each word they write uses only 23B to 55B of their parameters. Ripple is dense. Every word goes through all 65 billion, so at 4 bits the card reads nearly the whole 38.8 GB file from memory for each word. The A6000 can do that about 15 times a second. Memory speed, not arithmetic, is the ceiling.
In practice that is a 400-token answer in about 27 seconds, and short questions start answering in under a second. For one developer driving an agent, workable, not snappy.
What we saw on the 48 GB card
The agent job was a toy repository with an off-by-one bug that made a test fail. The model had one tool, a shell, inside a sandbox with no network. Ripple read the code, ran the tests, saw them fail, changed one <= to <, reran them and reported back. It never touched the tests. All 4 of its coding answers with the 4-bit file were right, and every tool call came back in the standard format existing agent code reads.
Long prompts are cheap in memory. The same card found a passphrase hidden at token 237,532, using about 46 GB. The catch is time: reading that prompt took about 13 minutes. And the full million is out of reach on one 48 GB card. About 256K tokens, with the model's notes on the prompt compressed, is its limit.
| Card | File | Speed (tokens/s) | Coding answers right |
|---|---|---|---|
| RTX A6000 48 GB | 4-bit, 38.8 GB | 14 to 16 | 4 of 4 |
| RTX 3090 24 GB | 2-bit, 20.0 GB | 23 to 31 | 2 of 3 |
The 3090 is a real 24 GB gaming card, not a budget we simulated. With fewer bits per number the file is smaller and faster to read, but the numbers are rougher. The bug-fix job still passed. The slip showed up where the model had to write a new test of its own. That points the same way as AtomicChat's own measurements: their card says the 2-bit file disagrees with the full model on the next word almost 20 times in 100, against about 7 for the 4-bit file.
On InferenceKey, once the file was on the machine, Ripple was answering 19.0 seconds after we asked for it on the A6000, and 19.3 on the 3090, because the worker downloaded a ready-made llama.cpp instead of building it.
Who should care
- You have a 48 GB card and want an open coding agent you control: worth a try. The 4-bit file gave our cleanest results.
- You need long prompts: a 237K-token prompt fit on 48 GB. Plan on minutes per question, not seconds.
- You have a 24 GB card: the 2-bit file runs, and faster, but review the tests it writes.
- You need speed above all: look elsewhere. Being dense, Ripple reads the whole model for every word.
The honest limit: we sent one request at a time with our own small prompts, each check once or a few times, so a card shared by several agents will be slower by an amount we have not measured, and this is a Preview.
Read the full Ripple-65B test for the memory table by card size, the tool-call samples and the long-prompt runs.