Ripple 65B and Grok 4.7 show opposing strengths in coding benchmarks

Conflicting benchmark results

The release of Ripple 65B Preview and Grok 4.7 has highlighted a significant divergence in how AI models perform on software engineering tasks. As OrcaRouter reported, these two models show superior results in different categories, suggesting that no single benchmark captures the full scope of an agent's capabilities.

Grok 4.7, a closed model from xAI, achieves a score of 71.0 on the DeepSWE v1.1 benchmark. In contrast, Ripple 65B Preview, an open-weight model from Recursive Intelligence, scores 44.3 on that same test. This indicates that Grok is more effective at long-horizon software engineering on real repositories.

However, the trend reverses when looking at Terminal-Bench. Ripple 65B Preview scores 80.52 on version 2.1 of the benchmark, while Grok 4.7 scores 38.0 on version 4.0. Because version 4.0 includes adversarial anti-cheat controls and longer timeouts, the scores are not directly comparable, but the gap suggests Ripple is stronger at command-line tasks.

How the benchmarks differ

Understanding these results requires looking at what each benchmark actually measures. Terminal-Bench focuses on command-line activities where an agent is given a container, a goal, and a time limit. The score is based on the correctness of the final filesystem state and the services provided.

DeepSWE takes a different approach by focusing on long-horizon software engineering. In this scenario, the agent must maintain a consistent plan across many different modifications to a large codebase. This type of work rewards perseverance and context management rather than just the ability to execute a single shell command correctly.

The discrepancy exists because the two labs appear to have optimized their models for different types of work. A model can be excellent at navigating a complex file structure over hundreds of turns while being mediocre at specific system-level repairs, or vice versa. This means a buyer must know which specific type of labor their production workload requires.

Grok 4.7's reasoning and costs

Grok 4.7 is a reasoning model that features four levels of effort: low, medium, high, and xhigh. The high setting is the default, and reasoning cannot be fully disabled. This architecture has specific implications for users because every call pays for thought tokens regardless of whether the task requires deep reasoning.

The pricing for Grok 4.7 includes a notable detail regarding the 200,000 token threshold. If a request exceeds 200K tokens, the entire request is refactored to a higher rate rather than just the excess. With a 500,000 token context window and mandatory reasoning, users might accidentally trigger these higher costs during complex tasks.

While Grok offers a low output price of $6.00 per million tokens, this may be deceptive. Because reasoning is mandatory, a significant portion of the billed tokens is for internal thought processes. Analysis shows that Grok 4.7 can cost six times more than some other models when calculating the actual cost per activity.

Ripple's open-weight economy

Ripple 65B Preview follows a completely different economic and architectural path. As an open-weight model under the Apache 2.0 license, it does not have a standard list price. Instead, the cost is determined by the hardware used to host the model, making it a different experiment for developers.

Ripple is designed with a dense architecture of 80 layers and a 1 million token context window. It was trained through long-context phases of up to 2 million tokens. This design is intended to maintain a large working set without the potential issues of expert-routing found in other large models.

The hosted rates for Ripple are near $0.20 for input and $0.60 for output, which represents the amortized cost of the hardware. This makes Ripple highly efficient for high-throughput tasks if the GPUs remain occupied. However, it may be less cost-effective if the workload is inconsistent or requires frequent idle time.

Choosing the right tool

The best way to choose between these models is to evaluate the shape of the work and the shape of the bill. If your agents live in containers and perform system-level tasks like infrastructure repair or migrations, Ripple 65B Preview is the stronger candidate based on its Terminal-Bench performance.

For tasks involving modifying a large repository over a long horizon, Grok 4.7 is the better signal. Its high DeepSWE score and improved marathon benchmarks suggest it is built for the marathon of software development rather than the sprint of system commands.

Ultimately, the perfect number to settle the debate does not yet exist. Ripple has not been tested on the marathon benchmarks, and Grok has not been officially ranked by independent analysis for Ripple. Until then, users should match the model's specific strengths to their unique production requirements.

Technical specifications

Grok 4.7 was released on September 21, 2026, and supports both text and images. It provides an output speed of 72 tokens per second. It is a closed model available only through an API, which allows for features like automatic failover and easy routing between different models.

Ripple 65B Preview was launched on November 4, 2026, and offers a much higher declared output speed of 250 tokens per second on two B200 GPUs. It features a 1 million token context window, which is larger than Grok's 500,000 token window. This makes it suitable for very large data inputs.

The two models represent different philosophies in the current AI landscape. Grok focuses on high-reasoning capabilities and managed API services, while Ripple focuses on high-throughput, open-weight accessibility. Both offer distinct advantages depending on whether a developer prioritizes reasoning depth or system-level execution.

Next steps for developers

Developers should first identify the primary environment where their AI agents will operate. If the agents are primarily interacting with shells and containers, they should prioritize testing Ripple 65B Preview. They can check its performance on Terminal-Bench 2.1 to see how it handles specific system tasks.

For teams building agents that need to plan and execute complex changes across hundreds of turns in a codebase, Grok 4.7 is the logical starting point. Users should monitor their token usage closely, especially near the 200,000 token mark, to avoid unexpected price jumps from the reasoning tokens.

Finally, users can utilize tools like OrcaRouter to manage these models. This allows for a triage system where simple tasks are sent to cheaper models while complex, high-effort tasks are escalated to Grok 4.7. This hybrid approach can help manage the costs associated with Grok's mandatory reasoning.