Nvidia has open-sourced SoL-Pi, a harness project built on top of Pi with an added efficiency layer aimed at lowering the cost of AI agents. The source article frames the effort around a simple priority: before making AI systems smarter, make them cheaper to run.
According to the project description cited in the article, SoL-Pi places AI inside a strict automated pipeline where it studies how agents work, identifies steps that burn tokens without adding much value, proposes fixes, patches bugs, and sends those changes into testing. The search began with 152 candidate directions and ended with four core architectural mechanisms.
The reported results are sharp. Token consumption was reduced by as much as 64%, while API call costs fell 50% to 54%. The project materials cited by the source also say that in professional research settings, the savings can reach $8.75 to $13.5 per hour. Nvidia has published the code on GitHub, and installation is presented as a single command: pi install git:github.com/NVlabs/SoL-Pi.
Why the harness layer matters
In this setup, the model handles reasoning, while the harness organizes tools, context, execution feedback, and task flow. That is what lets a model read files, edit code, run tests, and continue acting based on the output. The article notes that the same model can perform very differently depending on which harness it runs inside.
The issue becomes more visible as coding agents take on longer jobs. Work has moved from editing a few lines of code to fixing issues across repositories and then to autonomous runs that can last for hours. Once a task stretches that long, token waste that seems minor at first starts to stack up.
The article gives several examples. A model edits a file, and the next step is clearly to run tests, yet the system still triggers another round of reasoning. A large file has already been read, but later requests keep carrying it again. A log may contain thousands of lines, while only a handful matter for the next decision, yet a costly frontier model still reads the whole thing from the top. The same overhead appears in recursive self-improvement, or RSI, because each attempt to improve the system costs tokens, including failed attempts.
SoL-Pi is designed to attack that class of inefficiency. Versus base Pi, it uses 45% to 49% fewer tokens, lowers cost by about one-third, and keeps roughly 94% of the average score. Compared with the default harnesses paired with Codex and Claude Code, token use drops 35% to 64% and listed cost drops 50% to 54%.
The four mechanisms that survived the filter
Nvidia’s pipeline ended up keeping four mechanisms. Each one targets repeated work and repeated billing from a different angle.
Action Fusion: editing and validation in one local sequence
The first mechanism, Action Fusion, removes an extra model decision step that often sits between two tool calls.
In a base Pi trace, a common pattern is straightforward: edit a file, receive the result, then call a command to test or build. If the next command is already obvious, that extra round-trip through the model can be compressed. SoL-Pi wraps the edit and the follow-up command into one local execution sequence. The harness performs the file change and runs the command underneath, then returns the combined result in one shot. The test still runs and the output still arrives, but the intermediate model request disappears.
Online Context Compact: compress only when the math works
The second mechanism is Online Context Compact, which focuses on the timing of compression.
The article says long context windows turn past material into a growing compute and cost burden. Compression is not free, though. Rewriting context can interrupt reuse of the KV-cache and force the system to pay processing costs again. That is why earlier strategies often delayed compression as much as possible.
SoL-Pi changes the decision rule. It breaks a large task into subtasks and reevaluates after each one. Compression is triggered only when the expected future savings are large enough to cover the cost of rewriting the context now. In other words, the system does not compress by default or on a fixed schedule. It does so only when the cost model says the trade is worth taking.
ObservationPack: archive long outputs and recall them by index
The third mechanism, ObservationPack, addresses repeated billing caused by long tool outputs.
If a large file or an extended output remains in the active context after it has been read once, every later request keeps carrying it again. SoL-Pi moves the full content into local disk storage and leaves only a short stable handle plus a small excerpt in context. When the model needs detail later, it can fetch the archived content back by page through the index. The article compares the design to archiving a long report and keeping only the index and key summary at hand.
Evidence-Preserving Reducer: let a smaller model triage logs, then verify every claim
The fourth mechanism is the Evidence-Preserving Reducer, aimed at the first pass over long logs.
Build and test logs can run to tens of thousands of words, while only a few error lines may matter for the next action. Having a frontier model read every line each time is expensive. Handing the whole summarization task to a smaller model creates hallucination risk. SoL-Pi inserts a verification layer between those two options. A helper model reads the log and produces a compact diagnostic receipt. The system then checks each item in that receipt against the archived original log. Only statements that match the source text are passed on to the frontier model.
In the article’s telling, that keeps the main model working from verified information rather than from an unchecked summary.
From chasing scores to chasing efficiency
The article explains why these four mechanisms survived and ties them to Nvidia’s broader interest in RSI, short for recursive self-improvement.
The logic is direct: if AI can modify code, it should also be able to modify the system used to produce AI work. The problem is cost. Every trial in RSI consumes tokens. Nvidia therefore shifted the target. Instead of first trying to raise benchmark scores, it first tried to raise token efficiency.
The source argues that efficiency is harder to game than task scores. A system can overfit to specific tasks and lift scores by adding narrow rules. Reducing duplicated context, compressing tool output, and removing unnecessary decisions are changes that transfer more cleanly across tasks and models.
To test that idea, the team built what the article describes as an “agent researches agent” pipeline. It first created 535 verifiable environments, then had AI propose 152 optimization directions, and filtered them through three rounds:
- First, estimate expected gains from historical traces and remove ideas with little promise.
- Second, let AI modify code and run experiments, with a Reviewer Agent examining the results.
- Third, freeze the proposal and test it on fully isolated held-out tasks, where capability could not drop and efficiency had to improve.
Out of 152 ideas, only four remained. The article describes that as roughly one survivor for every 40 candidates. Its broader conclusion is that SoL-Pi works by having AI generate many hypotheses, then automatically experiment, reject, and validate until a small number of mechanisms prove durable.
The longer-term loop Nvidia is pointing toward
The source says SoL-Pi comes from Nvidia’s Efficient AI team led by Han Song, identified there as an MIT associate professor and Nvidia research director. For the team, the amount of token savings achieved so far is a milestone, not the final point. The bigger question is how far this “AI researches AI” loop can be pushed.
The official project page, as cited in the article, points to two longer-range directions. One is “Pretraining the harness.” The current 535 environments are still built by humans. The stated future goal is for agents to collect tasks from across the web, build environments, verify outcomes, and keep updating their own harness. If compute and environment diversity rise enough, the article suggests that harnesses could develop a scaling law of their own.
The other direction is “Efficiency for efficiency.” The idea is to use a more efficient harness to run larger and cheaper automated research loops, then discover even better mechanisms and produce a compounding effect on cost reduction.
In that loop, the article says, humans mainly provide prior direction at the start. Once the cycle is running, research and validation can proceed with zero intervention. After AI finds a workable mechanism, people return to analyze what was discovered and refactor the rough machine-written code into an industrial-grade version.
The article closes by noting that scaling laws for models are still debated, while work on a scaling law for harnesses may already be starting. In this account, the thing racing down that track is AI itself.
Project links cited in the source
GitHub: https://github.com/NVlabs/SoL-Pi
Project page: https://nvlabs.github.io/SoL-Pi/
X post: https://x.com/MaxForAI/status/2098050525279478059
The source article says the piece originally came from the WeChat public account Xinzhiyuan, written by ASI Qishilu and edited by Taozi and Moxi, and was republished by MarsBit.