A holiday-week special: NLW hands the mic to Nufar Gaspar for a webinar on the buzziest skill of the summer — loop and graph engineering — and how to drag it out of software engineering and into knowledge work. The core move: coders got verification for free; the rest of us have to manufacture the referee. If you can define a boring, checkable finish line, agents will run until the job is actually done — and when one loop isn't enough, you compose them into teams.
If you can't design a verifiable finish line, don't loop it — but you usually can.
Every agentic tool already runs a loop under the hood; the new skill is taking control of it. Coding made loops easy because verification is free — the code compiles or it doesn't. Knowledge work has no compiler, but the webinar's central move is that verification can be designed: boring, machine-checkable finish lines that let an agent run overnight until the work meets the bar. Master two things — knowing when a task deserves a loop, and defining the 'done when' — and then compose loops into graphs of agents only when one worker stops being enough.
The summer's hot topic among advanced AI users: don't tell the AI what to do — set up circumstances where an agent loops over and over against a measurable goal, running until the task is verifiably complete. It took hold first in software engineering, where success is definable; moving it into knowledge work is harder but doable with the right task design.
OpenAI's recent usage statistics show that around April–May, the majority of tokens consumed shifted from the ChatGPT-assisted paradigm to the agentic paradigm. Notably, the firms and individuals using AI agentically are pulling away from the average — at least by the rough metric of tokens consumed.
The framing the whole webinar hangs on, originally from NLW on the show: one loop is one worker running until done; a graph is loops composed into a team. The three-sentence version: your tools already loop behind the scenes, a concrete verifiable end goal makes them work until actually done, and when one agent isn't enough you compose loops into teams.
Each renaming — prompt engineering, context engineering, harness engineering, loop engineering, graph engineering — is about giving AI more independence at bigger scale. Chasing every new term is exhausting; the skill that survives every rebrand is knowing how to get agents to work effectively and how to orchestrate them.
Three weeks before the webinar, one of the most renowned engineers in modern tech history departed Google to found a company built around using loops for discovery — a data point that running AI in loops for progressively better results has real merit, especially in research and science where more experiments eventually find the right direction.
Every agentic tool — CoWork, ChatGPT Work, Codex, Cursor — already runs plan, act, check, adjust under the hood. But the native loop is only as good as what the vendor implemented, and it's generic: that's why the tools stop after one polite pass and need nudging unless you take control of the cycle yourself.
The advanced loop means extending the tool's native cycle with a dedicated command — /goal in most tools, literally 'loop' in Cursor — handing it a concrete, highly verifiable end goal it can progressively test itself against. Two skills matter: knowing when a task needs this, and defining the correct finish line.
Don't confuse loops with automations. A schedule runs on the clock or a trigger; a loop stops when the work meets the bar, however long that takes. Profoundly different promises, different purposes.
Code compiles or it doesn't; tests pass or fail. Knowledge work has no built-in referee — nobody's compiler answers 'is this report good enough for management?' The central move: verification for knowledge work can be designed by you. And if you can't design a clear, verifiable finish line, the answer is don't loop it.
Loop a task when it's long-running AND checkable, when you'd want to send it overnight and come back to a finished result instead of a draft, when one-shot with the smartest model wasn't good enough, and when it has a natural retry-and-improve shape. If one pass does it, or your judgment is the actual work, a normal conversation is the smart move — not the cop-out. And remember: loops are among the most token-hungry executions you can run.
Real use cases: deep-and-wide research, ad and campaign optimization (highly verifiable via click-through data), competitive scans, content audits, compliance checks. Never loop anything requiring human judgment — executive communication, hiring, strategy — because autonomy, at the end of the day, does not have a taste of its own.
Knowledge work only succeeds on a loop when you invent a boring, checkable finish line: 'two hundred verified data points, every claim cited, summary under 150 words.' 'Make it insightful' is not checkable — there's no way for an agent to converge on it. The task must also live in a bounded sandbox where mistakes are cheap, and must actually be able to converge.
A proper loop goal has a machine-readable objective, a defined output artifact, and concrete judging/stopping criteria — that's what makes or breaks everything. Optionally add stages, and always add fail-safes: a turn cap (e.g., 30 cycles), time limits, sandbox-only constraints. If the 200 unique data points don't exist, the cap is what saves you from a forever loop.
In Claude Code's /goal, a token-efficiency research loop logged its own cycles: 56 data points, then 90, then past 200 — in other runs it blew through to 300, proving loops aren't always disciplined and caps matter. Pro tip from the demo: ask the model to be verbose and narrate each cycle so you can monitor progression while you're new to loops.
Loops fail four ways: runaway spend, cycling without progress, running on tasks that never should have been loops — and the sneaky one, meeting the letter of your finish line while the result stays bland. That last one isn't the loop's failure; it's your goal definition's. If it hit your criteria verbatim and you're still unhappy, redefine the referee.
One node with an arrow pointing back to itself is the textbook definition of a loop — loops and graphs aren't different things. Computer science has drawn work as dots and arrows for fifty years; what's new is that AI made the drawing operational. The real question is and always was: how many nodes does your work deserve?
The org chart pretends work flows top to bottom. In reality work branches, loops back, ends up sideways, skips levels, and occasionally flows straight up at 11 PM before board meetings. The graph — dots and arrows going wherever the work actually goes — is the picture you need to paint for your agents.
Engineers have wired agents into graphs for years. What changed is the node: it used to be one fragile LLM call; today it's a whole agent with two gears — a quick one-pass task or a full loop running until done. Agents got reliable enough to be building blocks, so you can now draw a graph on a whiteboard and actually get it to run.
Go multi-agent when: your agent rubber-stamps its own work (models tend to agree with themselves — Claude verifying GPT beats GPT verifying GPT); one agent is wearing too many hats and confusing them; work can run in parallel instead of serially; the finish line keeps changing mid-run because it's really two jobs on one card; or quality flatlines no matter what you try. If none apply, stay in the single agent and don't overcomplicate.
You can draw it and hand the photo to any agentic tool; let the harness improvise sub-agents; prompt the graph in words (one sentence — parallel researchers plus a fresh-context reviewer — is a seven-node graph); build persistent sub-agents and skills; use visual canvases like n8n; or write it in code with LangGraph. It's not a competition to the top tier — most knowledge work lives in the middle.
Match the model to the node — cheap and fast for mechanical steps, strong models where judgment lives. Pass contracts between nodes, never the whole conversation. Spend where verification pays, cap turns per node, verify early because mistakes compound, and put a human at the right gate. A beautiful graph with built-in deep research can eat millions of tokens without batting an eye.
Human workflows are shaped by human limitations — attention span, time, bandwidth, the inability to be proficient in multiple things at once. Agents don't share most of those constraints. Designing the best graphs requires slightly radical thinking about the job to be done, not copying the current process of how humans hand work between each other.
A work graph confesses how your work really flows, who really owns what, and where quality actually gets decided. Knowledge workers have spent careers learning exactly that for their domain — which is why subject-matter expertise, not coding skill, is the edge in designing these systems. The four skills to master as of now: understanding agents and their underlying loops, defining concrete workflows, configuring loops, and orchestrating teams.
NLW's closing frame: AI skills have shifted from useful new tools — how to prompt Midjourney — to fundamental work primitives. Big chunks of what we used to do ourselves are now jobs of managing agents. Don't expect to master advanced management in a single session: there are no experts at this, just people who have done it more.