Ripple-65B Preview

Ripple-65B Preview is a dense 65-billion-parameter language model developed by Ricursive Intelligence and released on November 4, 2026. Pretrained from scratch on a massive 12-trillion-token corpus of predominantly English text and code, the model is engineered specifically for agentic software engineering, complex multi-step reasoning, and programmatic tool execution. It is published on Hugging Face under a permissive Apache 2.0 license, providing complete commercial freedom for both local deployments and self-hosted infrastructure.

While the frontier open-weight space has increasingly trended toward sprawling Mixture-of-Experts (MoE) architectures, Ricursive built Ripple-65B as a modernized, compute-dense monolithic Transformer. On agentic coding benchmarks, it achieves an 80.52 score on TerminalBench 2.1, matching or outperforming models that carry five to ten times as many total parameters.

For engineers seeking a local AI model with 65B parameters in 2026, Ripple-65B Preview occupies a compelling tier. It combines an architectural context window of up to 1,048,576 tokens (1M) with high compute density, allowing developers to execute full repository audits, autonomous bash scripting, and complex reasoning pipelines directly on local hardware without sending proprietary code to hosted API providers.

Ripple-65B Preview relies on a pure dense Transformer architecture. Every parameter is active during inference, which gives it predictable compute characteristics and avoids the high static VRAM overhead associated with routing through inactive expert layers in MoE setups.

The model adopts a thin-and-deep aspect ratio consisting of 80 layers paired with a relatively narrow hidden dimension (d_model) of 5120. Moving away from standard Llama-style foundations, the architecture incorporates design elements inspired by Gemma 3N to ensure gradient stability across its 12-trillion-token pretraining run. To boost reasoning capacity without inflating the raw parameter count, Ricursive overprovisioned the total number of attention heads while recalibrating the sliding window attention (SWA) to global attention layer ratio.

Key architectural components include:

• Attention Mechanism: Gated attention with global NoPE (No Positional Embeddings) and a compressed sliding window attention pattern to offset head overprovisioning.
• Layer Dynamics: Thin-and-deep 80-layer stack utilizing value residuals and Feed-Forward Network (FFN) activation clipping to prevent loss spikes during long-context execution.
• Context Length: Native architectural support for up to 1,048,576 tokens, trained via midtraining and long-context Supervised Fine-Tuning (SFT) stages.
• Precision: Shipped natively in BF16 (129.57 GB across 16 safetensors shards), alongside an official experimental NVFP4 build (57.22 GB) optimized for Blackwell-generation tensor cores.

Ripple-65B Preview is targeted directly at agentic workflows, software development, and structured problem-solving. It is not a generalized conversational toy; its post-training pipeline heavily emphasizes terminal tool execution, multi-turn instruction-following, and autonomous code generation.

Using Ripple-65B Preview for coding goes beyond autocomplete or single-function generation. The model is tuned for execution inside autonomous terminal environments. It excels at parsing compiler errors, inspecting directory trees, applying multi-file Git diffs, and self-correcting based on stdout and stderr feedback. Its 80.52 score on the TerminalBench 2.1 reasoning benchmark validates its ability to manage realistic developer command-line tasks without human intervention.

With context support scaling up to 1M tokens, the model can ingest entire code repositories, architecture diagrams, and comprehensive API documentation within a single session. This makes it ideal for finding cross-file dependency bugs, generating exhaustive integration tests, and translating legacy codebases across languages.

The model includes native function-calling and tool-orchestration capabilities. It handles strict JSON schema outputs reliably, enabling practitioners to embed it into multi-agent systems where it can interact with databases, external linters, web scrapers, and local system APIs.

Running a dense 65B model locally requires deliberate memory planning. Because all 65B parameters are active on every token, your inference speed is directly bounded by your system memory bandwidth, while your context depth is limited by available VRAM.

Memory requirements depend heavily on quantization and the target context length:

• BF16 (Unquantized): Requires approximately 130 GB to 140 GB of VRAM just to store the weights. Serving at full precision requires a multi-GPU workstation (such as dual 80GB or 96GB enterprise cards).
• 8-bit Quantization (Q8_0 / FP8): Requires approximately 68 GB to 72 GB of VRAM. Fits comfortably on workstations with 96 GB of total VRAM or large unified-memory systems.
• 4-bit Quantization (Q4_K_M / NVFP4): Requires approximately 38 GB to 42 GB of VRAM for the weights alone. With an 8k to 16k context window, total memory sits right around 45 GB to 48 GB.

For most local practitioners, the best quantization for Ripple-65B Preview is Q4_K_M (or NVFP4 if using modern NVIDIA hardware). Q4_K_M retains virtually all of the model's coding logic and terminal reasoning capabilities while bringing the footprint within reach of workstation-class hardware.

To run Ripple-65B Preview locally without aggressive CPU offloading penalties, you need a hardware configuration that supplies at least 48 GB of high-speed memory:

• Dual NVIDIA RTX 3090 or RTX 4090 (48 GB Total VRAM): The standard dual-GPU setup for local builders. Running Q4_K_M across two 24GB GPUs via tensor parallelism or layer splitting allows you to run the model at reasonable context sizes (16k to 32k tokens) with pure GPU execution.
• Apple Silicon (Mac Studio / MacBook Pro with M3/M4 Max or Ultra): Machines equipped with 64 GB, 96 GB, or 128 GB of unified memory are ideal for this model. A 128 GB M4 Max or Ultra can load the Q4_K_M or Q8_0 build entirely into memory with plenty of headroom for extended context windows.
• NVIDIA DGX Spark / Workstation Accelerators: If you run dedicated AI workstations, the best GPU for Ripple-65B Preview in BF16 or NVFP4 is modern enterprise silicon with high FLOP capacity, where the model can generate at maximum throughput.

Ripple-65B Preview performance scales cleanly with memory bandwidth:

• Dual RTX 4090 (Q4_K_M via llama.cpp / vLLM): Expect roughly 15 to 25 tokens per second at short to medium context lengths.
• Apple Silicon M4 Max (128 GB Unified Memory, Q4_K_M): Delivers between 14 and 20 tokens per second.
• Datacenter Accelerators (e.g., dual NVIDIA B200, BF16, batch=8): Capable of sustained throughput up to 250 tokens per second.

The quickest way to evaluate Ripple-65B Preview locally is through Ollama or llama.cpp. Once GGUF weights are downloaded:

1. Create a Modelfile pointing to your quantized GGUF:

1   FROM ./ripple-65b-preview.Q4_K_M.gguf
2   PARAMETER temperature 0.2
3   PARAMETER stop "<|im_end|>"

1. Build and run the local container:

1   ollama create ripple-65b -f Modelfile
2   ollama run ripple-65b

If you only have a single 24GB GPU (like a solitary RTX 4090), you will need to offload 20 to 25 layers to system RAM. This will dramatically reduce Ripple-65B Preview tokens per second down to 3 to 6 tok/s, making a dual-GPU or unified-memory rig the recommended route for serious daily use.

Llama 3.3 70B is the standard benchmark for dense open-weight models in this weight class. Llama 3.3 offers broader multilingual fluency and a standardized 128k context window supported by every toolchain. Ripple-65B Preview, however, focuses heavily on developer tool execution. On command-line agent tasks and multi-turn coding problem-solving, Ripple's thin-and-deep 80-layer architecture and 1M context potential make it significantly more capable in programmatic loops, whereas Llama 3.3 acts as a broader, general-purpose conversationalist.

Qwen 2.5 72B is renowned for code generation and mathematical reasoning. When comparing Ripple-65B Preview vs Qwen 2.5 72B, Qwen holds an edge in non-English programming contexts and mathematical proofs. Ripple-65B Preview counters with superior autonomous execution in bash environments, tighter function calling compliance, and lower VRAM consumption (65B versus 72B), which makes fitting inside tight 48 GB dual-card VRAM envelopes noticeably easier.