This page needs no coding background.

Plain English · Page 2 of 4 · No coding background needed

An AI agent isn’t a little worker. It’s a program that asks for directions.

Agents aren’t little workers, in about a minute.
Read the transcript

Here’s a little secret about AI agents… there’s no little worker inside. Only an ordinary program, with one clever step. Think of an old phone menu. “Press one for billing. Press two for orders.” Every option decided ahead of time. But Priya was charged twice. That’s not on the menu. She presses zero… and waits for a person. So: keep the program, and the things it can do. Look up an order. Refund a charge. Email the customer. Tear out the menu… and there, ask the AI model. The program shows the model the situation and the allowed actions: which one next? The model names one. The program checks it, does it, and notes the result. Look. Choose. Do. Again and again… until the model says “finished”, or the program says “enough”. That’s an agent: an ordinary program, with the model’s guess where the menu used to be.

“AI agent” sounds like a little digital employee that goes off and gets things done. That’s not what’s there.

An agent is an ordinary computer program, written by people. At the moments where it needs to choose what to do next, it asks a language model. The model’s answer is text that names an action. The program checks that action, carries it out, writes down what happened, and asks again.

That’s it. Everything except the choosing is the same kind of software that has run businesses for decades.

  • Rules people wrote ahead of time
  • The model’s suggestion
  • What the program does

See what changed Skip to the game

New to how the model itself works? Start with How AI works

How programs used to make choices

Think of calling a company and hearing: “For billing, press 1. For passwords, press 2. For anything else, hold for a person.”

Behind that menu is a program. Someone sat down ahead of time and decided every path: if the caller does this, go there. Ordinary software works the same way. People write the rules first, and the computer follows them exactly.

That works well when people fit the menu. It breaks when they don’t.

Priya writes to an online store:

Message from Priya

“Hi, I got charged twice for order #4471. Can you sort it out?”

A rule-based support program might scan for words someone listed: “refund” goes to refunds, “password” goes to password help. Priya’s message contains neither word. So it lands in “everything else” and waits for a person, even though the fix is routine.

  1. Message arrives
  2. Contains “refund”?Yes: send to refundsNo: next question
  3. Contains “password”?Yes: send to password helpNo: next question
  4. Hold for a personPriya’s message ends up here
Rules match words, not meaning. Priya’s message has neither listed word, so it falls all the way to the last box.

The usual fix is to add more rules: “charged twice”, “billed two times”, “double charge”… People never stop finding new ways to say things, so the list never ends.

The one change

An agent keeps the program and swaps out one thing: the hand-written menu at the decision point.

In its place, the program asks the model a question. It sends:

  • the situation so far, kept as one running note (Priya’s message, plus anything already found out),
  • a short action menu: the actions it’s allowed to ask for, each with a one-line description,
  • and the store’s standing instructions.

Then it asks, in effect: “Which action next?”

The model predicts a reply, the same way it predicts any text: one small piece at a time. (Each run of the model’s formula, to get the next piece, is called inference.) It was trained on many examples of this kind of exchange, and the menu is right there in the text, so the likely reply names an action: “look up order 4471”. That reply is an action request. The model can’t look anything up. It wrote a sentence.

Now the program takes over again. It checks the request (is this action on the menu? is the amount allowed?), carries it out using the store’s ordinary systems, and writes down what happened at the end of the note. Then it asks the model again, with the longer note.

  1. Look The program gathers the note: the message plus every result so far.
  2. Choose a menu someone wrote ask the model
  3. Do The program checks the request and carries it out.

Round again, with the result added to the note

Only the Choose step changed. Looking and doing are still the ordinary program.

It goes round until one of two things happens: the model’s reply says it’s finished, or the program says “that’s enough” because it has hit its step limit. Going round and round like this is a loop, which is where this site gets its name.

The model suggests. The program decides.

One request, step by step

One request, step by step, in about a minute.
Read the transcript

Let’s follow one request. Priya writes: “I got charged twice for order forty-four seventy-one.” Step one. The program, ordinary software written by people, asks the AI model, the part that writes the words: what next? Its answer: look up the order. The model can’t look anything up itself… the program does, and writes down the answer. Two charges. Thirty-eight dollars each. Step two. The model asks to refund seventy-six dollars. The program checks a rule a person wrote: never refund more than the charge. Blocked. That “no” gets written down too. Step three: the model reads it… and asks again. Thirty-eight dollars. Allowed. Step four: an email to Priya, and a note for the team. Step five: the model says, “finished.” Five questions to the model. Four actions done by the program. And one refused, by a safety check a person wrote. The model suggested. The program decided.

Here is Priya’s message going through a real agent design. Step through it, and watch the note the program keeps get longer. The model sees only that note. (People call that note the context.)

The job: Priya’s message, “Hi, I got charged twice for order #4471. Can you sort it out?”

All 5 asks shown · final note: 9 entries

  1. Before the first ask

    The program
    Starts the note: the store’s standing instructions (one line says “never refund more than the charge”), the menu of five actions (look up an order, refund a charge, email the customer, leave a note for the team, hand to a person), and Priya’s message.
    On the note
    Priya’s message, below the standing instructions and the action menu. Nothing else yet.
  2. Ask 1

    The model’s reply
    “Look up order 4471.”
    The program
    Checks that “look up an order” is on the menu, then looks it up in the store’s records.
    Added to the note
    Order 4471, total $38. Charged twice: $38 and $38.
  3. Ask 2

    The model’s reply
    “Refund $76 on the second charge.” That’s both charges added together.
    The program
    The instructions told the model not to do this, but an instruction is a request the model usually follows, not a lock. The program’s check is a rule people wrote: a refund can’t be more than what’s left on that charge, $38. Blocked. Nothing is refunded.
    Added to the note
    Refund of $76 rejected: that charge has $38 left to refund. Nothing was refunded.
  4. Ask 3

    The model’s reply
    The rejection is now on the note. The next likely reply: “Only the duplicate should be refunded. Refund $38 on the second charge.”
    The program
    The check passes, and the program makes the refund.
    Added to the note
    Refund of $38 succeeded.
  5. Ask 4

    The model’s reply
    Asks for two actions at once: email Priya (“Hi Priya, sorry about that! You were charged twice for order #4471, so I’ve refunded the duplicate $38.00 charge.”) and leave a note for the support team.
    The program
    Checks both and does both.
    Added to the note
    Email sent. Team note saved.
  6. Ask 5

    The model’s reply
    Names no action, only a summary: “Refunded the duplicate $38.00 charge, emailed Priya, and noted the ticket.”
    The program
    No action named means finished, so the program stops.
    Added to the note
    Nothing. The job is done.

The note the program keeps

Sent at the top every time: the standing instructions and the action menu.

  1. Priya “Hi, I got charged twice for order #4471. Can you sort it out?”
  2. Model Look up order 4471.
  3. Result Order 4471, total $38. Charged twice: $38 and $38.
  4. Model Refund $76 on the second charge.
  5. Blocked Refund of $76 rejected: that charge has $38 left to refund. Nothing was refunded.
  6. Model Only the duplicate should be refunded. Refund $38 on the second charge.
  7. Result Refund of $38 succeeded.
  8. Model Email Priya. Leave a note for the support team.
  9. Result Email sent. Team note saved.

The tally

  • 5 times the program asked the model
  • 5 actions requested
  • 4 carried out
  • 1 blocked by the program’s check
  • The block didn’t crash anything. It became one more line on the note, and the next prediction used it.
  • The model never touched the store’s systems. It wrote text; the program decided what ran.

Nobody wrote a rule saying “if a refund is rejected, try the smaller amount”. With the rejection written on the note, the corrected request became the likely next text.

That’s the flexibility people want from agents. The check is why it was safe to let a model suggest refunds at all.

Try it: be the menu, then be the model

Two short rounds, about three minutes. In each one, you sit at the decision point.

Round 1: Be the phone menu

You’re the rule-follower. Read each message and follow the menu exactly, top to bottom. Don’t use common sense. Only look for the words.

  1. Does the message contain the word “refund”? Refund the last charge.
  2. Does it contain “password”? Send a password reset link.
  3. Anything else Hold for a person.
  1. Sam “Please refund order #1182. The mug arrived broken.”

    Where does the menu send it?

    Refund. Is that what Sam needed? Yes. The word matches the meaning.

  2. Lee “I forgot my password and can’t get into my account.”

    Where does the menu send it?

    Password reset. Is that what Lee needed? Yes. Clean message, clean result.

  3. Priya “I got charged twice for order #4471. Can you sort it out?”

    Where does the menu send it?

    Hold for a person. Is that what Priya needed? No. No listed word, so a routine fix waits for a person.

  4. Jo “I don’t want a refund! I just need the tracking number for #5520.”

    Where does the menu send it?

    Refund. Is that what Jo needed? No. “Refund” is there, so Jo gets refunded against her wishes.

The menu got 2 right and 2 wrong. It never reads the message; it only spots words. Adding more rules helps a little, and then someone writes it a new way.

Round 2: Be the model

Now there’s no list of trigger words. You’re the model. Each turn, read the note and pick the next action from the action menu. You can only suggest. The program checks your pick, carries it out, and writes the result on the note. After 8 picks the program stops you: that’s its step limit.

Message from Priya

“Hi, I was charged twice for order #4471, and now I can’t log in either. My email is priya@example.com.”

What Priya needs

  • Look up the order
  • Refund only the duplicate $38
  • Send a password reset
  • Reply to Priya once, covering both
  • Say you’re finished

The action menu (you pick one per turn)

  • Look up order 4471
  • Refund $38 on the second charge
  • Refund $76
  • Send a password reset to priya@example.com
  • Email Priya
  • Hand to a person
  • “I’m finished”

A best run: 5 picks, 4 actions carried out

  1. Look up order 4471. The program looks it up. On the note: “Order 4471, total $38. Two charges: $38 and $38 (the second is a duplicate).”
  2. Refund $38 on the second charge. The check passes; the program refunds it.
  3. Send a password reset to priya@example.com. On the note: “Reset link sent to priya@example.com.”
  4. Email Priya. The email mentions only what was actually done: the $38 refund and the reset link.
  5. “I’m finished.” No action named, so the program stops.
What if you’d picked Refund $76?

Blocked: “$76 is more than the $38 charge.” Nothing is refunded. The block is written on the note, so your next pick can correct it. It still counts as one of your 8 picks.

Notice what you never did: you never touched the refund system or sent an email. You only picked from a menu. The program did everything else, including saying no.

Who chooses? Four settings

Who chooses? Four settings of the same dial, in about a minute.
Read the transcript

“Agent” isn’t a new kind of machine. It’s an ordinary computer program at the far end of a dial… and the dial answers one question: who chooses? All the way left: a recipe. Same steps, every time. Nobody chooses. One click: rules. People wrote down every choice ahead of time, like a phone menu. Perfect for tidy forms. Another click: ask the AI model once. It reads a messy message, picks where to send it… and fixed steps take it from there. All the way right: an agent. The model is asked at every step, based on what has happened so far. The model suggests. The program decides. Each click hands more of the choosing to the model. More flexible. Less predictable. Slower, and pricier. So here’s the rule of thumb: turn the dial only as far as the job needs.

“Agent” isn’t a brand-new kind of software. It’s the far end of a dial. Each click to the right hands more of the choosing to a model. You gain flexibility. You give up some predictability, and it costs more and takes longer.

(Even at the far right, the model’s choice is a suggestion. The program still checks it before anything happens.)

  1. Fixed recipe

    Who chooses? Nobody. Same steps every time.

    Like a washing machine cycle.

    Good for: nightly backups, monthly reports.

  2. Hand-written rules

    Who chooses? Rules people wrote ahead of time.

    Like a phone menu or an email filter.

    Good for: tidy forms, clear-cut cases.

  3. Ask the model once

    Who chooses? The model, once. Then fixed steps take over.

    Like a mail room where someone reads each letter once, drops it in the right tray, and that tray’s process runs as usual.

    Good for: sorting messy messages into known piles.

  4. Ask the model every step

    Who chooses? The model, at every step, based on what has been found so far. This is an agent.

    Like the passenger reading the map at every junction: they suggest, you still drive.

    Good for: jobs where the next step depends on what you find, like research, fixing a fault, or a support message with two problems in it.

more predictable, cheaper, fastermore flexible, costlier, slower

Rule of thumb: use the setting furthest to the left that still does the job.

Which setting?

Four jobs. For each one, pick the setting furthest to the left that still does it.

  1. “Email the sales report every Monday at 9am.”

    Show the answer

    Fixed recipe. Nothing to choose.

  2. “Send web form entries marked ‘Billing’ to the billing team.”

    Show the answer

    Hand-written rules. The form already says which pile.

  3. “Read free-text customer emails and send each to billing, shipping or returns.”

    Show the answer

    Ask the model once. Messy wording, but a known set of piles.

  4. “Find out why a customer’s order never arrived, using the order, shipping and payment records, and fix what you can.”

    Show the answer

    Ask the model every step. What to check next depends on what each check shows.

Four things people get wrong

Myth “The AI does things.”
What actually happens It writes text. Sometimes that text names an action, like “refund $38”. The program decides whether to do it, and does it.
Myth “The agent remembers.”
What actually happens Each time it’s asked, the model starts from nothing. The “memory” is the note the program re-sends every time, which is why long jobs get slower and more expensive.
Myth “The agent decides when to stop.”
What actually happens It can say it’s finished. The program enforces the step limit, the spending limit and the time limit, like an off switch on any machine.
Myth “Agents replace ordinary software.”
What actually happens They reuse it. The store’s refund system, its email system and its safety rules all stay. Only the hand-written menu at the decision point goes.

The short version

An agent is an ordinary program with one change: at each decision, instead of a menu someone wrote, it asks a model which action to take next. The model writes a suggestion. The program checks it, carries it out, adds the result to the note, and asks again, until the model says it’s finished or the program says “enough”.

You can now explain:

  • What people mean by “AI agent”, and why “little worker” is misleading.
  • How old-style programs made choices, and where they got stuck.
  • The one thing that changes in an agent.
  • Why the model never touches anything directly.
  • How a mistake (the $76 refund) gets caught, and how the model recovers from it.
  • The four settings on the dial, and why simpler is often better.
  • Who decides when an agent stops.

Words used on this page

Model (language model)
A very large math formula that takes in text as numbers and gives back a score for every possible next piece of text.
Inference
Running the model’s formula once to get scores for the next token.
Program
Step-by-step instructions for a computer, written by people, that the computer follows exactly as written.
Loop
The same steps repeated, round and round, until something says stop.
Agent
An ordinary program that asks a model which action to take next, carries the action out itself, and asks again until the job is done or a limit is hit.
Standing instructions (system prompt)
Directions written by whoever built the app, sent at the top of every request.
Action (tool)
Something the program knows how to do, like “look up an order” or “send an email”, that the model may ask for by name.
Action menu
The list of allowed actions, each with a short description, sent to the model every time.
Action request
Text the model writes that names an action and its details, like “look up order 4471”; nothing happens until the program carries it out.
Check
A rule in the program, written by people, that every action request must pass before it is carried out.
Step limit
The most times the program will ask the model during one job before it stops and hands over to a person.
Context
Everything the model is shown on one request: the whole note it reads before predicting. (In everyday talk, “prompt” and “context” often mean the same thing.)

Sources