NVIDIA Unveils SoL-Pi: Self-Driving Research Cycles That Reduce Coding Agent Token Usage by as Much as 49%

If you run AI coding agents on long tasks, you already know the pain: sessions that once lasted minutes now stretch across hours, and every file edit, test run, and log inspection feeds more text into the model's context window. That translates directly into higher API bills. A research group from NVIDIA, NTU, and MIT has released SoL-Pi, a set of four efficiency mechanisms for the open-source Pi coding agent. Remarkably, these mechanisms were discovered by an AI running automated research loops at the harness layer. On the 51-task EdgeBench evaluation, SoL-Pi reduces recorded token traffic by 44.7% to 49.0% compared to Pi, and cuts API costs by roughly a third — while scoring close to Pi on both GPT-5.6 Sol and Opus 5.

And yes, it's deployable today. SoL-Pi is available on GitHub under the NVlabs organization as an MIT-licensed extension that runs on an unmodified Pi release. It has been tested with Pi 0.85.1 and Node.js 22.19 or newer.

Why the Harness Is the Right Target

Most efficiency research attacks the problem from the model side: faster compute kernels, quantization, or swapping in cheaper models to lower the cost per token. SoL-Pi takes a different angle. Instead of making each token cheaper, it reduces how many tokens a task consumes in the first place. The target is the harness — the software layer responsible for managing tool calls, context, observations, and task delegation.

Tuning this layer by hand is painful. Its components are tightly coupled, so a change that saves money in one place often pushes costs into later steps. Systems like Meta-Harness already automate some of this tuning, but a recent study found that harnesses evolved this way can overfit to their search tasks, delivering only marginal benefits on new ones. SoL-Pi's authors designed their pipeline specifically to avoid that trap.

How the Automated Search Works

The search process works like this: a research AI watches execution traces from a separate agent running base Pi, then proposes changes to the harness and tests them. The scale of the search is substantial:

• 152 proposed directions spanning 6 families: context, progress, tools, delegation, prompt and policy, and improvement and evaluation
• 535 executable environments: 495 built from GitHub issue–pull request pairs, plus 40 synthetic tasks with executable verifiers
• More than 3,000 runs and over 60,000 agent-environment interactions

Each search runs as an isolated, disposable loop, following the autoresearch cycle but extended with a Ralph Loop implementation step and an independent reviewer.

Crucially, the acceptance rules are locked in before the search begins, and the optimizer cannot modify them. Every capability metric must stay within a predeclared tolerance, and any candidate must improve at least one efficiency metric. EdgeBench remains held out throughout: of its 51 public tasks, 11 are used for one-way acceptance checks of frozen candidates, and 40 are reserved for final evaluation. Results from these held-out tasks never feed back into the search.

The Four Mechanisms That Made the Cut

Action Fusion. Base Pi typically edits a file, then issues a separate command to build, test, or run it. Action Fusion merges both into a single tool request and returns both outcomes in one observation, eliminating a full model round trip.

Online Context Compact. The harness tracks plan steps through `update_plan`. When a step completes, it estimates how many requests remain, then compares projected input savings against the extra cost of rewriting the prompt cache. Pi's native compaction kicks in when this gate passes or when the context approaches the window limit.

ObservationPack. Tool outputs exceeding 10 KiB are archived locally and delivered in full for the next 2 provider requests. From the 3rd request onward, the model sees a stable handle, the original size, and a short excerpt of head and tail lines. Exact pages remain retrievable through the handle.

Evidence-Preserving Reducer. Build and test logs of at least 4 KiB are sent to a cheaper model, GPT-5.6 Luna at high, which produces a compact receipt. A deterministic verifier checks the receipt's schema, source hash, exit status, exact quotes, and size. The harness falls back to the original log in three cases: verification fails, credentials are suspected, or the receipt isn't actually smaller.

Results on EdgeBench

| Backend | Harness | Tokens (B) | API Cost | Avg. Score |
|---|---|---|---|---|
| GPT-5.6 Sol | Codex | 3.05 | $1,787 | 34.7 |
| GPT-5.6 Sol | Pi | 2.15 | $1,339 | 44.8 |
| GPT-5.6 Sol | SoL-Pi [Efficiency] | 1.10 | $894 | 42.0 |
| GPT-5.6 Sol | SoL-Pi [Performance] | 2.02 | $1,271 | 47.2 |
| Opus 5 | Claude Code | 2.00 | $2,535 | 43.7 |
| Opus 5 | Pi | 2.37 | $1,741 | 44.8 |
| Opus 5 | SoL-Pi [Efficiency] | 1.31 | $1,158 | 42.2 |
| Opus 5 | SoL-Pi [Performance] | 2.10 | $1,605 | 50.5 |

The full stack was built on GPT-5.6 Sol and then moved to Opus 5 without any additional search. On Opus 5, it retains 94.3% of Pi's score while cutting token traffic by 44.7% and API cost by 33.5%. On GPT-5.6 Sol, it keeps 93.7% of Pi's score with 49.0% fewer tokens and 33.2% lower cost.

The Performance configuration uses the single best mechanism per backend: ObservationPack on GPT-5.6 Sol, and Action Fusion on Opus 5. This variant lifts scores 5.3% and 12.8% above Pi, respectively.

One interesting wrinkle: on GPT-5.6 Sol, the full stack actually increases cache-write traffic from 0.0141 B to 0.0316 B tokens, yet total cost still drops from $1,339 to $894. The paper estimates hourly savings of $8.75 to $13.50 compared to the native Codex and Claude Code harnesses, and $4.36 to $5.71 versus Pi.

Beyond EdgeBench

Terminal-Bench 4 (63 CPU-only tasks): SoL-Pi solves 15 tasks versus 18 for both Codex and Pi, while lowering total cost by 26.3% versus Pi ($211.12 vs $286.45).

IMO 2026, Lean 4-verified: SoL-Pi passes 3 of 6 problems, matching Pi, at the lowest cost per passed problem ($20.90). Codex passes 5.

Agent swarm: A Codex coordinator with 20 SoL-Pi workers reaches 1,127 cycles at $60.11, while the same setup with 20 Pi workers reaches 1,366 cycles at $82.12. A single Codex agent remains the cheapest option at $39.20, reaching 1,333 cycles.

The team openly labels the cross-model transfer as preliminary. The mechanisms trigger less frequently on Opus 5, possibly because the search relied solely on GPT-5.6 Sol trajectories.

Key Takeaways

• SoL-Pi cuts EdgeBench token traffic by 44.7% to 49.0% versus Pi.
• API cost drops by roughly 33% while preserving about 94% of Pi's average score.
• Four mechanisms survived a search across 152 directions and 535 environments.
• SoL-Pi is an MIT-licensed, opt-in Pi extension available on GitHub.

For teams running long-horizon coding agents and watching their API spend climb, SoL-Pi offers a pragmatic middle ground: near-parity on task quality at roughly two-thirds of the cost.