Key takeaways
- Ricursive released Ripple-65B Preview on November 4, 2026. The instruction-tuned BF16 and NVFP4 checkpoints are public, ungated and Apache 2.0; a separate BF16 base checkpoint and DFlash2 draft are also published.
- The model is a 64.8B-parameter dense Transformer with 80 layers, a 5,120-wide hidden state, 80 attention heads and a hybrid of sliding-window and global attention. Ricursive says it was pretrained on 12 trillion predominantly English and code tokens.
- OpenRouter exposes ricursiveai/ripple-65b-preview through one BF16 GMICloud endpoint at $0.20 per million input tokens, $0.60 per million output tokens and $0.05 per million cached-input tokens, with 1,048,576 total context and up to 131,072 output tokens.
- Ricursive reports 80.52 on Terminal-Bench 2.1 and says the full program cost $32 million. The model card mixes official comparison scores with Ricursive’s in-house evaluations and explicitly warns that agentic benchmark replication is difficult; AccessAllGPT did not reproduce the results.
- Trial the hosted route first on representative repositories and tool loops. Move to NVFP4 or BF16 self-hosting only when privacy, control or sustained volume justifies hardware and serving work, and keep the custom model code and preview status inside the risk review.
Ripple-65B Preview launched on November 4
Ricursive Intelligence released Ripple-65B Preview on November 4, 2026 as a general-purpose variant of the proprietary model behind its chip-design platform. The launch includes ricursiveAI/Ripple-65B-Preview in BF16, ricursiveAI/Ripple-65B-Preview-NVFP4 for lower-memory inference, a BF16 base checkpoint and a separate DFlash2 speculative-decoding draft. The principal repositories were public, ungated and tagged Apache 2.0 during review.
This is an available release rather than a promise of future weights. The BF16 instruction repository contains 16 safetensor shards and reports 64,782,689,360 parameters. Its stored artifacts total about 129.6 GB because BF16 uses roughly two bytes per parameter before ancillary files. The repository also ships custom configuration and modeling code, a tool-aware chat template and an SGLang serving recipe.
A dense 65B architecture targets coding and local control
Ripple is a dense Transformer rather than a mixture-of-experts model: all 64.8 billion parameters participate in each token. The checked config defines 80 layers, hidden size 5,120, intermediate size 40,960, 80 attention heads, eight key-value heads and a 1,024-token sliding window. Four sliding-attention layers alternate with one global-attention layer. Ricursive also describes gated attention, global NoPE, value residuals and feed-forward activation clipping.
Ricursive says pretraining used 12 trillion text-only, predominantly English and code tokens at 8K sequence length. The disclosed post-training sequence then includes 200 billion midtraining tokens at 64K, 6.5 billion long-context tokens at 2M, 183 billion supervised-fine-tuning tokens at 128K, 13.5 billion long-context SFT tokens at 2M and 700 reinforcement-learning steps. The company says post-training was comparatively light and focused on agentic coding; no independent training-data audit accompanies the release.
Hosted access is live, but the routes are not identical products
OpenRouter lists the exact API identifier ricursiveai/ripple-65b-preview. During review it had one GMICloud endpoint serving BF16 with a 1,048,576-token context window and a 131,072-token maximum completion. The endpoint accepted text, tools, automatic tool choice, structured response format, seeds and log probabilities. OpenRouter listed $0.20 per million input tokens, $0.60 per million output tokens and $0.05 per million cached-input tokens. Those registry prices and provider availability are time-sensitive.
Ricursive also links Together AI and GMICloud as launch hosts, and Together has a live model page. Hosted routes reduce the setup burden, but buyers should not assume identical precision, context handling, privacy terms, cache behavior or tool parsing across providers. Record the exact provider, route revision and request contract in evaluations rather than treating the model name as the entire product.
One million context is a supported ceiling, not a quality guarantee
Ricursive advertises support for up to one million tokens, and its two-B200 SGLang recipe sets a 1,048,576-token combined prompt-and-generation limit. The target config supports up to 2,097,152 positions, while the checked tokenizer metadata defaults to 131,072 and the DFlash2 draft uses a 16K attention window. These are distinct implementation limits, not contradictions: the effective ceiling depends on the serving stack and route.
No reviewed artifact establishes reliable recall, state tracking or tool use at every position in a million-token request. Long prompts also amplify cost, latency and evidence-selection problems. Test the lengths and document structures the product will actually use, including information near the beginning, middle and end, and preserve a retrieval or chunking fallback when whole-context quality drops.
The headline benchmark and cost claims need local confirmation
Ricursive reports 80.52 on Terminal-Bench 2.1, 79.1 on SWE-bench Pro v2.0 Hard and 44.3 on DeepSWE 1.1. It also reports 250 tokens per second on two B200 GPUs at batch eight and says the complete research-and-development program cost $32 million. Those are useful vendor disclosures, not independent measurements; AccessAllGPT did not reproduce them.
The model card is unusually direct about comparison limits: it combines official model-card scores with Ricursive’s in-house evaluation flow where official results were missing, uses different agent harnesses in specified cases and says replication has been challenging because sequence length, summarization and other settings move results. That caveat matters. A high aggregate score does not prove compatibility with a team’s repositories, dependency graph, approval policy, test runtime or recovery behavior.
What builders and buyers should do next
Start with a reversible hosted trial using pinned prompts and the exact provider route. Evaluate issue understanding, multi-file edits, test selection, tool-call validity, long-running recovery, unsupported assumptions and cost on representative repositories. Treat model-produced commands and patches as untrusted: keep least-privilege sandboxes, secret isolation, network controls, human approval for consequential actions and deterministic checks before merge.
Trial Ripple when an Apache-licensed dense coding model and provider choice are valuable. Constrain it behind a feature flag until quality, tool behavior, data handling and spend are measured. Wait on self-hosting until the NVFP4 or BF16 checkpoint fits the actual hardware and serving stack. Reject the migration if local task success, review burden or total operating cost does not beat the incumbent despite the headline benchmarks.
Copy-ready Ripple-65B evaluation record
Keep the hosted and self-hosted decisions separate while preserving comparable tasks and acceptance gates.
Entries stay in this browser tab and are not submitted to AccessAllGPT. Blank responses are copied as [Unresolved].
Coding or agent workflow, repositories, users, consequential actions, review owner and unacceptable failure modes.
Exact API ID and provider, or Hugging Face repository, commit SHA, BF16/NVFP4 precision, license and artifact hashes.
Runtime version, custom-code review, GPUs, context/output limits, chat template, tool parser, cache and concurrency.
Representative issues, languages, repository sizes, tool loops, long-context placements, malformed inputs and recovery cases.
Task success, test pass rate, invalid calls, unsupported assumptions, review time, latency, throughput, memory and incidents.
Input, output and cache tokens; provider price snapshot; hardware and operations; retries; reviewer time; expected monthly volume.
Sandbox, permissions, secrets, network, approvals, logs, retention, provider terms, rollback and incident response.
Trial, constrain, wait or reject; approved scope, traffic percentage, unresolved evidence, owner and retest date.
Primary sources
Browse the publication-wide evidence index →
- Introducing Ripple-65B Preview, a Frontier Open-Weight ModelRicursive Intelligence · Reviewed: Launch announcement; availability; training cost claim; reinforcement-learning recipe; architecture; model ladder; conclusion and footnote · Retrieved · Supports: Ricursive announced Ripple-65B Preview on November 4, describes its 65B dense architecture and 12-trillion-token pretraining run, names launch hosts, and reports its own benchmark, throughput and development-cost results. These remain vendor claims.
- ricursiveAI/Ripple-65B-Preview model card and repositoryRicursive Intelligence on Hugging Face · Reviewed: Repository metadata; model card; files; architecture config; tokenizer config; chat template; license; inference server instructions; benchmark methodology and limitations · Retrieved · Supports: The public, ungated repository contains the BF16 instruction model, custom architecture and serving code, 16 safetensor shards, an Apache 2.0 license, tool-aware chat template and a vendor benchmark table with methodology caveats.
- ricursiveAI/Ripple-65B-Preview-NVFP4 repositoryRicursive Intelligence on Hugging Face · Reviewed: Repository identity; creation and modification timestamps; access gate; license; safetensor parameter metadata and files · Retrieved · Supports: The public, ungated NVFP4 checkpoint is available under Apache 2.0. Its existence supports a lower-memory local evaluation path; it does not independently validate quality or hardware fit.
- Ripple-65B-Preview API model pageOpenRouter · Reviewed: Release date; model ID; modalities; provider; listed token prices; cache price; context and output limits; quantization; supported parameters; uptime and privacy label · Retrieved · Supports: OpenRouter lists the callable ricursiveai/ripple-65b-preview route, one BF16 GMICloud endpoint, a 1,048,576-token context window, 131,072-token maximum output and current token prices. Registry values can change.
- Ripple-65B Preview API: Pricing, Benchmarks & DocsTogether AI · Reviewed: Model identity; provider attribution; architecture; training-token summary; context; license and hosted availability · Retrieved · Supports: Together AI has a live model page for Ripple-65B Preview, corroborating that a second hosted access route exists. AccessAllGPT did not authenticate or call the Together API.
Limitations
This is a first-party release, repository and registry review—not hands-on model testing, an independent benchmark, a security audit, privacy assessment, legal opinion or procurement review. AccessAllGPT did not call Ripple through OpenRouter, Together AI or GMICloud; spend API credits; download or hash the roughly 129.6 GB BF16 repository; run BF16, NVFP4 or DFlash2; execute custom model code; inspect the full training corpus; reproduce Terminal-Bench, SWE-bench, DeepSWE, safety, long-context, throughput, compute-efficiency or cost claims; compare output quality with another model; validate one-million-token recall; measure latency, throughput, memory, power, uptime or total cost; or review provider data terms. Repository metadata, hosted routes and prices can change. Apache 2.0 availability does not by itself establish fitness, safety, non-infringement or compliance for a particular deployment.
Disclosures
AccessAllGPT received no weights, hosted access, API credits, hardware, private demo, briefing, benchmark data, review, payment or compensation for this article. Ricursive Intelligence, OpenRouter, Together AI and GMICloud did not sponsor, review or endorse it. AccessAllGPT did not test, score, rank or certify Ripple-65B Preview. AccessAllGPT Research is operated by NeuralArc, is independent, and is not affiliated with Ricursive Intelligence or the distribution providers. Publication-wide relationships are listed on the disclosures page.
