Ripple-65B Preview targets open-model leadership in agentic coding

Ricursive Intelligence has released Ripple-65B Preview, a 65-billion-parameter open-weight language model aimed at software-engineering tasks and agentic coding. The company says the model achieved the highest TerminalBench 2.1 score among open U.S. models, while its Apache 2.0 license gives developers broad rights to inspect, modify, and deploy the model.

The release arrives as coding models are increasingly judged not only by code-generation tests, but by their ability to operate tools, navigate repositories, and complete multi-step tasks. Ripple’s reported results therefore position it as a model for autonomous development workflows rather than simply another general-purpose language model. However, the available evidence is largely based on Ricursive’s own performance claims, and comparisons with other models remain mixed.

A dense 65-billion-parameter model for coding agents

Ripple-65B Preview was pretrained on 12 trillion tokens, according to reporting by The Decoder. Ricursive describes the system as a dense Transformer with 65 billion parameters, rather than a mixture-of-experts model that activates only part of a larger parameter pool for each request.

The architecture choice has practical consequences for teams considering deployment. A dense model can be simpler to reason about operationally, although a 65-billion-parameter system still requires substantial memory and infrastructure. The Decoder reports that Ripple is optimized for Nvidia hardware and may be easier to deploy on users’ own machines than some competing open models.

For agentic coding, the model is used partly with Terminus 2 and partly with OpenCode as its harness, according to The Decoder. Those harnesses provide the surrounding environment through which a model can interact with code, tools, and development tasks. In practice, results from such systems depend on more than the model’s weights: prompt design, tool access, repository setup, execution limits, and error recovery can all affect the outcome.

TerminalBench result carries the main claim

Ricursive says Ripple-65B Preview scored 80.52 on TerminalBench 2.1, which the company presents as the leading result among open U.S. models. VentureBeat separately characterized the release as claiming a U.S. open-coding lead on two major benchmarks, but its full article text was not available in the supplied evidence. The second benchmark and its result therefore cannot be independently detailed here.

The TerminalBench claim should be read as a vendor-reported benchmark result rather than an independently verified market ranking. The available reporting does not establish the exact evaluation setup, hardware, prompting conditions, agent harness configuration, or comparison set used for the “open U.S. model” distinction. Those details matter because agent benchmarks can be sensitive to the tools and runtime environment surrounding the model.

The Decoder also reports that Ripple trails the newly released Inkling 2 Small on other benchmarks. That contrast is important: a strong score on a terminal-based coding evaluation does not automatically mean the model is best for general reasoning, code completion, instruction following, or production reliability. Builders will need to evaluate the model against their own repositories and operating constraints rather than treating one leaderboard result as a complete capability profile.

Apache 2.0 access changes the deployment equation

Ripple-65B Preview is available through Hugging Face under the Apache 2.0 license. That is a meaningful part of the release for companies that want more control over model hosting, customization, and integration than is available through a closed API. The license generally permits commercial use and modification, subject to its stated terms, but organizations would still need to review compliance, attribution, patent, and downstream-risk requirements for their particular deployment.

The model’s open-weight status also gives engineering teams the ability to test performance without committing immediately to a proprietary provider’s serving stack. That can matter for sensitive source code, regulated environments, offline development, and applications where API costs or latency are difficult to predict.

At the same time, open weights do not eliminate deployment costs. A dense 65-billion-parameter model may require multiple high-memory GPUs or carefully optimized quantization to serve efficiently, and the supplied evidence does not provide latency, throughput, memory, or quantization figures. The practical cost advantage over hosted alternatives therefore remains workload-dependent.

Ricursive says total research and development spending, including training, was $32 million. That figure is another company-reported claim, and the evidence does not break out compute, staffing, data, evaluation, or infrastructure costs. Even so, it signals the company’s intended argument: a relatively focused team can produce a competitive coding model without the spending levels associated with the largest frontier-model programs.

What the release means for builders and enterprises

For AI builders, Ripple is most relevant as a candidate engine for repository agents, terminal-based coding assistants, and internal developer tools. Its reported TerminalBench performance suggests that teams should test it on workflows involving shell commands, code changes, test execution, and iterative debugging—not only on static programming questions.

The model may also appeal to organizations that prioritize control over model placement. Running weights inside a company’s environment can reduce dependence on external inference APIs and make it easier to enforce internal data-handling policies. But those benefits must be weighed against GPU procurement, model serving, monitoring, access controls, and the need to maintain the surrounding agent system.

For researchers and competing model developers, the release highlights a widening gap between model size and benchmark specialization. Ripple does not lead every reported evaluation, yet it may be competitive where tool use and long-horizon coding behavior are emphasized. That makes evaluation design increasingly important: a model can be a strong choice for one engineering loop and a poor fit for another.

What to watch next

The most important follow-up is an independently reproducible TerminalBench 2.1 evaluation, including the precise harness, prompts, tools, hardware, and model settings used. More complete results for the second benchmark mentioned by VentureBeat would also clarify the scope of Ricursive’s leadership claim.

Developers should watch for public measurements of inference memory, throughput, quantized variants, context limits, and performance across common codebases. Those figures will determine whether Ripple-65B Preview is practical for local or private deployment, not just whether it performs well on a leaderboard.

The community should also compare Ripple directly with Inkling 2 Small and other open coding models across security-sensitive tasks, bug fixing, test generation, and sustained repository maintenance. Model-card documentation, safety guidance, and evidence of how the system behaves when tools return errors will be especially relevant for enterprise adoption.

Creati.ai perspective

Ripple-65B Preview is notable less because one benchmark settles the open-model race than because it combines a substantial dense model, a permissive license, and a clear focus on agentic coding. That combination gives builders another model to test when local control and terminal interaction matter.

The release should nevertheless be evaluated as a promising but incomplete data point. Ricursive’s strongest results and $32 million cost figure are vendor-reported, while the model’s weaker showing on other benchmarks argues for task-specific testing. The next stage of the story will be determined by reproducibility and real deployment economics, not the headline score alone.