NVIDIA open-sources the SoL-Pi system, enabling AI to act as a workflow supervisor to optimize agent efficiency. Through rigorous automated filtering, the system ultimately retains four core mechanisms from 152 optimization ideas: action fusion, online context compression, observation packets, and evidence-preserving simplifiers. Experimental results show that SoL-Pi reduces token consumption by 45%–49% compared to the open-source base Pi, and by up to 64% compared to official agent frameworks, lowering API costs by 50%–54% and saving $8.75 to $13.50 per hour. NVIDIA introduces the concept that “efficiency itself is a form of RSI,” arguing that optimizing AI workflow efficiency frees up additional resources for capability generalization.

Author and source: Leiphone

AI is still the best tool for getting AI to work.

NVIDIA open-sourced a productivity-enhancing harness called SoL-Pi this morning, enabling AI to act as a supervisor that meticulously reviews Agent workflows, identifies and fixes any potential inefficiencies or token-wasting steps, and continuously self-optimizes.

After efficiency improvements, token consumption decreased by up to 64%, API call costs dropped by 50%–54%, and businesses save between $8.75 and $13.50 per hour in actual development.

It achieved such excellent results because NVIDIA generated 152 optimization workflow ideas using AI, which were then rigorously filtered through an automated pipeline, leaving only four mechanisms that survived. These four mechanisms became the core of SoL-Pi.

Because it is based on the open-source project Pi, the name includes this keyword.

Everyone is now looking for ways to reduce costs and improve efficiency, and NVIDIA’s latest innovation has genuinely saved businesses a significant amount of money.

How does 01 AI detect AI slacking off?

How does AI detect AI slacking? This issue must be addressed on two levels: immediate waste and long-term challenges.

In real-world business applications, AI has long evolved to involve thousands of agents working together, operating continuously for days or even nights without human intervention. However, this also means that over such extended periods, contextual history accumulates and becomes increasingly bloated, while the number of tools being invoked continues to grow.

Each time the model is invoked, it must reread all this historical context, inevitably leading to significant redundancy. Moreover, AI lacks the adaptability of humans; sometimes, operations that could be completed continuously are rigidly split into two separate decisions. These scattered inefficiencies accumulate, burning real money.

The industry is currently discussing RSI—AI optimizing itself—but each attempt consumes tokens, and over 90% of these attempts ultimately fail. The cost of such blind trial-and-error is too high; companies may run out of funding before AI successfully evolves.

NVIDIA’s approach is to improve efficiency while also cutting costs. Instead of letting AI blindly modify code online, they first had AI generate 152 potential optimization workflows, then filtered them through a strict automated sandbox. This automated filtering process is called the “automated research loop.”

NVIDIA has also explored three ways for AI to manage AI.

One was a planned economy model, where you were the boss and I simply followed orders. Every step was rigidly defined by humans or a master model, but it was quickly abandoned due to its inflexible rules.

Second is the centralized management model, in which a super-admin AI writes code on the fly, holds meetings, assigns tasks to subordinate agents, and adjusts processes in real time. This model is highly flexible but overburdens the administrator, causing the core codebase of the main model to become excessively large and bloated.

The third is the shared flash mode, in which the entire system maintains only one minimalistic "work template" and instructions. Each time an AI experiment is launched, a copy of this template is directly duplicated, allowing users to freely modify the code and run experiments within it. Once the experiment ends, the temporary command code created during the process is discarded.

The third approach was adopted, completing 152 experiments. In the end, only the four most effective mechanisms survived, forming the core framework of SoL-Pi.

Previously, after the AI modified a line of code, it had to pause and think, "Should I run a test to verify this next?" Only after making that decision would it issue a command to invoke the terminal to run the test—adding an extra step of AI reasoning.

After system recognition, combine the fixed sequence of "modify code + run tests" into a single step, eliminating the unnecessary decision overhead.

The transformer mechanism means that AI's memory is linearly cumulative; after completing each task, it must review all previous accumulated context, causing costs to continually increase.

After optimization, the system breaks down large tasks into individual smaller tasks. After completing each small task, it compresses and organizes the history into a summarized version, retaining only the key conclusions. By default, only the summary is displayed; the original records can be retrieved when detailed verification is needed.

The output from each tool is also fully included in the context, such as hundreds of lines of logs generated during testing. Every subsequent discussion about this result must carry this large block of content, consuming significant space.

After optimization, the system will store the full output locally, retaining only a brief "summary + index" in the context; if the AI needs specific details, it can retrieve the corresponding section on demand.

When analyzing error logs and troubleshooting issues, having the main model read through them from start to finish is like using a sledgehammer to crack a nut.

After optimization, the system will use a smaller, lower-cost model to summarize logs into a "diagnostic report," where each conclusion in the report can be traced back to its specific location in the original text. The main model only reviews this summarized report and refers to the original text only if clarification is needed.

02: More cost-effective than Pi, pushing the cost-performance ratio of large models to the limit

To evaluate the effectiveness of these four mechanisms, NVIDIA created 535 verifiable environments.

Among these, 495 tasks involved the NVIDIA team searching GitHub for real open-source project bugs. They "one-click restored" the code repositories to their historical states before the bugs were originally fixed by developers, and set up all dependencies in an offline environment. Meanwhile, they concealed the "correct answers"—how human developers originally fixed these bugs—from the AI.

The other 40 tasks are "mystery box challenges": NVIDIA first writes a "validator" in code, then releases the AI into an open-ended sandbox with no script—requiring the AI to freely explore and trigger the通关 condition on its own.

Then, let the four harnesses compete head-to-head: GPT-5 Sol driven by the native framework, Claude Opus 5, the open-source agent backbone Pi, and NVIDIA’s own SoL-Pi.

As a result, SoL-Pi demonstrated remarkable cost-efficiency while maintaining its core base.

Compared to Pi, SoL-Pi reduces token consumption by 45%–49%, directly cutting development costs by approximately one-third.

Compared to the official agent framework natively provided by the model, SoL-Pi has reduced token consumption by up to 64% and lowered API costs by as much as 54%.

After this experiment, NVIDIA reached its own conclusion: efficiency itself is also an RSI.

Instead of solely pursuing smarter AI, focus first on making AI work more efficiently. The budget saved can then be reinvested into running more experiments and exploring more ideas, ultimately accelerating the generalization and advancement of AI capabilities. The paper refers to this as “Efficiency for efficiency”—efficiency is both an outcome and a resource for the next round of research.

True efficiency doesn't come from practicing problems; these four mechanisms fundamentally address common ailments inherent in AI workflows—issues that persist regardless of the model or task you switch to.

These four ideas emerged only through broad exploration and multiple attempts; focusing too narrowly on a single direction can easily lead to a dead end. At this stage, “breadth is more important than depth.”

In the future, more and more cases of “AI improving AI tools” will emerge. Even if you don’t use the SoL-Pi tool, you can directly apply these four optimization principles to your own AI workflow.