Lesson 3 - Your First Autonomous Loop

Welcome to Your First Autonomous Loop#

Setup and safety are in place, so now comes the moment the module has been building toward: you give an agent a goal, and it runs the loop on its own — gathering, acting, and checking, round after round, while you watch. This lesson is about making that first run go well: what to hand the agent, how to start it safely so you stay in control, and what to watch for as it iterates. The loop is the one you know; the new experience is seeing it run without you in every round.

By the end of this lesson, you will be able to:

• Give an agent a clear goal that sets up a good autonomous run
• Start a first run safely, in ask-before-changes mode
• Recognize the gather–act–verify loop as the agent runs it
• Steer or stop a running loop when needed

Let’s start with what you hand the agent.

Give It a Real Brief#

An autonomous agent will do exactly what you point it at, fast and across many files — which means the quality of your goal matters more here than in any browser chat. This is where Module 2 pays off. Don’t type “clean up my folder.” Hand the agent a proper brief: the goal, the definition of done, and the boundaries. “Sort every file in this folder into subfolders by type, rename any file whose name doesn’t describe its contents, write an index.md listing what’s in each folder — and don’t modify the contents of any file, only move and rename.” Now the agent knows what “done” looks like and what not to touch.

The difference is stark. A vague goal given to an autonomous agent is worse than a vague prompt in a chat, because there’s no round-by-round steering to catch the drift — the agent just confidently does the wrong thing to a hundred files. A clear brief given to the same agent is a joy: it works steadily toward a finish line you both understand. Everything you learned about writing finishable goals was really preparation for this moment, when the goal runs without you holding its hand.

Start in Ask Mode#

For a first run — and any run you don’t fully trust yet — start in a mode where the agent asks before making changes. You set this up in the last lesson; now you use it. In ask mode, the agent proposes each action and waits for your approval before it happens. You become the round-by-round check: you see “I’ll create these four folders — OK?” and “I’ll rename these 12 files — OK?” and you approve, adjust, or stop.

Ask mode does two things at once. It keeps you safe — nothing changes without your yes — and it teaches you what this agent does with this kind of task. After a run or two where every proposal was sensible, you’ve earned the confidence to loosen the approvals for that task. Starting hands-on is how you get to hands-off safely.

Watch the Loop Run#

As the agent works, you’re watching the exact loop from Lesson 1 play out — and it helps to name the phases as they go by. It gathers context: “reading all 100 files to see what each is.” It proposes and takes an action: “create these folders; move these files; rename these.” It verifies: “checking — 100 sorted? three are unmatched, handling those.” And it repeats until the goal is met, then reports done. That “three unmatched, handling those” moment is the loop correcting itself — the agent noticed its own work wasn’t complete and went another round, without you telling it to.

This is the payoff of everything so far: the attempt-check-correct cycle you ran by hand for four modules, now running on its own over real files. Your job during the run shifts from doing each round to supervising — approving actions, watching for anything off, and confirming the result at the end. It’s a different kind of work, and a much faster one when the agent is doing a task well.

Steering and Stopping#

You’re never a passive passenger. A running loop can be steered. If the agent proposes something you don’t want — “I’ll delete the duplicates” when you’d rather keep them — you decline that action and redirect: “Don’t delete anything; move duplicates into a duplicates/ folder instead.” If it heads off in the wrong direction, you stop it and restate the goal. And you can always halt a run entirely if something feels wrong; nothing is so far gone that you can’t stop and check.

The healthy mindset is the one from Module 3: a running agent’s “I’ll do X” is a proposal to verify, not a command you must accept. In ask mode you verify each proposal explicitly. As you move toward more autonomous modes later, you replace that per-action checking with a strong up-front brief, enforced permissions, and — next lesson — the agent’s own self-checks. But the instinct to stay in control, to treat the agent as a capable assistant you supervise rather than a black box you trust blindly, never goes away.

A Harborlight First Run#

The owner tries their first autonomous loop on a copy of the shared folder, in ask mode. They hand over the brief: sort by type, rename cryptic files, write an index, don’t alter file contents. They hit enter — and then watch. The agent reads the files and proposes four folders; they approve. It moves and renames; they watch the count climb. It checks its work, finds three files it couldn’t classify, and sorts them into a misc/ folder on its own — the loop self-correcting. It writes the index and reports done. The whole thing took four minutes and a handful of approvals. The owner reviews the folder: it’s genuinely tidy, the originals (the untouched real folder) are safe, and — importantly — they now trust this agent to do this task, which means next time they can let it run with fewer approvals.

Practice Exercises#

Exercise 1: Fix the first-run goal#

Improve this goal for an autonomous run: “tidy up my documents folder.”

Exercise 2: Read the loop#

In the run, the agent said “three are unmatched — sorting those now.” Which phase of the loop is that, and why is it a good sign?

Exercise 3: Steer the run#

Mid-run, the agent proposes “I’ll overwrite the old index file.” You want to keep the old one. What do you do?

Summary#

Running your first autonomous loop is where the whole module pays off: you give the agent a goal and it runs the gather–act–verify cycle on its own. Because it acts fast and across many files, the brief matters more than ever — hand it a real goal, definition of done, and boundaries (Module 2), not “clean this up.” Start in ask-before-changes mode, where you approve each action: it keeps you safe and teaches you what this agent does with this task, so you can loosen the approvals once you trust it. As it runs, you watch the familiar loop — gather context, take action, verify, repeat — and you stay in control, steering proposals you don’t want and stopping if something feels off, treating every “I’ll do X” as a proposal to verify. Pick a small, safe, reversible first task (a copy of a folder), and let one boring successful run earn you the confidence for the exciting ones.

Key Concepts#

• Autonomous loop — the agent running gather–act–verify itself, round after round, toward your goal.
• Ask-before-changes mode — the agent proposes each action and waits for your approval; safe and instructive.
• Self-correction — the verify phase catching incomplete work and going another round without being told.
• Steering — declining or redirecting a proposal, and stopping a run, to stay in control.

Why This Matters#

This is the moment loop engineering becomes real leverage: hours of file work done hands-off while you supervise, not toil. Learning to start hands-on — a clear brief, ask mode, a safe task — is what makes the later hands-off runs trustworthy rather than reckless; you earn autonomy by first watching the agent behave. It’s the same “verify before you trust” discipline from Module 3, now applied live to a running agent. But approving every action doesn’t scale — you can’t sit and click yes forever. Next, you’ll give the agent a way to check its own work against your criteria, so it can catch its mistakes without you approving every step.

Continue Building Your Skills#

You’ve run your first autonomous loop: a clear brief, ask mode, and the agent gathering, acting, and verifying its way to done while you supervise. Do one small, safe run yourself — the feel of watching a loop run hands-off is worth more than any description. Next, you’ll reduce how much you have to approve by giving the agent its own eyes: a way to check its work against your definition of done, so it catches its mistakes before you even see them.