Lesson 1.13 · Agents From Scratch

Module 1 Final Quiz

Seven core questions covering every lesson in the module, then six on what the real runs showed.

review

What you will be able to do

Explain what turns an LLM into an agent
Describe the ReAct loop and who writes each part of it
Say why agents need structured output, memory, planning, and error handling
Tell a multi-agent hand-off apart from a ReAct loop
Explain why Module 1 built everything by hand before Module 2’s framework

How to use this

This is the final review for Module 1: Agents From Scratch. Answer each question from memory before revealing it - if one is hard, the lesson it came from is worth another read. The core questions are in lesson order.

Every lesson in this module was run against a real local model, and the runs taught things the theory alone does not. The last six questions come from those runs: invented tool results, instructions hidden in files, memory that quietly forgets, and agents that repeat each other’s mistakes.

One sentence to carry into Module 2: an agent is an LLM that can use tools, observe their results, and repeat the process until it can produce a final answer.

ArchitectureModule 1 in one picture

The loop at the centre is Lessons 1.4 to 1.6. Everything around it - memory, planning, error handling, more agents - is what Lessons 1.7 to 1.12 added.

User

LLM

decides the next action

Tool

your code runs it

Observation

result - or the error

Final Answer

Memory

1.8 - messages, notes.json

Planning

1.9 - steps first

Error handling

1.10 - errors as text

More agents

1.11 - hand-offs

React Flow

Module 1 cheat sheet

LLM

Generates text - including the decision about what to do next.

ollama.chat(model, messages)

Tool

A function your code runs on the model’s behalf.

TOOLS = {"calculate": calculate}

Agent

LLM + tools + a loop.

for step in range(max_steps):

ReAct

Thought -> Action -> Observation, repeated, then Final Answer.

options={"stop": ["Observation:"]}

Structured output

Machine-readable data: parse it, then validate it.

json.loads(raw)

Memory

Previous messages, resent - or facts in a file, loaded each start.

messages.append(...)

Planning

Break a goal into steps; carry results forward; re-check.

make_plan(goal)

Error handling

Turn failures into Observations, within limits.

except Exception as e: ...

Multi-agent

Specialised agents pass outputs to each other.

writer(researcher(topic))

Frameworks

Hide these details - Module 2 starts there.

LangChain, LangGraph

Key points

An agent is an LLM that can use tools, observe their results, and repeat until it can answer.
The model decides; your code executes - and every safety limit lives in your code.
Structured output must be parsed and validated; retries need feedback to help.
Memory is what your code resends or reloads; trimming and context limits make it forget.
Plans are guesses - carry results forward and re-check as you go.
Errors become Observations, inside step and retry limits.
Agents chained together repeat each other’s mistakes unless grounded in real sources.