Scroll tech Twitter or LinkedIn for five minutes and you’ll meet them. The founder who left an agent running overnight and woke to a finished product. The engineer whose agent “gets smarter every week.” The poster who swears the entire SaaS industry is about to be eaten by “loops.” It reads like hype. But underneath sits one of the most consequential ideas in software right now — and, refreshingly, one of the simplest. Grasp it in two minutes; I’ll spend this column on why those minutes should reshape your week.
Swipe or scroll sideways to flip through the 10-slide deck →
The idea, in one line
Draw clean lines first, because “agent” gets slapped on everything now. A chatbot answers you: one message in, one reply out, done. A workflow is automation with a model bolted in at one fixed station: predictable but brittle, because when reality deviates from the script the pipeline breaks. An agent is neither. The definition that stuck across the industry is short enough to fit in a sentence: an agent is a model using tools in a loop. It runs the line — deciding, acting, checking what happened, and deciding again until the job is done.
That “over and over” is the whole trick — almost embarrassingly plain. The engineers who build these systems don’t dress it up: they call it “the canonical agent architecture — a while loop with tools,” and marvel at “the unreasonable effectiveness of an LLM agent loop with tool use.” The loop has four beats — gather context, act, observe the result, verify against the goal — then it repeats or exits. In code it’s small enough to memorize:
while not done:
step = model(context) # think, pick an action
result = run(step.tools) # act on the world
context.append(result) # observe what happened
done = goal_met(context) # verify, then loop or stop
Everything else — frameworks, “harnesses,” platforms — is scaffolding. The loop is the engine; the rest is the car.
Why the dumb loop wins
Here’s what should sting anyone who spent years hand-crafting AI pipelines: the loop beat them. A pipeline encodes a designer’s guess about how a task will go, and reality is a lousy collaborator — the API times out, the file’s missing, the data’s malformed — and the pipeline dies. A loop reads the error and tries something else, because “what happened” gets fed back in every turn. Error recovery isn’t a feature bolted onto the loop; it is the loop. And because the loop hands the model the steering wheel, it improves for free as models do — scaffolding built for a weak model becomes a ceiling on a strong one.
The internet’s favorite proof is the Ralph loop, which lit up feeds in late 2025. Engineer Geoffrey Huntley put a coding agent inside a bare while true loop feeding it the same prompt file forever, memory kept on disk, not in the model’s head. He named it after Ralph Wiggum precisely because it shouldn’t work — and yet projects shipped overnight, including a shared $50,000 client contract delivered for a few hundred dollars of compute. The point isn’t the folklore; Ralph isolates the active ingredient: not orchestration, not clever prompting, just iteration against feedback with memory kept in the environment.
What “self-improving” actually means
“Self-improving” sounds like machines rewriting themselves toward superintelligence. What it actually means: an agent that critiques and revises its own draft within a task (real, table stakes now); an agent that keeps a writable memory — notes, conventions, reusable skills — so mistake N isn’t repeated at N+1 (real, the current frontier); and an agent that rewrites its own prompts and tools (real in research — the Darwin Gödel Machine work — but fenced behind human approval in production).
Notice the through-line, the whole point: the improvement lives in the environment, not the model. The weights never change; what changes is the notes, tools, checklists, and accumulated context — the way a restaurant improves without swapping the chef’s brain. One rule sits under all three: critique must be grounded in something objective — a test, a rubric, a schema. An agent grading its own homework on vibes learns nothing; one graded by a failing test suite improves every cycle. Same rule names the honest risk: where you can’t verify, agents loop confidently toward plausible, not correct — so don’t automate what you can’t check; delegate and review instead.
What this does to work
A static agent is a tool you bought. An agent that gets even 1% better per week at your workflows is a compounding asset, and its value curve looks like nothing software has priced before. That’s why the money is moving, and why pricing is flipping from seats to outcomes: seat math stops describing value when one loop does a week of licensed-human work in an hour. Gartner projects at least 40% of enterprise SaaS spend shifts to usage-, agent-, or outcome-based pricing by 2030. One flagship support agent charges about $0.99 per ticket actually resolved — not per seat — and rode that past $100M in ARR.
Loops spread in a predictable order: not by intelligence, but by feedback latency. Code first (instant, verifiable), then reconciliation and compliance, then marketing and recruiting where feedback is slower, and last the deeply human work — strategy, taste, trust. The winners are the companies that make a fuzzy domain verifiable: build the “test suite” for legal review or ad creative, and you’ve built the rails agents run on.
The honest read: agent loops don’t remove humans, they move us up one level. The loop absorbs the middle two beats — act and observe. What grows is the outer loop that was always ours: deciding what’s worth doing (briefing), specifying what good looks like and judging the result (reviewing), and handling the weird 10% no rubric covers (exceptions). Harvard Business Review already named the role — the agent manager — and it will stop sounding exotic and start sounding like “manager.” Your calendar changes before your title does: mornings will begin by reviewing what your loops produced overnight.
So don’t cheer it or dismiss it. Get your hands on one. Pick a weekly task that’s digital and verifiable; write a crisp brief with a definition of done; give an agent minimal tools and a budget; review the output and feed your notes into the next run. That’s a loop, those notes are its memory, and you’re running a self-improving agent — everything in the hype is just that, with more zeros attached. The most threatened are those who refuse to operate a loop; the most empowered treat “what should the loop do, and how will I know it did it well?” as the job itself. Start one this week.