The Loop Is the Product

An agent is a language model inside a loop, and the loop is the part a team builds. The model call is one node in it. What the loop sees, what it can touch, and what it saves are engineering decisions. So is the rule that stops it.

You meet an agent as a product surface first. A chat box gets a tool, the demo runs, and the room calls the result magic.

The course treats the agent as a system. The model sits in a loop, wired to tools and placed in an environment. Tasks measure it, and safety constrains it.

The Model Is One Call Inside a Process

The loop has five steps: observe, decide, act, examine, remember. The model call sits at decide. Tools make act possible, the environment supplies observe, and storage gives remember something to hold.

The process decides what the model sees, what it can touch, and how it recovers. It also decides how anyone knows the run worked. Draw the boundary around all of that and you have an agent. The model call alone is a text generator with good manners.

A complete agent has parts you can point at: loop state, tool contracts, memory, permissions, observability, evaluation, escalation, and rollback. Leave one out and the system still demos well. It fails on the first run where the missing part is the one that mattered.

Reliability Is the Standard

Reliability is the standard, and it is a harder bar than a good answer. Reasoning counts when it survives a distraction. Tools count when the interface is shaped well enough that the model does not have to guess. Memory counts when retrieval returns the right record at the right moment. A second agent helps when coordination beats confusion.

The standard is what still matters when you build with it next week. Four checks make it concrete.

• Name the state that persists between actions.
• List the actions that can change the outside world.
• Point at the evidence that ends the task.
• Show how a human takes control back.

Run the four before you widen what the agent can touch.

The Course Moves From the Inside Out

The twelve notes move from the inside out, and each one repairs a joint of the loop.

• Notes 1 and 2 build the decide and act steps. Reasoning traces make the decision less brittle. ReAct and tools ground the action, and memory makes the next observation less blind.
• Notes 3 through 7 make the loop inspectable: multi-agent frameworks, enterprise grounding, DSPy, coding agents, and workflow agents. They settle who owns state, what counts as evidence, and how a run gets measured.
• Notes 8 and 9 take the work language cannot hold: symbolic planners, solvers, simulation, robotics, and embodied control. Exact constraints move into the decide step, and the act step moves into a physical world.
• Notes 10 through 12 decide where the loop stops. Open science, measurement, responsible scaling, privacy, and trustworthy deployment draw that line.

Each group assumes the loop underneath it already exists.

A Demo Works Because a Human Filled the Gaps

A demo works once because a person fills the gaps by hand. You supply the state the loop never stored and clean the tool output before the model reads it. When the recovery path leads nowhere, you step past it.

None of that work is in the system. The next run happens without you in the room, and that run is the measurement.

Autonomy pays when the agent can see state, act safely, measure progress, keep evidence, and stop before mistakes compound. Without those five, more autonomy moves a bad decision further before anyone catches it.

Ask Which Part of the Loop Failed

When an agent fails, name the step that broke before you touch the prompt. Observe, decide, act, examine, remember, and the permission boundary are the candidates. A prompt edit moves the decide step and leaves the other five where they were.

Read the transcript and you see one run. Read the machinery and you see every run after it. Then check whether that machinery holds under noisy inputs, stale state, weak tools, and partial failure.

Fix the named step, run the task again, and check the same six candidates.

The Builder Test

Take one task your agent runs today and trace it through the loop. Point at the observation it started from and the action it took. Find the result, the memory it wrote, and the measurement that says the task is done. Name the boundary that held it inside its permissions. A step you cannot point at is the defect, and it is the next thing to build.

What Carries

Agent quality is state, tools, evidence, measurement, and control working together. Model quality is one input to that. The other five are yours to build.

A loop that cannot think through one hard task will not survive twelve. So the decide step comes first.