Agentic AI
The agent is a compiler. Own the loop, rent the model.
We keep making the same argument to clients: the model you pick matters least, and the loop you run around it matters most. It is easy to hear that as a vendor talking its own book. So it is worth pointing at someone with no reason to sell you our version of it.
Nirant Kasliwal builds and optimizes agent systems for a living. He wrote FastEmbed, contributes to LiteLLM, and spends his days cutting the cost of agents that run at the scale of a million chats a day. In a recent talk, "The agent as compiler," he arrives, from a pure engineering angle, at the position we have been building our whole practice around. His framing is sharper than ours, so we are going to borrow it.
The framing: the model is the middle of a compiler, not the product
A compiler takes source you wrote, lowers it through intermediate representations, runs optimization passes, and emits machine code you then run and check. Kasliwal's move is to line a coding agent up against that pipeline stage for stage. Human instructions are the source. The agent plans and explores, generates, then verifies the output by running it. And the large language model in the middle is the intermediate representation.
That last point is the one that pays off. As he puts it, "an IR is never the product. You run passes over it, then you check what comes out." Nobody ships the IR. You ship what survives the passes and the verification at the end.
If the model is the IR, a lot of anxiety about model choice evaporates. Swapping models becomes what swapping a compiler backend always was: a thing you do when a better one shows up, not the thing that defines your product. This is the same conclusion we reached the long way around in The model is a commodity, the harness is the product, and it is why we think general-purpose models keep beating specialized ones: the value was never in the middle box.
The loops are the product
Here is where the compiler picture gets useful rather than just clever. A compiler is a fixed graph of passes. An agent runs loops, and Kasliwal's taxonomy of them is the most practical part of the talk:
- The agent loop. The model calls tools until the task is done. Everyone already ships this. It is table stakes, not a moat.
- The verification loop. A grader, code or another model, scores the output against a rubric and feeds failures back. This is where quality is actually set.
- The event-driven loop. Something outside fires the agent, so it becomes a component in a larger system rather than a tool you poke.
- The hill-climbing loop. An analysis pass reads the traces and rewrites the harness itself, so the system improves between runs.
His line about the verification loop is the one we would put on a wall: reward and verification are the narrow slit an unbounded model output has to pass through, so they set the shape of what comes out. "Widen the slit and the ceiling lifts; narrow it and you just automate being wrong, faster." That is the mechanism behind something we have written about from the failure side, why small error rates explode over a long agent loop: without a real verifier in the loop, every pass compounds the last pass's mistakes.
Why this makes the model interchangeable, and cheap
Once the verifier carries the quality, the model underneath stops being special. Kasliwal's phrase is "frontier minus one is enough": with the right harness, last season's model does the work, and the model becomes a commodity you buy on price. He shows the same harness running five different models and holding its output, because the reward signal, not the weights, is doing the work.
That is the cost argument we made in the bottleneck has moved from intelligence to cost, stated from the other direction. When output quality lives in the loop, you are free to route to the cheapest model that clears the bar, fall back when one rate-limits, and never rewrite your product to do it. The commodity layer being cheap is a feature, not a threat, once you own the layer above it.
The human is in the loop on purpose
The part that matters most for how we deliver is that the loop is not autonomous. Kasliwal splits the reward into two kinds and gives each a human owner: a domain expert owns the outcome check, because they know how the finished thing should look, and a dedicated engineer owns the trajectory check, reading where the agent drifted from intent. "Most real systems need both."
That is not a compromise on the way to full autonomy. It is the design. It is exactly what we mean when we say anyone can build a digital worker, but we run it and own the number: the operated loop, with named humans setting and reading the reward, is the product we actually sell. The build is the easy part.
The verifier is a stack, not a vibe
If the verification loop is where quality is set, then building the verifier well is the work. This is the same layered evidence argument our everylayer product makes for test health, applied to model output: cheap, dense checks on every run, heavier ones less often. The open-source pieces you assemble it from are worth naming, because they are the concepts a team actually reaches for: promptfoo for prompt-regression checks, DeepEval and Ragas for scored evals, and Langfuse for the traces the hill-climbing loop reads. Skills, the reusable unit of judgment, need a security gate before you trust them, which is the case we made in the three-layer field guide to agent tools. None of these is exotic. That is the point: the loop is assembled from commodity parts, and the assembly is the moat.
The sovereignty angle a buyer should hear
Kasliwal closes with a line from Satya Nadella that he quotes on a slide: a company should be able to swap out a generalist model "without losing the 'company veteran' expertise built into their learning system," and that this is the real test of your control and sovereignty in the era ahead. Read as a buyer, that is a warning about where you let value accumulate. If your expertise lives inside a specific vendor's model, you rent your own institutional knowledge back every month. If it lives in your loop, your rubrics, your skills, your traces, then the model is a supplier you can replace on Tuesday.
That is the whole case, made by someone whose job is to make agents cheaper, not to sell you an operating model. The agent is a compiler. The model in the middle is a commodity IR. The loop around it, and the humans who own the reward inside it, is the thing worth building and the thing worth owning. Or, in the four words he ends on: own the loop.