Former Google employees claim Ripple leads on two coding benchmarks

Ricursive Intelligence has released Ripple-65B Preview, an open-weight model under the Apache 2.0 license. The company says it scores higher than other US open models on Terminal-Bench 2.1 and SWE-bench Pro v2.0 Hard, benchmarks for terminal-based coding and complex engineering tasks. Ripple is available to download on Hugging Face and through several API providers. But its lead is limited to the selected benchmarks: it trails competitors on others, and its claimed one-million-token context window exceeds the 16,384-token limit listed by OpenRouter.

Ricursive releases Ripple-65B and claims the lead on two benchmarks

From chip-design platform to open model

Ricursive developed its own language model for a chip-design platform, then prepared a public version for other tasks. The company describes Ripple as a general-purpose counterpart to the closed model used in its platform. It is related technology, not the chip-design system itself.

Ricursive’s founders — CEO Anna Goldie and CTO Azalia Mirhoseini — previously helped develop AlphaChip, Google’s reinforcement-learning program for chip design.

In January, the startup announced a $300 million Series A at a $4 billion valuation. Lightspeed led the round. Investors included NVentures, Nvidia’s investment arm, DST Global and Sequoia.

Ripple’s coding results offer a way to assess one Ricursive model, but on their own they say nothing about how effective the company’s separate chip-design platform is.

Benchmark results

Ripple has 65 billion parameters — numerical values the model adjusts during training. Ricursive trained it from scratch on 12 trillion tokens. In its launch materials, the company highlighted tasks that require the model to take several steps and use software tools.

Ripple scored 80.1 on Terminal-Bench. It was followed by Reflection’s Beam at 79.7, Meta’s Muse Spark Open at 76.4, Thinking Machines’ Inkling at 63.8 and Nvidia’s Nemotron 3 Ultra at 56.4. After rounding, the difference between Ripple and Beam is about 0.4 percentage points. Ricursive also says it achieved this result with roughly 15 times fewer total parameters than Inkling.

In its launch chart, Ripple also leads these models on SWE-bench Pro v2.0 Hard. The result is different on DeepSWE: Meta scored 60.0, compared with Ripple’s 44.3. Meta also scores higher than Ripple on the cited automation and adversarial-attack safety tests, while both Meta and Reflection score higher on the math benchmark.

These results do not establish overall coding leadership. In a comparison published by Reflection, several Chinese-developed models outperform Ripple on Terminal-Bench. Reflection’s updated figures for Beam also show 77.2 on SWE-bench Pro v2-Hard and 44.4 on DeepSWE. These are estimates from different companies, not the results of a controlled comparison between two models.

Why the figures are hard to compare

Ricursive’s materials contain discrepancies. Its model card lists Meta at 52.3 and Inkling at 2.0 on SWE-bench Pro v2.0 Hard, while the launch chart gives them 72.4 and 39.6. Some competitor results on DeepSWE differ as well.

The model card says the tables combine published results with internal estimates. Ricursive acknowledges that reproducing AI-agent benchmarks is difficult and notes that the evaluation framework chosen affects the final scores.

For teams choosing a model, this makes it harder to predict results in their own workflows. An AI agent’s performance depends on the tools available to it, how it manages a long conversation and how it handles errors. A benchmark score therefore reflects not only the model itself, but also the conditions under which it runs.

The results make Ripple a candidate for testing, but do not show whether it will handle a specific company’s tasks more accurately, quickly or cheaply.

How Ricursive explains its training costs

Ricursive estimates the total cost of preparing Ripple at $32 million. According to the company, that figure includes preliminary training experiments, data preparation, evaluations, debugging, synthetic data generation, development of later training stages and final runs. For comparison, Ricursive cites estimates of hundreds of millions or even billions of dollars for other advanced closed models.

The startup also estimates its costs at about one-tenth those of the previous US leader among open-weight coding models. Ricursive based this estimate on published data from Reflection about compute resources and training duration. It is not a comparable financial report from the two companies.

Ricursive’s case for training efficiency rests on two technical arguments.

First, Ricursive says that 1.4 million rollouts were enough for reinforcement learning to reach its published Terminal-Bench result. A rollout is a sequence of model actions that researchers evaluate and use as training feedback. According to the startup, that is about 70 times fewer than Reflection required.

Reflection separately reported running more than 100 million rollouts over a four-week reinforcement-learning cycle. The rollout count alone does not establish comparable savings: sequences can vary in length, hardware requirements and evaluation cost.

Second, Ricursive says it improved pretraining efficiency by changing the model structure, settings and data. Experiments began with Olmo 3, with changes first tested at smaller scale before moving to a larger model.

According to the company’s chart, the final training setup reached a comparable code-prediction loss while using up to 16 times less compute on a 4-billion-parameter model. That result applies to a specific training objective. It does not mean the AI agent became 16 times more efficient or costs 16 times less to run.

Architecture and running on local hardware

Ricursive chose a dense architecture: the model uses its full set of parameters during generation. The company says this was easier to train than a mixture-of-experts model, which routes compute through separate parts of a larger system.

Ripple has 80 layers, and its structure was optimized for Nvidia hardware. The company reports roughly 40% model FLOPs utilization, a measure of how fully training uses available compute. Ricursive says this did not require custom kernels or quantization during training.

The model sizes need some clarification. Ripple’s model card lists 65 billion active parameters, while Beam has 23 billion active parameters out of 501 billion total. Total parameter count and compute per generated token are different measures.

For local use, Ricursive mentions Nvidia DGX Spark and, in a social media post, a MacBook. The launch description does not specify the laptop’s memory configuration, operating speed or available context length in this setup.

The model card includes instruction-tuned weights in BF16 and compressed NVFP4 formats, as well as a base model in BF16. Developers evaluating local deployment need to check memory use and performance for each version separately.

API access and pricing

The most specific published price is for Ripple through OpenRouter and the GMI Cloud endpoint: $0.20 per million input tokens and $0.60 per million output tokens. OpenRouter lists cached input tokens at $0.05 per million. The endpoint currently supports a context of up to 16,384 tokens, so this price does not establish access to the claimed one-million-token window.

Together’s model page says Ripple will soon be available through its serverless API, but its public pricing list did not include a separate price for the model. Fireworks’ documentation also has no Ripple-specific price. For dense models with more than 16 billion parameters and no individual price, Fireworks lists a standard rate of $0.90 per million tokens, the same for input and output. That cannot be treated as a confirmed price for Ripple.

GMI Cloud’s public page covers GPU compute rentals, while the Ripple-linked console page did not show a readable price. The OpenRouter rate therefore confirms the cost of that particular access route, not GMI Cloud’s direct price.

Ripple’s listed rates are below Together’s published prices for Beam — $0.40 per million input tokens and $1.20 per million output tokens. But Ripple is not the cheapest hosted option: Together lists GPT-OSS-120B at $0.15 per million input tokens and $0.60 per million output tokens. This compares prices across different providers, whose operating conditions may differ.

For AI agents, token prices are only part of the cost. Teams also need to account for the amount of text per task, the number of retries and the cost of the environment in which the agent runs tools.

Apache 2.0 and commercial use

Ricursive’s model repository includes an Apache 2.0 license. It permits commercial use, modification and redistribution subject to the license terms.

Companies can adapt the model and include it in commercial products without paying model-license royalties. The published terms set no revenue or monthly-user threshold that would require a separate commercial agreement.

Redistribution still comes with obligations: recipients must receive a copy of the license, changes to modified files must be noted, and applicable copyright and attribution notices must be preserved. If the distribution includes a NOTICE file, relevant notices must be included in distributed derivative versions.

Apache 2.0 does not require publishing all changes under the same terms, and it does not grant broad rights to Ricursive’s trademarks or provide a general warranty.

The license for the weights and an API provider’s agreement govern different matters. Downloading the model does not eliminate hardware and operating costs, while API use is subject to the provider’s pricing and terms.

What enterprise teams can test

Ripple combines downloadable weights, a permissive license, Ricursive’s claimed coding results and a low-cost API access option. Developers’ next step is to compare it on their own repositories and with the AI-agent software they use. The evaluation should track tasks completed, errors, time spent, token use and the amount of human intervention required. For local deployment, memory requirements and performance should be measured separately.

Ricursive is inviting teams to test whether a model with fewer total parameters can handle tasks usually assigned to larger US open-weight models. Dataist’s take: Ripple’s practical value will depend on reproducible results, real deployment constraints and the cost per completed task. The available benchmarks and API prices do not yet answer those questions.