The era of treating LLMs as standalone chatbots is over. We've moved from raw models to harnesses, and now we are entering the era of the loop.
The Simple Version
Imagine you are training a world-class chef. You don't just give them a recipe book (the model) and a kitchen (the tools); you stand next to them and taste every dish. When something is too salty, you don't rewrite the whole cookbook—you tell them, "Next time, use less salt," and they remember that for the next plate.
In the world of AI agents, this 'tasting and correcting' is the loop. According to Gavrilescu, the magic isn't in the model you use, but in the signals (how the agent knows it's on the right track) and the verifiers (how it confirms the work is actually correct). When you capture these corrections into a reusable format, you've created a 'recipe' that allows the agent to replicate your professional taste without you being in the room.
How It Actually Works
Gavrilescu breaks down the architecture of modern autoresearch into three core pillars.
1. The Loop is the Product
The success of an agent depends on the quality of its feedback loop. He cites a real-world example of a user using OpenClaw to haggle for a car. The loop involved four steps: finding prices on Reddit, checking inventory, pitting dealers against each other, and using a verifiable signal to know when the price was right.
The goal is to "loop the loop," where the artifacts generated by the first execution are fed back into the system to improve the next run.
2. System Distillation and Agent Recipes
If you build a great agent on a specific platform, you are locked into that provider. Gavrilescu proposes system distillation as the real competitive moat. This means capturing everything—evals, judges, human judgment, and prompts—into portable, versioned agent recipes.
As Gavrilescu puts it, "An agent recipe is really something that enables you to create reproducible frontier AI systems... agnostic to the models and providers you use." Introspection is releasing an early version of this called Pi recipes, built on the Pi harness and Harbor for evals, allowing these recipes to live in Git repos.
3. Valued Work per Watt
Once an agent reaches the 'frontier' (it can actually do the job), the next challenge is economic viability. The metric to optimize is valued work per watt. This means measuring the actual value delivered to the user against the compute cost required to produce it.
Technical Deep Dive
To understand how a 'recipe' is actually built, we have to look at the transition from traces to evals. In a production environment, agents leave behind 'traces'—detailed logs of every thought, tool call, and error. Most developers ignore these, but Introspection treats them as the primary data source for distillation.
The process follows a specific technical pipeline: Pattern Recognition → Calibration → Promotion. First, you analyze traces to find clusters of failure. For example, in a talent-sourcing agent, you might notice the agent keeps trying to hire famous figures like John Carmack instead of finding 'hidden gems' on GitHub. This is a pattern of 'incorrect taste'.
Next, you create a Calibration Judge. This is a specialized LLM prompt or a small model trained to identify that specific failure pattern in future traces. A human-in-the-loop doesn't write the code for the eval; they simply calibrate the judge by confirming, "Yes, reaching out to Big Tech employees is the wrong behavior here."
Finally, this calibrated judge is added to the agent's recipe. This transforms a subjective human preference (taste) into a hard, versioned evaluation metric. This builds on the concept of RLHF (Reinforcement Learning from Human Feedback), but instead of updating the model's weights directly, it updates the harness and evals that guide the model's behavior in a loop.
Why This Matters
This approach shifts the value from the model provider (OpenAI, Anthropic, xAI) to the system architect. If the 'recipe' is the moat, it doesn't matter if a new, more powerful model is released tomorrow; you simply plug the new model into your existing recipe, and it immediately inherits your codified taste and business logic.
For vertical AI companies, this is the only way to build a defensible product. Without a distilled system of evals and signals, any competitor with a slightly better model can replicate your service. With a recipe, you own the 'know-how' of the domain, making your agent's performance a result of your proprietary distillation process rather than just a prompt.