Skip to content
AI Coding

Ripple-65B Preview Guide: Agentic Coding Setup

Ripple-65B Preview just dropped as U.S. open-weight SOTA on agentic coding. Here's the #1 mistake, exact API/local setup, and pitfalls that kill agent runs.

6 min readBeginner

The #1 mistake with Ripple-65B Preview right now

People see “U.S. open-weight SOTA on agentic coding” plus the 1M context claim, then drop the model into the same agent stack they use for Claude or GPT coding endpoints. The run starts strong. Then it dies – host clips context mid-repo, a multi-thousand-token <think> block burns the budget, or a tool call ships extra junk fields and the parser chokes.

I did exactly that the morning after the November 4, 2026 drop. Terminal-Bench looked real on paper. The agent still failed halfway through a repo walk. More prompt glue did not save it. Ripple-65B Preview is a specialist dense model with sharp host, template, and bandwidth edges. Wire those on purpose or the trajectory ends early.

Quick context: what just landed

November 4, 2026: Ricursive Intelligence shipped Ripple-65B Preview – open general-purpose cut of the chip-design lab’s internal silicon model. 65B dense Transformer, trained from scratch on 12T tokens, Apache 2.0 weights on Hugging Face the same day the APIs lit up (Together, GMI Cloud, OpenRouter, Fireworks).

80.5 on Terminal-Bench 2.1 is the headline they own as U.S. open-weight SOTA (Beam 501B at 80.1 in their table). SWE-bench Pro v2.0 Hard lands at 79.1. Full R&D: $32M and 1.4M RL rollouts, with light coding-focused post-training. Specs from the model card – 80 layers, d_model 5120, up to 1M context supported. Dense on purpose. It runs on NVIDIA gear without mystery layers.

Hands-on: get Ripple answering agent tasks today

Skip local until the behavior is boring. Start hosted.

API path (OpenRouter or Together)

As of early November 2026, pricing commonly sits near $0.20 / 1M input and $0.60 / 1M output (cache reads ~$0.05). Live context is not the marketing 1M on every host – check the provider page before you feed a monorepo.

from openai import OpenAI

client = OpenAI(
 base_url="https://openrouter.ai/api/v1", # or Together endpoint
 api_key="your-key",
)

resp = client.chat.completions.create(
 model="ricursiveai/ripple-65b-preview", # Together: ricursive-ai/Ripple-65B-Preview
 messages=[
 {"role": "system", "content": "You are a terminal coding agent. Use tools. Keep final answers short."},
 {"role": "user", "content": "List files, then fix the off-by-one in src/parser.py and run the tests."}
 ],
 tools=[{
 "type": "function",
 "function": {
 "name": "run_bash",
 "description": "Execute a bash command",
 "parameters": {
 "type": "object",
 "properties": {"cmd": {"type": "string"}},
 "required": ["cmd"]
 }
 }
 }],
 tool_choice="auto", # required-tool calls: pair with strict schemas
 temperature=0.2,
 max_tokens=4096
)
print(resp.choices[0].message)

Together’s model page lists the same price band and native tool calling. Turns out required tool calls without strict schemas invent extra argument fields – community notes and the ripple SGLang parser both want clean JSON inside <tool_call>.

Pro tip: inspect the raw message for <think> blocks before the next turn. Hard steps always pay the reasoning tax; strip or summarize traces so long trajectories stay under the real window.

Local path that actually works

BF16 is ~130 GB. Experimental NVFP4 (~57 GB – MLP NVFP4, attention BF16) plus the DFlash2 4B drafter is the single-box path Ricursive ships for a DGX Spark. Official spark.py serves through SGLang at 128K, one request at a time.

Want the full 1M window? Two B200-class GPUs on the BF16 checkpoint + drafter under SGLang 0.5.19. Ricursive quotes ~250 tok/s at batch 8 before extra quant. Four GPUs → two independent copies. Consumer cards and stock llama.cpp still need community patches. Launch posts mention a MacBook run; no official MLX path shipped with the preview.

  1. Clone the NVFP4 or BF16 repo from ricursiveAI on Hugging Face.
  2. Install the pinned SGLang + CUDA stack the README calls for.
  3. Launch with the provided script; point your agent at the OpenAI-compatible port.
  4. Start with short terminal tasks before you feed a 100k-token monorepo.

That first successful local bash loop – lists files, edits, runs pytest, stops clean – is when it clicks. After that you’re only lengthening the trajectory.

Common pitfalls that kill agent runs

  • Context surprise: Early hosted listings (OpenRouter especially) showed 16,384 context while the card says 1M. Agents burn that reading a tree. Trust the live provider limit.
  • Always-on thinking: Chat template emits reasoning in <think> with no on/off or effort switch. Hard bugs → 1.6k+ token traces. Budget for it or summarize mid-flight.
  • Tool schema strictness:tool_choice required without strict: true leaks stray argument fields. Clean JSON schemas; ripple-aware parser on SGLang.
  • Dense bandwidth tax: Every token touches all 65B parameters. Fine on proper NVIDIA iron; sluggish or dead on typical consumer GPUs without heavy quant + patches. Official local ceiling on Spark is 128K NVFP4; 1M wants multi-B200 BF16.

Same four failures showed up across the first day of community runs. Not theory.

What the numbers actually mean for your work

For multi-step bash + edit + test loops, the 80.5 Terminal-Bench number is the signal that matters. Light post-training focused on agentic coding explains the shape of the rest of the table: strong on the harder SWE-bench Pro slice (79.1), trails larger MoEs on SWE-bench Verified (76.5 vs Beam 81.6), SciCode 39.4, and several knowledge/math rows.

Daily work = controlled executable trajectories? Ripple belongs in the rotation. Broad science coding or general knowledge? Keep a stronger generalist beside it.

When NOT to reach for Ripple-65B Preview

Laptop GPU and you need sub-second replies? Skip. Agent locked under a hard 8-16K window forever? Skip. Multimodal input, pure knowledge/safety work, or zero appetite for custom serving stacks? Skip – local is still NVIDIA-first and preview-flavored.

Quick chat or cheap bulk generation? Smaller or MoE open models are still less friction. Ripple earns its slot when you want strong agentic coding under Apache 2.0 on hardware you control, or a cheap dense endpoint that finishes the loop.

FAQ

Is Ripple-65B Preview really free to run commercially?

Yes. Apache 2.0 weights – fine-tune, host, ship. Training data stays closed.

How do I keep long agent sessions from blowing the context?

Pick a host or self-host recipe that actually exposes the long window (GMI/Together listings and the 2×B200 path aim at 1M). One real case: a 40-file refactor only stayed under budget after tool results returned diffs instead of full files – plus compacted <think> summaries and a working-tree checkpoint so a truncated turn could restart clean.

Does the “SOTA” claim mean it beats every open coding model?

No. Ricursive’s claim is U.S. open-weight on the Terminal-Bench 2.1 number they published. The gap over the next U.S. model is small. Non-U.S. models and other harnesses sit outside that comparison. Light post-training also leaves weaker spots on SciCode and some verified SWE slices. Strong specialist. Not a universal champion.

Next action: run the OpenRouter (or Together) snippet against one real failing test in your repo. Watch the raw <think> and <tool_call> tags. Then choose hosted for the week – or schedule the DGX Spark / dual-B200 install.

Related Tutorials