In this video, Nate B. Jones (AI News & Strategy Daily) argues that the way most people use AI, one task at a time, is the wrong frame for the work that actually weighs on us. Instead of prompting AI repeatedly and remaining the manager of every step, he proposes a structure he calls a loop of loops: recurring jobs that remember context, notice when something changes, hand off to each other, and stop where your judgment is required.
The promise of the video is conceptual, not a tool tutorial. Nate wants you to leave able to look at one repeated job in your own life and say, "that's a loop I could build." A full build walkthrough is promised for Friday.
Nate keeps the definitions deliberately simple:
Crucially, this is not a "nanny in a box" or an agent pretending to run your life. It is a set of small, remembered workflows that notice what changed, hand off context, stop in the right places, and bring you in when your judgment matters. As Nate puts it: agents are loop managers, and that is what makes them interesting.
"Make me a packing list for the school trip" is a fine prompt. The AI can suggest a raincoat, lunch, water bottle, sunscreen. But the prompt was never the whole job. You still had to:
That recurring cycle, notice, gather details, compare against what you know, make the list, buy what's missing, is the loop. Without a system, the loop rests on your shoulders every time.
Going a level higher, a loop of loops detects "there's a school trip coming" and wakes the relevant loops together:
That last detail is the heart of the idea. Self-organizing is only trustworthy when the AI does not autonomously fire off messages while you scramble to unplug the computer. It is recurring jobs that notice each other and hand off context, then pause where a human decision belongs.
Most useful work is not a single question; it is a recurring situation that takes memory. A customer needs follow-up, a draft needs revision, a database needs refreshing, a client needs a response today.
Apps gave us only pieces of the loop: your email holds the confirmation, the school portal holds the pickup change, the grocery app holds the list. But the loop does not live inside any one app, it lives between them. For the last twenty years, the wiring between apps (open the calendar, text the parent, look up the address, set the reminder) has been on us. Apps digitized every piece of life and quietly made you do all the connecting. The first genuinely useful agent is therefore not another app in a box; it is something that sits across the loop that carries your load.
Nate stresses that his own setup (heavy on AI research) is only an example to illustrate the shape. Once you see the shape in one place, you spot it everywhere. He suggests interrogating your own life:
The key reframe: loops organize your attention. Your job is to make as many loops run cleanly as possible so you only get woken up when it really matters. Think of building a loop as allocating your attention once to create something durable.
Nate emphasizes the gap between prompting and looping is "99% of your mental effort," and that loops are not intuitive, which is why he is so concrete.
"Every Monday, tell me what's going on in the AI world. Give me the top 50 tweets, organized by theme, and do it again next Monday." That recurrence plus memory is a loop in its simplest form.
Add a second loop that checks multiple individual loops to find what's good. For example, a Twitter loop and a Google AI-news search loop (Claude or Codex can search directly, which is far easier than screen-recording a search). A loop of loops looks across both sources, aggregates them, and gives you one perspective on what matters today. Loops simply tell each other: here's what changed, here's what ran, here's what needs the human, here's what woke up another loop, here's what stopped.
The point is not grocery management specifically. It is caring about the practical loops that "eat our real brains up and make us tired," far more than any benchmark score.
This is explicitly not about never asking. An agent that never asks is dangerous. Nate's framing for safe loops:
If something recurs, you can loop it. To design one well, ask question-quality questions: What can it do safely? What should it ask? What record should it leave behind? How would it get smarter next time? And, importantly, what other recurring jobs should know about this? If the trip loop finds rain, what else needs to know? If the hiring loop finds a candidate, who needs to know? If the finance loop sees a travel charge, does the trip loop need it?
At the loop-of-loops level, the questions change, and Nate notes this is rarely covered well. A loop of loops is really a control pattern across loops. You don't get there by asking "where's the specific pain here?" That question is for designing an individual loop ("I have recurring pain; let me describe it well enough to delegate it"). The loop-of-loops question is higher level: what entire process am I willing to let go of and trust the AI to run? For example, delegating the whole "get the kids ready for summer camp" process. You only reach that level after thinking through the individual pieces of pain underneath it.
If you want an early start on a loop of loops, pick a process where:
Do not start with anything involving banking. A good first candidate: filling out product use cases (tedious), then turning those into Linear tickets, then having another loop tackle PRDs. That chains naturally into a loop of loops, and if it goes wrong, you have some cleanup but nothing catastrophic.