Learning objectives. By the end of this module you will be able to place any AI product you encounter on the conceptual ladder; explain the difference between traditional software, machine learning and generative AI in plain language; explain why agents became possible only recently; and describe what has genuinely changed about automation.

Core lesson

For seventy years, software worked one way: a human decided the rules, wrote them down as instructions, and the computer executed them exactly. If the rule was wrong, the output was wrong. If a situation was not anticipated, nothing happened. This is deterministic software, and it still runs the majority of the world. It is fast, cheap, auditable and utterly literal.

Machine learning changed the source of the rules. Instead of a human writing them, the system derives statistical patterns from examples. Spam filters, fraud detection and recommendation engines work this way. The rules became better at messy real-world data — and simultaneously harder to inspect.

Generative AI changed the output. Rather than classifying or scoring, these models produce new content: text, code, images, audio. The breakthrough architecture, the transformer, was published in 2017; the practical consequence arrived when models trained on enormous corpora began to display broad, transferable competence rather than narrow skill. These are foundation models — general-purpose systems adapted to many tasks rather than built for one.

Large language models (LLMs) are foundation models specialised in language. Because so much human work is mediated by language — instructions, documents, code, tickets, emails, policies — a system that handles language competently is unusually general.

That generality is where agents begin. Three capabilities, each maturing at roughly the same time, made agents practical:

Instruction following that survives complexity — a model that can hold a multi-part objective without collapsing.
Reliable structured output and tool calling — the model can emit a precise, machine-readable request to call a specific function with specific arguments, which is what turns a suggestion into an action.
Long, usable context — enough working memory to hold a task, its history and its supporting material at once.

Add a loop around those three and you have an agent: a system that receives an objective, decides on an action, executes it through a tool, observes what happened, and decides again.

START HERE — the five things people confuse

Chatbot. Answers questions in a conversation. It has no goal of its own and changes nothing outside the chat.

Assistant. A chatbot with better context about you and your work. Still fundamentally helping a human do the work.

Automation. A predefined sequence: when an invoice arrives, extract the total, add a row to the spreadsheet, notify the finance channel. Every step known in advance. Reliable and cheap. Blind to anything unexpected.

Agent. Given the objective “make sure every invoice this month is recorded and any anomaly is flagged”, an agent works out its own steps, uses tools to read email, parse documents and write to the ledger, notices the invoice that arrived in an unusual format, and asks a human about the one it cannot resolve.

Agent system. Several agents plus humans plus governance plus measurement, owning an outcome end-to-end.

The practical distinction: an automation does what you told it; an agent does what you asked for. The difference between “told” and “asked” is judgement — and judgement is exactly what needs boundaries.

ARCHITECT — what did not change

It is worth stating plainly, because a great deal of investment in 2024–2026 was lost to forgetting it:

Determinism did not become obsolete. Anything that can be expressed as a reliable rule should still be expressed as a reliable rule. A model call where a WHERE clause would do is a tax on every future run.
Data quality did not stop mattering. Agents amplify data problems, they do not absorb them.
Process design did not stop mattering. Standardise a process before you automate it, and automate it before you agentify it. Automating chaos produces faster chaos.
Accountability did not move. No regulator, client or court accepts “the agent decided” as an answer.

Business example

A mid-sized professional services firm receives client enquiries by email. The first version was a chatbot on the website: it answered FAQs and deflected roughly a fifth of enquiries. The second version was an automation: new enquiries created a CRM record and a task. Useful, but blind — enquiries arriving as forwarded threads or PDF briefs broke it. The third version was an agent: given the objective “every genuine enquiry becomes a qualified, enriched CRM record with a suggested next action”, it reads the thread whatever its shape, looks up the company, checks whether the sender is an existing client, drafts a qualification summary, and escalates ambiguous cases to a named human. Value did not come from the model being cleverer. It came from the agent being able to handle the cases the automation could not anticipate.

Common mistakes

Calling every LLM feature an “agent” — which makes it impossible to reason about cost, risk or architecture.
Reaching for an agent when a form, a rule or a query would have solved it.
Assuming that because a demo worked once, the system works. A single successful run tells you almost nothing about reliability (Module 12).
Believing that the newest model removes the need for architecture. It never has yet.

Expert insight

The industry’s centre of gravity moved from model capability to system design somewhere around 2024–2025. When frontier models were weak, the bottleneck was the model. Once models became broadly competent, the bottleneck moved to everything around them: context, tools, permissions, evaluation, recovery. This is why two teams using the identical model produce systems with wildly different reliability. The model is now the commodity; the harness is the craft.

Module summary

Software went from executing rules to learning patterns to generating content to taking action. Agents became possible when instruction following, tool calling and long context matured together. The conceptual ladder — model, assistant, automation, agent, multi-agent system, holistic agent system — is the tool for keeping the conversation honest.

Knowledge check

State the single defining technical difference between an automation and an agent.
Why does structured tool calling matter more than raw model fluency for agents?
Give one example from your own work of a task that should remain deterministic automation.
What is a foundation model, and how does it differ from a traditional ML model?
Why does moving up the conceptual ladder increase risk as well as capability?
“The agent decided” — why is this never an acceptable accountability answer?

Challenge

List ten repetitive tasks in your organisation. For each, mark which rung of the ladder is genuinely appropriate. Predict how many are agent-appropriate. Most people guess seven or eight; most honest analyses find one or two. Explain your reasoning for each in one sentence.

Further exploration

Anthropic, Building Effective Agents (2024) — the workflow/agent distinction from a frontier lab’s engineering practice.

The New Age of AI