Ripple-65B Tested Locally: Recursive Intelligence's Dense Coding Model

Recursive Intelligence released Ripple-65B, a 65 billion parameter dense transformer for agentic coding, as a preview under the Apache 2.0 license on Hugging Face as ricursiveAI, trained on 12 trillion tokens of mostly natural English text and code. A hands-on local test found deployment took hours rather than minutes, requiring a custom VM and a quantized checkpoint using about 75GB of VRAM, plus manual rewrites of the provided inference code for a different GPU than it was built for. In testing, Ripple-65B found a deliberately planted subtle bug in a full-stack retirement calculator app, correctly diagnosed a decimal formatting error, and fixed it without hand-holding, while trailing larger models in math, safety, and automation benchmarks.

Ripple-65B Tested Locally: Recursive Intelligence's Dense Coding Model A hands-on local test of Ripple-65B, a dense 65B transformer for agentic coding, covering setup, VRAM needs, and real bug-fixing results. What is Ripple-65B? Ripple-65B is a 65 billion parameter dense transformer built by a small team at Recursive Intelligence listed on Hugging Face as ricursiveAI , released as a preview under the Apache 2.0 license. Unlike most current frontier models, which use a mixture of experts MoE architecture that only activates a slice of parameters per token, Ripple runs all 65 billion parameters on every token. It’s aimed specifically at agentic coding and reasoning tasks, supports long context, and is small enough to run on a single high end workstation GPU setup like an Nvidia DGX Spark or equivalent, once quantized. TL;DR - Dense architecture means Ripple uses all 65B parameters on every token instead of routing through experts, a deliberate contrarian choice while most labs chase MoE efficiency. - Thin and deep design gives the model 80 layers with a narrow width, a Gemma style layout for training stability, extra attention heads, and sliding window attention to control compute cost. - Training ran on 12 trillion tokens of mostly natural English text and code during pretraining, with synthetic data deliberately held back for later stages so the team could iterate on it independently. - Post-training is still light in this preview release, covering mid-training, long context fine-tuning, supervised fine-tuning, and reinforcement learning across mixed domains, with more to come before a full release. - Benchmarks show it leading on terminal-based agentic coding and SWE-bench style software engineering tests against much larger models, while trailing in math, safety, and automation categories. - Local deployment took hours, not minutes , requiring a custom VM, a quantized checkoint using about 75GB of VRAM, and manual rewrites of the provided inference code for a different GPU than it was built for. - In hands-on testing , the model found a deliberately planted, subtle bug in a full-stack retirement calculator app, correctly diagnosed a decimal formatting error, and fixed it without hand-holding. mission-critical enterprise applications. ✓ HIPAA ✓ SOC 2 ✓ Self-hosted How does Ripple-65B’s architecture differ from mixture-of-experts models? Most large language models released by major labs in the last two years use mixture of experts designs. In an MoE model, each token only activates a subset of the total parameters, which keeps inference cheaper relative to the model’s total size. Ripple goes the opposite direction. It’s fully dense, meaning every one of its 65 billion parameters participates in processing every token. The tradeoff is straightforward: dense models are generally more expensive to run per token than an MoE model with the same total parameter count, but they can be simpler to train and, in Recursive Intelligence’s telling, easier for a small team to iterate on. The model is also described as “thin and deep,” with 80 transformer layers and a comparatively narrow width per layer, rather than the wider, shallower designs common elsewhere. The team adopted a Gemma style layout for training stability, added extra attention heads to support reasoning, and used sliding window attention with a smaller window size in most layers to hold down compute costs. Additional architectural choices include gated attention and value residual connections, both aimed at improving training stability and output quality without ballooning parameter count. What was Ripple-65B trained on? Pretraining used 12 trillion tokens, made up mostly of natural English text and code, with the team deliberately avoiding heavy reliance on synthetic data during this phase. According to the model’s documentation, synthetic data was held back and introduced later so the team could refine it independently without disrupting or blocking the pretraining run. After pretraining, the model went through several post-training stages: mid-training, a long context stage, supervised fine-tuning, a second long-context fine-tuning pass, and finally reinforcement learning across a mix of domains. Recursive Intelligence has been explicit that this release received comparatively light post-training, with the main focus placed on agentic coding capability rather than broad general-purpose polish. That framing matters for anyone evaluating the model: this is explicitly a preview, not a finished product, and later post-training rounds are expected to change its behavior. How does Ripple-65B perform on coding benchmarks? On published benchmarks, Ripple scored well on agentic coding tasks, including a terminal-based benchmark and a harder software engineering benchmark resembling SWE-bench style evaluation, outperforming several models with significantly more parameters. On a deep software-engineering benchmark it landed near the top group of tested models, though Meta’s comparison model scored clearly higher there. The weaker spots were math, safety, and automation benchmarks, where models from Meta and a “Reflection” comparison model led. The overall shape of the results suggests a model that punches above its weight specifically in coding-oriented agentic tasks, with real gaps elsewhere that the team will presumably try to close in later training rounds. What happened in hands-on local testing? made for the enterprise. A tester ran Ripple-65B against a real, running full-stack application: a retirement calculator covering 20 countries, built with a typical frontend/backend/cache/database setup inside Docker. A single subtle bug had been planted in the code, one that didn’t crash the app or produce obviously wrong logic on inspection, but silently miscalculated retirement savings by treating a withdrawal rate as “4” instead of “0.04,” making every calculated result roughly 100 times too small. Early attempts through hosted API providers hit token limit errors rather than producing a usable result. The tester then moved to a self-hosted setup: a VM with 96GB of VRAM, running a quantized version of the model that consumed about 75GB of VRAM. Getting this working required downloading and configuring the model from scratch, and importantly, rewriting the inference code that Recursive Intelligence provided, because it was originally built for a different GPU than the RTX Pro 6000 Blackwell card used in testing. The tester also had to stand up a small serving layer and configure it with an agent framework Hermes before the same buggy application could be tested again. Total setup time across both attempts ran to several hours. Once running locally, the model correctly identified the planted bug on its own, without being told where to look, and explained the root cause: the decimal formatting error in how the withdrawal rate was stored and used. After the fix was applied, the calculator produced sensible retirement numbers across multiple countries. The same local setup was also tested with a complex, multi-table SQL/Databricks query task involving nested arrays, structs, and maps, designed to trap models into double-counting revenue across joins or mishandling window functions like percent rank and qualify . The model built its answer as a sequence of smaller steps, summed line items and refunds separately before joining them, and handled the ranking and regional breakdown logic correctly. Is Ripple-65B worth running locally? For developers specifically interested in agentic coding and debugging tasks, the benchmark results and hands-on bug-fixing test suggest real capability, particularly for a dense model of this size competing against much larger systems. The Apache 2.0 license also removes usage restrictions that come with many other open model releases. The practical catch is deployment friction. Running the model locally required nontrivial VRAM around 75GB in quantized form , a capable workstation GPU, and manual engineering work to adapt the provided inference code to different hardware. This isn’t a model you run casually on a laptop. It’s also explicitly a preview with light post-training, so behavior in areas like safety, math, and general reasoning may lag the coding-specific results until Recursive Intelligence ships a more fully trained version. Frequently Asked Questions What does “dense” mean for a language model like Ripple-65B? A dense model activates all of its parameters for every token it processes, unlike mixture-of-experts models that route each token through only a subset of specialized sub-networks. Ripple-65B uses all 65 billion parameters on every token. How much VRAM does Ripple-65B need to run locally? In testing, a quantized version of the model used approximately 75GB of VRAM on a 96GB VRAM VM, running on an Nvidia RTX Pro 6000 Blackwell GPU. The developers also indicate it can fit on hardware like DGX Spark class devices. What license is Ripple-65B released under? It’s released under Apache 2.0, a permissive open source license that allows commercial use, modification, and redistribution with minimal restrictions. Without shadow IT. Deal desk ✓ IT approved Expenses ✓ IT approved Onboarding ✓ IT approved Inspections ✓ IT approved What is Ripple-65B best at compared to other models? Benchmark results show it performing strongly on agentic coding tasks, including terminal-based and software engineering benchmarks, often outperforming larger models. It trails comparison models in math, safety, and automation benchmarks. Is Ripple-65B a finished, production-ready model? No. Recursive Intelligence describes this as a preview release with relatively light post-training, focused primarily on agentic coding. Further training stages are expected before a more complete version ships.