TL;DR
The short version
Software engineers run agents in loops until the work passes a check, and wire agents into graphs when one agent isn't enough. Knowledge workers can copy both — but only after doing the part code hands you for free: writing a boring, machine-checkable definition of done.
That's the argument from a The AI Daily Brief webinar with Nufar Gaspar (host Nathaniel Whittemore): a loop answers until, not when; the finish line has to be checkable; and a graph is a diagram of how work flows, not who reports to whom.
Built on the The AI Daily Brief webinar with Nufar Gaspar and Nathaniel Whittemore.
The loop answers "until," not "when"
Every agentic tool already runs a hidden loop: plan, act, check, adjust. The skill isn't discovering that cycle — it's extending it with a command tied to a concrete end goal, so the agent keeps going until the work meets a bar instead of stopping after one pass.
The most common mistake is confusing a loop with a schedule. A schedule answers when — run this every morning. A loop answers until — keep working the problem however long it takes to clear the bar. If you find yourself picking a time, you don't want a loop. If you're picking a finish line, you might.
Coding got free verification; you have to build yours
Here's why this is harder for knowledge work than for code. Code compiles or it doesn't. Tests pass or they fail. The compiler is a referee that tells the agent, objectively, whether it's done.
A report has no compiler. Nobody's compiler answers those questions for an analysis or a memo, which means the referee has to come from you. If you can't build one, don't loop the task — a normal back-and-forth with the agent is the correct move, not a cop-out.
That referee has one hard requirement: it has to be boring and machine-checkable. "200 verified data points." "Every competitor covered." "Summary under 150 words." Those converge.
Something like "make it insightful" is not checkable. There is no way for the agent to converge on "make it insightful."
Nufar Gaspar, The AI Daily Brief
Gaspar packages the referee as a goal card: the objective, the output definition, the judging and stopping criteria, and fail-safes like turn caps and sandbox limits, all appended to the loop command. The card is where the work lives. The loop is just plumbing.
Where loops break
Loops fail in four ways, and only one is really the loop's fault:
- Runaway spend — no hard cap on turns, so it grinds forever. Set a turn limit before you start.
- Stuck cycles — it iterates without making progress.
- Met the letter, still mediocre — the output passes your check and still isn't good. Your finish line was wrong.
- Never should have been a loop — the task couldn't converge in the first place.
When one agent isn't enough, draw a graph
Push a single agent far enough and it strains: it can't reliably check its own work, it's wearing too many hats and drowning in context, or a task that could run in parallel is running in sequence. Those are the signals to fan out to more than one agent.
Wired together, agents form a graph — nodes are agents or tasks, edges are how information flows between them, and a loop is just a node pointing at itself. The reframe that matters: a graph is a work-flow, not an org chart.
The org chart is the diagram of the authority. It's not and never was a diagram of how work gets done.
Nufar Gaspar, The AI Daily Brief
This is where knowledge workers out-design engineers, because they already know how the work actually moves. What changed in 2026 is the node itself: it used to be a single fragile model call; now it's a whole agent, reliable enough to be a building block. Computer science has diagrammed work as graphs for decades — the new part is that the drawing became operational. Draw it and it can run for you.
Keep a human at the gate
Two guardrails run through all of it. Don't let an agent grade its own homework — models tend to agree with themselves, so one model judging its own output skews toward "correct." Use a different model, with fresh context, as the verifier.
And keep a human at the gate where judgment and taste actually live: verify early, spend where verification pays, and don't just copy the human process, since human limits aren't the agent's limits.
None of this needs expertise you don't have. As Nathaniel Whittemore put it, there are no experts at this — just people who have done it more. The move is to find one task with a boring, checkable finish line, write the goal card, cap the spend, and run it.
