1 - Start ~4 mins
You have already trained a model and used it inside a program. Today the question is different: what happens when software is given a goal and allowed to plan, use tools, and act in a loop until the job is done?
That kind of software is called an AI agent. You will direct one on the board, then take turns being the agent yourselves.
Recap in one line only: last sessions trained an image model and used it in Scratch. Today's shift is from a model that classifies to software that plans and acts. Keep the open under a minute so the demo has time.
2 - Agent or Chatbot? ~4 mins
A chatbot answers. You ask a question, it replies with text. The conversation stops until you type again.
An AI agent is a model given a goal. It can:
- Plan the steps needed to reach the goal
- Act by using tools (write a file, run code, search, send a message)
- Observe what happened (an error message, a result, a web page)
- Adjust the plan and try the next step
It keeps looping through plan, act, observe, adjust until the goal is met or it is stopped. A chatbot waits; an agent keeps going.
Cap this at naming the four phases on the board and the one contrast: chatbot waits; agent keeps going. Do not add extra product examples here; any coding examples land in the demo debrief instead.
The common misconception is that any AI is an agent. Push the distinction only. If someone asks whether Scratch or MakeCode is an agent, say no: those run the instructions you wrote. An agent decides the next instruction for itself against a goal.
3 - Hands-on: Direct the Agent ~14 mins
Your class is about to direct an AI coding agent. One person is the error-spotter: their job is to call out when something looks wrong. Everyone else confirms the goal, predicts the next step before it happens, and names which phase is running: plan, act, observe, or adjust.
Goal: write a short program that asks for two numbers and prints their sum. If anything breaks, fix it.
Your teacher will run a live agent on the board, or walk a worked transcript one beat at a time. Before each reveal, write or say: next phase = ? next action = ?
After the run, answer as a class:
- Which steps were plan, act, observe, adjust?
- Where did the agent need a human watching it?
- How is this different from a chatbot that only explains how to add two numbers?
- Observe and adjust is debugging: the agent runs a test, reads what went wrong, and fixes it. Where did you see that today?
Before the lesson
If you have a safe, school-approved AI coding agent, drive it live on the board with the same goal. If not, use the worked transcript below. Both meet the outcome. Reveal only one beat at a time (board, slide, or reveal) so students see a single plan, act, observe or adjust moment with a predict pause. Do not put the whole transcript on screen at once.
Worked transcript (reveal one beat at a time)
- Plan. Agent: "I will write a short program that asks for two numbers, adds them, and shows the total." Pause: what tool will it use first?
- Act. Agent writes a program that reads two numbers as plain text and joins them together instead of adding them as values. Pause: what will happen when this runs with 3 and 4?
- Observe. It runs. Output shows 34, not 7. Error-spotter: what went wrong?
- Adjust. Agent: "The inputs were treated as text, so I need to convert them to whole numbers first." It rewrites the program to convert each input before adding.
- Act again. Runs with 3 and 4. Output shows 7.
- Observe. Goal met. Agent stops.
Suggested timing
- Pick the error-spotter and confirm the goal (1 min)
- Run the live agent or walk the transcript beat by beat (10 min)
- Class answers the four debrief questions (3 min)
Teaching tips
Force a predict pause before every act: What do you think it will do next? Hold students to the card prompt (next phase / next action) so phase-naming is practised, not only watched. Keep naming the phase out loud so the loop sticks. The planted bug (joining text instead of adding numbers) is deliberate: it shows observe and adjust, not a perfect first try. Land the debrief line that observe and adjust is debugging: run a test, read what went wrong, fix it. Use the debrief to land any extra coding examples you skipped in the set-up.
If the live agent goes off-track, that is useful. Freeze it, ask the error-spotter what they noticed, and decide as a class whether to let it continue or stop it. Staying in control is part of the point.
Look-fors
- Students using the words plan, act, observe, adjust without prompting by the end
- Someone spotting that 34 means the inputs were treated as text
- Someone saying the chatbot would only tell you the fix, while the agent tried it
- Someone linking observe and adjust to debugging or testing they have met before
4 - Hands-on: Be the Agent ~12 mins
Now you take the roles yourselves. Your teacher will model one tiny loop with the whole class first, then you work in pairs.
Director: state the goal. After each full loop, decide whether another loop may start, or stop the agent. You do not plan or do the work.
Agent: do only one full loop at a time:
- Plan one step out loud
- Act it on paper or on screen
- Report what you observed
- Say how you will adjust
Then wait for the director before the next loop.
Remember: Director speaks only after Adjust. Agent does one step, then waits.
Pick one goal from the list your teacher shows on the board. Run two full loops in total: complete at least one loop, swap once so each of you is the agent for at least one loop, then stop.
Before pairs start, spend about 60 seconds modelling one tiny loop with the whole class on the Scratch bounce goal. You state the goal as director; a volunteer agent plans one step, acts (names the if-on-edge-bounce block), observes ("sprite would bounce"), and adjusts ("next I would test it"). Then freeze and send pairs off.
Goals list (show on the board as a pick-one strip; do not leave this buried in the student card)
- Write the steps for a Scratch sprite that bounces when it hits the edge. Example act: write the name of the if-on-edge-bounce block on paper.
- Plan a micro:bit program that shows a happy face if the room is bright and a sad face if it is dark. Example act: note the light-level sensor block and the threshold you would check.
- Fix a broken Python idea that should count from 1 to 5 but never stops because the counter is never increased after each print. Example act: on paper, write "after each print, increase the counter by 1" as the missing step in the loop.
- Build a two-page plan for a tiny website about a local sports club (home page and fixtures page). Example act: list two headings for the home page.
Run in pairs. If numbers are odd, a triple works with one observer who only names the phase out loud.
Circulate for the rule-break you will see most: the "agent" jumping three steps ahead, or the director planning or doing the work. Blow the whistle gently and reset to one step. The director only speaks after a full loop (approve another loop, or stop), not mid-loop. Check that adjust is spoken out loud before the next loop starts.
Sixteen minutes covers the model, board goal pick, two loops total across both roles, one swap, and a one-minute whole-class snap on which role needed more judgement? Do not wait for every pair to finish both roles deeply. Expect split views: directors hold the goal and the stop decision; agents decide the next concrete move under tight rules. Both are judgement. Name that.
5 - Make Sense ~3 mins
An AI agent is not just a chatbot with a longer answer. It is software given a goal that can plan, use tools, act, read what happened, and try again in a loop.
In coding, that loop is familiar: write, run, read the error, fix. Observe and adjust is debugging: the agent runs a test, reads what went wrong, and fixes it. The difference is who is driving each step, and who is still responsible for the result. You saw both sides today: directing an agent, and being one under strict rules.
Keep this to two minutes of whole-class talk. Land one sentence: the agent acts; the human still owns the goal and the stop button. Name that observe and adjust is the same skill as debugging. That line feeds the next lesson on judgement, limits and ground rules.
Unlock the full learning experience
You're previewing this lesson. Get full access to this lesson and hundreds more — each one ready to teach, with interactive activities, printable resources and pupil progress tracking built in.
This lesson is copyright of Coding Ireland 2017 - 2025. Unauthorised use, copying or distribution is not allowed.