Ripple-65B Preview Ran 100 Coding Agents at Once for About Seven Cents

Ripple-65B Preview went live this morning. Ricursive Intelligence trained it from scratch, released the weights under Apache 2.0, and GMI Cloud serves it from launch at $0.20 per million input tokens and $0.60 per million output tokens. The launch package has the benchmark table. We wanted to see what the model does with real work.

So in the days before launch my team ran it through 25 scout tests in five domains, built two demos, and stress-tested both. The whole week came to about 7,400 model calls and a bill of $2.90. This post has what we found, the traps the model stepped around, the settings that worked, and a curl command to start from. All measurements are our own, taken from a laptop over the public internet, and the launch package is the official record.

The model

Ripple-65B Preview is a dense 65-billion-parameter model. Ricursive chose a dense design over mixture-of-experts so the model would be simple to train and serve on NVIDIA hardware, and dense models produce each token with low latency. That choice shows up in the speed numbers later in this post.

The benchmark figures are Ricursive's own. Weights and reference serving code are on Hugging Face.

How we tested

Five research agents, one per domain, each wrote and ran its own tests. The domains were DevOps, enterprise knowledge work, science and math, infrastructure, and business agents. Every scenario had a known right answer plus decoys and traps, so a script graded each run from what the model did with its tools, and the model's own summary of its work carried zero weight. The math and science questions were written fresh for this test, after the model's cutoff, and checked by hand. Where a result below comes from a single run, we say so.

The coding swarm

The first demo is a board of coding agents. Each agent gets its own small repository with one real bug, a failing test, and a shell, and all of them start at once against the same endpoint. A tile turns green only when our own test passes on the agent's patch.

With 20 agents, 279 of 280 bugs were fixed across 14 runs, and a clean run finished in a median of 8.4 seconds. With 60 agents it fixed 180 of 180. With 100 agents, in a single run, all 100 fixes landed in 22.3 seconds, for a total cost of about seven cents.

Two things explain why a 65B model handles this well. Code comes out about twice as fast as prose on this endpoint, and agent loops are mostly code and JSON. And the model plans in batches: it reads everything it needs in one parallel tool turn, then acts, which keeps each agent's loop short.

Figure 1. Output speed per stream and in total, measured on the GMI Cloud endpoint during launch week.

Demo 2: the 3 a.m. page

The second demo is the one that made me trust the model. One incident agent works a simulated outage with 11 tools: metrics, logs, deploy history, change control, paging, and a status page. A human clicks Approve or Deny before any production change goes through. All companies and systems in the demo are made up.

We planted traps, because a model that fixes the obvious thing fast is only useful if it also leaves the wrong thing alone. We ran the scenario 324 times during development.

A full incident, from investigation through approval, fix, verification, status update, and postmortem, took a median of 8 model calls and about 28 seconds, and cost about half a cent. The status line had to name the cause in a strict service@version form, and the model got it exact in 320 of 324 runs.

It also recovers from its own slips. In one run it guessed a wrong metric name, read the error, and used the right one next. When change control rejected an approval over unclear wording, it went back to the human with the exact change spelled out. The final version of the demo passed 40 of 40 runs.

Tool calling that holds up

Ripple uses the standard OpenAI tools format, so existing agent code runs unchanged against the GMI Cloud chat completions API. Across 141 business-agent calls we saw zero malformed calls, zero unknown tools, and zero invalid JSON arguments. The incident demo alone made 3,401 tool calls across 11 tools.

What stood out was how wide it goes in one turn. Handed 60 emails in one prompt, it returned 60 parallel tool calls in a single reply, routed all 60 correctly, and finished in 13.8 seconds for about $0.003. A data-room agent read six documents in one parallel turn and used a calculator tool to land on the exact total.

It follows format rules too. Asked for strict JSON from a contract playbook, it returned exactly the required keys, got 6 of 6 statuses right, and kept every quote verbatim and under 25 words. It left out the one contract whose clause was notice-only rather than consent-based, which was the trap. Given a deprecated policy next to the current one, it used the current one every time. Across six mock MCP servers with 34 tools, it left the decoy account alone and skipped the disabled tool in every run.

Problems written after the cutoff

Benchmark scores show how a model does on questions it may have seen before. We wanted questions it was meeting for the first time, so we wrote them during the test week.

It solved all three new competition-style math problems with short, readable solutions, and answered all five graduate physics and chemistry questions correctly. Given a 10-K excerpt and an earnings-call transcript with five planted contradictions, it found all five with zero false positives, and also noticed that a notice was dated before the call it referred to. In a set of draft financial statements it found all three breaks, including the hidden plug that made the balance sheet balance. On a three-hop question over 20 made-up research papers it cited the right chain and flagged the contradiction. On lab decay data with decoy isotopes, it named the right two and fit their half-lives within 0.4% of our own answer.

Twice it found something we had left unplanted. In a security review of a pull request it found a third real bug we had missed. And it flagged an error in our own test generator, where one contract listed two different values for itself.

On coding, it drove git bisect by itself across 12 commits to find a rounding regression, wrote a one-line fix, and passed the check in 46 seconds. It ported a Python 2 module to Python 3 against 7 locked tests and passed all 7. Asked to turn a spec into an MCP server, it produced a working server on the first try in all three runs.

Speed and cost on the GMI endpoint

These numbers came from a laptop talking to the public endpoint during launch week, so yours will vary with load and distance. Reasoning is adaptive: easy prompts get an answer at once, hard prompts get a visible chain of thought in a separate reasoning_content field, and the first token of it usually lands in under a second.

Figure 2. What each workload cost at launch pricing.

The cache is the quiet win for agents. An agent that resends the same system prompt and tool list on every turn pays the full price once, then gets the fast first token for the rest of the task. It is the same effect we leaned on when we sent a whole repository to GPT-6 Luna three times for under 30 cents.

What worked best

These are the settings and patterns that gave us the cleanest runs. Most of them are one line in a prompt or one decision in a tool schema.

Give it room to think. Reasoning tokens count toward max_tokens, so a tight limit on a hard task cuts the model off mid-thought. We used 8K or more per turn for anything hard.

Ask it to act early. The line "Keep your thinking short and call tools early" kept the long coding tasks short and focused. Pair it with "Call several read-only tools at once when you can" and you get the short, wide loops from the swarm demo.

Give analysis agents a step budget. "At most 8 tool calls, then write the summary" stopped the research agents from wandering.

Use enums and strict formats in tool schemas, validate inside the tool, and return a clear error. The model reads the error and fixes its call on the next turn. Hand deterministic work to tools too. Once the returns agent had a check_return_eligibility tool for the date math, it passed 8 of 8 checks in 5 of 5 runs.

Put safety in the tools, and keep it in the prompt as well. Our change-control gate allows a production change only with a matching human approval on file. The model worked with that gate in every run, but the gate is what makes the guarantee.

Make tool results say what happened. "The team acknowledged; the fix is still pending" gives you an accurate status report. A bare 200 OK gives you an optimistic one.

Stream everything and show the reasoning. The thinking arrives in its own reasoning_content field, so showing users what the agent is doing takes a few lines of code.

Reuse the prompt prefix. Agent loops that resend the same context get cache hits, and the warm first-token number above is the payoff.

Try it on GMI Cloud

The endpoint is OpenAI-compatible. Create a key in the console (the quick start walks through it), swap it into the call below, and you get a plain chat completion back. Add a tools array in the usual format to start an agent.

curl --request POST \
  --url https://api.gmi-serving.com/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_GMI_API_KEY' \
  --data '{
    "model": "gmicloud/Ripple-65B-Preview",
    "messages": [
      {"role": "system", "content": "You are a knowledgeable AI assistant."},
      {"role": "user", "content": "Explain the concept of quantum entanglement in simple terms."}
    ],
    "temperature": 1.0,
    "top_p": 1.0,
    "max_tokens": 800
  }'

For a hard task, raise max_tokens to 8000 or more and set "stream": true so the reasoning shows up as it is produced.

The question to answer

Which agent in your stack is still running one tool call per turn because the model behind it got confused when you asked for more? Point it at Ripple-65B Preview, add the line about calling read-only tools at once, and watch the loop count. If a job that took 30 turns now takes 8, and the bill for the run is under a cent, you have found your next default model for agent work.

Ripple-65B Preview is an open-weight model from Ricursive Intelligence, released under Apache 2.0. Launch benchmark figures are from Ricursive's model card. All other measurements in this post are GMI Cloud's own, taken on simulated systems with made-up companies and data.