Science and engineering have long relied on a simple, human rhythm: try something, see if it works, learn from the mistake, and try again. For decades, this cycle has been the engine of discovery, where a researcher builds a prototype, tests it, and uses the results to refine the next version. But as computers have become powerful enough to write their own code and run their own experiments, a new question has emerged. Can a machine learn from its own failures in the same way a human does? The challenge is not just that the machine gets a result, but that it understands why it got that result. When a computer tries a thousand variations of a design, it often produces a mountain of data that tells it what happened, but not which specific change made the difference. Without that clarity, the machine is forced to relearn the same lessons over and over, wasting time and energy on paths that lead nowhere.

This is the problem a team of researchers at Sapient Intelligence set out to solve. They built a system called PRAXIST, designed not just to find solutions, but to build a clear, auditable history of how those solutions were discovered. Instead of treating every attempt as a fresh start, PRAXIST treats research as a continuous conversation. It takes the results of one experiment, breaks them down into specific lessons—what worked, what failed, and what was just a lucky guess—and saves those lessons as a permanent record. When the system starts its next round of experiments, it doesn't just look at the best score from the past; it looks at the specific mechanisms that earned that score. It asks, "Did this part of the design actually cause the improvement, or was it something else?" By answering that question, the system can carry forward only the useful parts of its history, building stronger and more reliable solutions with far less effort than before.

The researchers tested this approach on a massive set of seventy-five different machine-learning engineering challenges, ranging from identifying diseases in medical images to predicting stock market trends. They compared their system against a powerful, standard AI coding assistant running on one of the most advanced language models available. The results were striking. The standard assistant managed to earn a medal on about seventy-three percent of the tasks, but it spent nearly thirty-eight thousand dollars in computing costs to do so. The PRAXIST system, using a different underlying model and a much smarter way of organizing its work, earned medals on eighty percent of the tasks, all while spending only about three thousand dollars. In other words, the new system found better solutions for roughly one-twelfth of the cost.

But the true innovation lies not just in the savings, but in the method. The researchers observed that most automated systems treat their history like a simple list of scores, keeping only the highest number and discarding the rest. PRAXIST, however, treats history like a family tree. Every time the system builds a new piece of software or a new control mechanism, it records the specific design choices that led to success or failure. If a particular change in a rocket landing algorithm caused the vehicle to crash, that failure is recorded not as a dead end, but as a valuable lesson that tells future attempts what to avoid. If a specific tweak to a trading strategy improved profits, that success is tagged with the exact reason it worked, so the system knows to use that same tweak in a different context. This process allows the system to inherit "typed evidence," meaning it knows exactly which parts of a solution are proven to work and which are still just guesses.

To see how this works in the real world, the team applied PRAXIST to four complex, open-ended engineering problems that had no single right answer. In one case, they asked the system to design a controller for a reusable rocket to land vertically. The starting point was a controller that succeeded only four percent of the time. A standard automated optimizer tried hundreds of variations and managed to improve the success rate to seventeen percent, but it could not get the rocket to land safely every time. PRAXIST, however, took a different path. It didn't just try random changes; it built a lineage of improvements. It first added a governor to manage fuel, then a guide to handle the transition between flight phases, and finally a specific mathematical tool to balance the forces on the rocket's fins. By the end of the campaign, the system had produced a controller that landed the rocket successfully in every single test run, a perfect score of one hundred percent. Crucially, the system recorded the entire journey, showing exactly how each small improvement led to the final success.

In another experiment, the system tackled the problem of autonomous trading. The goal was to create a strategy that could buy and sell stocks to maximize profit over time. The baseline strategy, which simply bought an equal amount of every available stock, achieved a yearly growth rate of twenty-three percent. PRAXIST discovered a more complex, adaptive strategy that learned from market patterns and adjusted its behavior based on execution costs. This new strategy achieved a growth rate of fifty-three percent, more than double the baseline. The system didn't just find a lucky combination; it traced the discovery back to specific changes, such as how the strategy handled risk and how it managed the timing of its trades. The researchers could look at the system's "lineage" and see the exact moment the strategy learned to avoid a common pitfall that had been hurting its performance.

The system also proved its worth in the field of robotics and physics. In a test involving a robot that uses cameras and lasers to navigate, the standard system was wasting a huge amount of computing power by constantly updating its map with redundant information. PRAXIST realized that the robot didn't need to look at every single frame of video; it only needed to look when the new information was actually useful. By teaching the robot to skip unnecessary updates, the system cut the visual processing time by seventy-two percent without losing any accuracy in its navigation. Similarly, in a simulation of controlling a nuclear fusion reactor, the system designed a controller that kept the unstable plasma stable for longer periods than the existing human-designed controllers, even though the physics involved are notoriously difficult to predict.

What makes these results so significant is the transparency they provide. In traditional automated research, when a system finds a solution, it is often a "black box." You know it works, but you don't know why, and you can't easily tell if the success will hold up in a slightly different situation. PRAXIST changes this by attaching a detailed story to every result. It records the "lineage" of the solution, a chain of evidence showing which mechanisms were tested, which were validated, and which were discarded. This means that human scientists can look at the system's work, understand the logic behind it, and even take the best parts to build something new. It turns the computer from a tool that just produces answers into a collaborator that documents its reasoning.

The researchers emphasize that this approach is not about replacing human scientists, but about giving them a more powerful instrument. By handling the tedious work of testing thousands of variations and organizing the lessons learned, the system frees humans to focus on the big picture. The ability to inherit knowledge across generations of experiments means that the system doesn't have to start from scratch every time it faces a new problem. It can carry forward the wisdom of its past failures and successes, building a foundation of reliable knowledge that grows stronger with every attempt. This shift from a simple search for the best score to a deep understanding of the evidence behind the score represents a fundamental change in how we approach complex engineering challenges.

In the end, the story of PRAXIST is about the power of memory in machines. For a long time, computers were excellent at calculation but poor at learning from their own history in a structured way. This system shows that when you give a machine the ability to record not just what happened, but why it happened, it can solve problems that were previously out of reach. It does so not by being smarter in a general sense, but by being more careful about what it remembers and how it uses that memory. The result is a system that is not only more efficient and cost-effective but also more trustworthy, because every solution it offers comes with a clear, inspectable account of how it was reached. This is the future of autonomous research: not a machine that guesses its way to a solution, but one that builds a legacy of evidence, one experiment at a time.