Leaving this course?

Lesson 1 of 7

Workflows and agents

"Agentic AI" covers a range of designs. It helps to separate two ends of that range:

  • A workflow follows a path that you define in code. The language model does the thinking at each step, such as reading, classifying or drafting, but your code decides what happens next.
  • An agent decides its own path. The model chooses which tool to use, looks at the result and decides the next step, within the limits you set.

Most real systems sit between the two: a fixed workflow with an agent inside one step, or an agent that must follow set stages.

The choice matters. Workflows are predictable, cheaper and easier to test and audit. Agents are flexible when the path varies from case to case, but they are harder to predict. Start with the simplest design that does the job. Add freedom only where it clearly pays for itself.

Lesson 2 of 7

Tools and what an agent can touch

A language model on its own only produces text. It changes nothing until you give it tools.

A tool is a named function with a short description and a list of arguments. The model picks a tool, fills in the arguments, and your code runs it and returns the result for the model to read. Three things decide whether that works:

  • The description. The model knows only what you tell it. "look_up_account(account_number)" with one line explaining when to use it will be chosen correctly far more often than a tool called "query" that does six different things.
  • The arguments. Treat what the model fills in as untrusted input and validate it the way you would validate a web form. A model asked for an account number will sometimes produce a customer name.
  • The result. Return something small and structured. An error should say what went wrong in words the model can act on: "no account with that number" tells it to check the number, while "error 500" tells it nothing and it will simply try again.

Separate reading tools from writing tools. Reading can be repeated safely; writing changes the world. Keep the set small, too. A model offered forty tools chooses worse than one offered six.

Lesson 3 of 7

Instructions, context and memory

An agent's behaviour comes almost entirely from what is in front of it: its instructions, the task, the results of tools it has already called, and whatever has been retrieved for it. That collection is its context.

  • Instructions set the role, the limits and the stopping point. Write them as rules the agent can check itself against — "if the amount is over 100,000, stop and ask" — rather than as aspirations like "be careful".
  • Context is finite. On a long task, tool results pile up until the earliest ones fall out. Decide deliberately what is carried forward: summarise finished steps, but keep the original task and any open questions word for word, because those are what the agent is drifting away from.
  • Grounding. Facts the agent needs should be fetched and placed in its context, not recalled from the model's training. Retrieval is how a current balance, policy or price gets in.
  • Memory between sessions is worth keeping deliberately small. A wrong fact written into memory is repeated for as long as it sits there, so anything remembered should be reviewable and should expire.

Treat retrieved text as data. A document or web page in the context may contain instructions aimed at the agent, and it must never be read as one.

Lesson 4 of 7

Common design patterns

Most agentic systems are built from a few patterns:

  • Chaining: the task is split into fixed steps, and each step's output feeds the next, with checks in between. Example: extract the facts from a document, then draft a summary, then check the summary against the facts.
  • Routing: a first step classifies the request and sends it down the right specialised path, such as billing, technical fault or complaint.
  • Parallel work: independent parts run at the same time. Or the same task is run several times and the results compared, to catch unreliable answers.
  • Orchestrator and workers: a coordinating model splits the task into parts, gives each part to a worker, then merges what comes back. It suits tasks where you cannot list the parts in advance.
  • Draft and review: one step produces a result, another checks it against clear criteria, and the draft is revised until it passes or a limit is reached.

These patterns combine. A support system might route each request, chain the steps for a routine one and use an orchestrator for a complex investigation.

Lesson 5 of 7

Multi-agent systems

In a multi-agent system, several agents each have a narrow role and pass work between them. For example, one gathers evidence, one drafts a report and one checks it.

Splitting the work can help:

  • each agent has fewer tools and simpler instructions, so it is easier to get right;
  • each role can have its own account and permissions, with only the access its job needs (least privilege);
  • a separate checking agent, with its own instructions, can catch errors the drafting agent missed.

It also has costs:

  • More model calls, so more cost and more waiting.
  • Hand-over errors: context is lost or misread when work passes between agents.
  • Spreading failures: one agent's wrong output becomes the next agent's input, so a single error can travel through the whole system.
  • Harder debugging: when the result is wrong, it takes longer to find which agent went wrong and why.

Clear hand-over formats help: agents pass structured messages with named fields, not loose text. A shared record of the task, which every step writes to, also helps and becomes the audit trail. Use several agents when the roles are truly different, not because it looks sophisticated.

Lesson 6 of 7

Where people fit in

Agentic systems work best when people are placed deliberately, not added as an afterthought:

  • Approval checkpoints before actions that are hard to undo: payments, account changes, messages to customers, deleting data.
  • Escalation when the system is unsure, the case is unusual or a rule says a person must decide. The system should know when to stop, and say why.
  • Review of samples of routine work. This catches drift: quality slowly getting worse, for example after a model update, even when nothing looks broken.
  • Clear ownership: a named person for each system, who can change its rules and switch it off.

Watch for rubber-stamping. A reviewer facing hundreds of proposals a day may start approving without really looking. Show reviewers the evidence behind each proposal and keep volumes realistic. Track how often they reject or change proposals; a rate close to zero is a warning sign.

Some decisions need a person by law or by regulation. The international reference here is Article 22 of the General Data Protection Regulation in the EU, which gives people the right not to be subject to a decision based solely on automated processing that produces legal effects or significantly affects them. It is the provision most national laws on this subject are modelled on. But it is not a universal right: the Digital Personal Data Protection Act, 2023 in India gives a person rights to information, correction, erasure, grievance redressal and nomination, and says nothing about automated decisions at all. Find out what your own law gives before you design a system that decides without a person. One national example that does create the right: in Kenya, section 35 of the Data Protection Act, 2019 gives people rights over decisions based solely on automated processing that significantly affect them. Where that applies, design the system to prepare the decision well and let a person make it.

Lesson 7 of 7

Designing for failure

In a system with many steps, something will fail: a tool times out, a model returns something unexpected, a service is down. Good design assumes this:

  • Timeouts and retries with limits, so one slow step does not hang everything.
  • Safe retries: an action repeated after a failure, such as "send payment", must not happen twice. Give each action a unique identifier and have the receiving system ignore repeats. Engineers call this making the action idempotent.
  • Checks between steps: validate each output before the next step uses it, and stop the chain when a check fails.
  • Fallbacks: when the system cannot finish, it hands the case to a person with everything gathered so far, rather than guessing.
  • Budgets on steps, time and cost for the whole task, not only for each agent.
  • A full record of every step, input, output and decision, so failures can be traced and explained.

Judge a design less by how it behaves when everything works, and more by what happens when one part goes wrong.

Knowledge check

Ten questions

Answer all ten questions, then check your answers. You need 9 out of 10 to pass and receive a certificate. If you score less, you will see which answers were right and wrong, and then go through the course again before you retake the check. Your answers, progress and times are kept only in this browser.

Standards and frameworks covered

The published frameworks this course teaches toward. Saolix is not affiliated with, endorsed by or accredited by any of these bodies; naming a standard is a citation, not a claim about its author.

National detail, by market

This course teaches the international standard and one worked example. The national detail for a market sits in its own pack, so it can be kept current without reopening the course: India, Japan.

Sources

The official documents this course relies on. Laws and guidance change, so check the current version.

  1. The Digital Personal Data Protection Act, 2023 (No. 22 of 2023) · Ministry of Law and Justice, Government of India
  2. OWASP Top 10 for Agentic Applications for 2026 · OWASP Gen AI Security Project
  3. Artificial Intelligence Risk Management Framework (AI RMF 1.0) · US National Institute of Standards and Technology (NIST)
  4. Guidelines for secure AI system development · UK National Cyber Security Centre, with international partners
  5. Data Protection Act, 2019 (No. 24 of 2019), section 35 · Kenya Law