Leaving this course?

Lesson 1 of 14

Why it all looks like one thing

One product's name has become the word for all of it. People say a system "uses ChatGPT" when they mean it has a text box, a prediction, a rule, or sometimes nothing but a fast interface. This course is about being able to say what a system actually is.

The confusion is not stupidity, it is a design outcome. A conversational interface hides the machinery behind it on purpose. Arthur C. Clarke's observation that sufficiently advanced technology is indistinguishable from magic is usually quoted admiringly; here it is a warning, because a thing you cannot classify is a thing whose risks you cannot name.

Three different systems can produce the same screen. A refund decision might come from a rule somebody wrote in 2019, a model scoring the transaction against past ones, or a generative model asked to judge the case in prose. The customer sees one answer. The difference decides whether the decision is repeatable, explainable, auditable, or defensible when a regulator asks.

Mislabelling runs in both directions. Plain software gets called AI because it is new and the interface is good, which inflates expectations and sometimes budgets. Real AI gets called "just automation" because it has been working quietly for a decade, which is how a model making credit decisions escapes the scrutiny a chatbot attracts.

The cost of the muddle is concrete. Teams buy a generative model for a job a database query did better and cheaper. Governance frameworks written for chatbots miss the scoring model deciding who gets a loan. Risk registers record "AI" as one entry when four quite different failure modes are present.

This course gives you a test, not a vocabulary list. By the end you should be able to take any system, ask three questions about it, and place it in one of four groups: deterministic software, predictive AI, generative AI, or agentic AI. You should also be able to say what each group can and cannot do, and what goes wrong with each.

The groups are not a hierarchy. Agentic is not better than deterministic. A payroll calculation should never be probabilistic, and a sanctions list should never be summarised by a model that might paraphrase a name. Choosing well means choosing the simplest thing that answers the question.

And real systems mix them. Almost nothing in production is purely one kind, which is why the last third of this course is about hybrids and about where a person belongs in the loop. The point of the taxonomy is not to file systems away; it is to see the parts, and the seams between them.

Lesson 2 of 14

Input, engine, output

Here is the whole test. For any system, ask what goes in, what the engine does with it, and what comes out. Three questions, and the answers classify almost anything.

Question one: what goes in? Structured fields from a form or a database, or unstructured material such as free text, an image, a recording? Deterministic software and predictive models usually take defined inputs. Generative models take whatever can be expressed as a sequence.

Question two: does the engine follow written rules or learned weights? This is the question that does the real work. A rule was written by a person and can be read. A weight was derived from data by an optimisation process, and no single number in it explains anything on its own. If somebody can show you the logic as text, it is rules. If they can only show you the training data and the evaluation, it is learned.

Question three: is the output an exact result, a prediction, content, or an action? An exact result is the only correct answer to the input. A prediction is a number, label or probability about something. Content is new text, image, audio or code. An action changes something outside the system.

Those answers give you the four groups. Written rules and an exact result: deterministic software. Learned weights and a prediction: predictive AI. Learned weights and content: generative AI. Learned weights, content, and the ability to act on it in a loop: agentic AI.

Apply it to a spam filter and you learn something. The earliest filters were keyword rules: deterministic. Most filters since have scored the message against patterns learned from labelled mail: predictive. Same product name, same screen, different kind of system, and the second one can be wrong in ways the first could not.

Apply it to dynamic flight pricing. Prices changing by the hour feel like intelligence. If the price comes from a formula over seats remaining and days to departure, it is arithmetic. If it comes from a model forecasting demand, it is predictive AI. Only one of those can be surprised.

Apply it to a spellchecker. A dictionary lookup with edit distance is deterministic. A model predicting the intended word from context is predictive. The grammar suggestion that rewrites your sentence is generative. One product, three kinds.

The test is also a buying question. When a vendor says AI, ask the three questions. The answers tell you what to test before you sign, what can go wrong, and whether you need an explanation you can give a regulator.

Lesson 3 of 14

Deterministic systems, and why they are not AI

A deterministic system follows rules a person wrote. Given the same input it produces the same output, every time, and the logic can be read, reviewed and reasoned about.

The defining property is repeatability. Run it twice with identical inputs and you get identical results. Not usually, not within tolerance: identically. This is not a modest property. It is what makes testing meaningful, audit possible and a bug reproducible.

Most software that gets called AI is this. A payroll calculation, a database lookup, an interest accrual, a workflow that routes a form based on its amount, a script that renames files. Robotic process automation is usually here too: it repeats a sequence of interface steps, with no learning anywhere in it.

Complexity is not intelligence. A rule engine with four thousand rules is complicated, hard to maintain and impossible to hold in one head. It is still deterministic. Nobody should call it AI because it is big, and nobody should assume it is simple because it is not AI.

A good interface is not intelligence either. Autocomplete from a fixed list, a search box with fuzzy matching, a form that validates as you type: these feel responsive and modern, and none of them involves a learned model. This is the most common mislabelling, and the easiest to check with question two.

Where deterministic systems belong, they are the right answer. Anywhere the rule is known and the answer must be exact: tax, interest, entitlement, limits, thresholds, hard compliance blocks. If the law says a transaction over a threshold must be reported, you want a comparison, not an estimate.

Their failure mode is brittleness, not error. They do exactly what they were told, including when what they were told is wrong or no longer matches the world. They do not degrade gracefully on an input nobody anticipated; they stop, or they do something absurd with complete confidence. That confidence is a property of the code, not of a model.

Which also makes them the baseline nobody measures against. Before adopting anything probabilistic, the honest question is what a well-written rule achieves. Often the answer is most of it, for a fraction of the cost, with an explanation you can hand to anybody. Lesson fourteen returns to this as a decision.

And they are what a probabilistic system should be wrapped in. The hard stops, the limits, the reconciliations: these are rules around a model, not more model. The best architectures use learned weights for judgement and written rules for the boundaries that must not move.

Lesson 4 of 14

What probabilistic really changes

A probabilistic system does not compute the answer; it estimates how likely something is. Everything awkward about AI follows from that sentence.

Same input, possibly different output. Some systems are stable, some vary by design, but none owes you the same answer twice in the way a calculation does. For anybody used to deterministic software this is the hardest adjustment, because it breaks the habit of treating one successful test as proof.

Correctness becomes a rate, not a property. You cannot ask whether a model is correct. You can ask how often it is right, on what kind of input, and what it costs when it is wrong. That means evaluation stops being a pass or fail and becomes a measurement with a denominator, which has to be designed.

Confidence is not accuracy. A model can report high confidence and be wrong, and the confidence number is itself learned from data rather than being a guarantee about the world. A confident wrong answer is the single most dangerous output any of these systems produce, because it looks exactly like a right one.

Performance depends on resemblance to what it learned from. A system works well on input that looks like its training data and degrades on input that does not, often without any signal that this is happening. The degradation is quiet, which is why monitoring a live model is a continuing job and not a launch task.

The world moves and the model does not. Behaviour changes, fraud patterns change, language changes, customers change. A fixed model facing a changing world gets worse without being touched. This is drift, and it has no equivalent in deterministic software, where nothing changes unless somebody edits it.

Explanation is partial at best. You can often say which inputs mattered most to a decision. That is not the same as the readable logic of a rule, and the difference matters enormously anywhere a person is entitled to an explanation of a decision made about them.

Which means governance has to change shape. Deterministic software is governed by reviewing the code and the change. Probabilistic systems are governed by measuring behaviour over time, on data you keep, against thresholds you set in advance. The NIST AI Risk Management Framework is built around exactly that difference.

None of this makes probabilistic systems bad. It makes them suited to problems where no exact rule exists: reading handwriting, spotting an unusual pattern, ranking by relevance, judging similarity. The error is not using them. The error is using them as though they were calculations.

Lesson 5 of 14

Symbolic AI, the part still running your bank

Before learning from data dominated the field, AI meant representing knowledge as symbols and reasoning over it with rules. That work did not disappear. A great deal of it is still in production, and some of it is load-bearing.

Expert systems encoded what a specialist knew. A knowledge engineer interviewed experts and wrote their reasoning as rules, so the system could reach conclusions and, importantly, explain which rules it used. In the 1970s and 1980s this was the commercial face of AI, in medical diagnosis and industrial configuration.

The explanation was the feature. A rule-based system can show its reasoning as a chain a person can read and challenge. Decades later, that is still something learned models struggle to offer, and it is why rules persist where accountability is required.

They stayed where the rules are written down. Compliance is the clearest case. Sanctions screening logic, transaction limits, reporting thresholds, know-your-customer requirements: these are not patterns to be discovered, they are rules somebody published. Encoding them as rules is correct, not old-fashioned.

Payment routing and fraud blocks are full of them. The hard decline on a card, the velocity limit, the country block, the rule that stops a transaction regardless of what any model thinks: rules. Often sitting in front of a model, so the rule gets the final say on the things that must not be negotiable.

Their limit is the knowledge bottleneck. Every rule has to be elicited, written, maintained and retired by people. Where expertise is tacit, where a situation has thousands of weak signals, or where the pattern changes faster than a committee can meet, rules cannot keep up. That limit is what made learning from data attractive.

Calling them AI is a historical fact, not a stretch. They are in the field's own account of itself, and the OECD and EU definitions of an AI system are broad enough to include rule-based inference. This matters practically: a system you think of as "just rules" may fall inside an AI regulation's scope.

The useful consequence for you is scope. When an obligation or a policy says "AI systems", find out whether your rule engines are included. Many organisations have mapped their models and missed the decision logic that has been making consequential decisions for fifteen years.

And the hybrid is the normal case. Rules for what must be certain, a model for what must be judged. Lesson thirteen takes a single payment through a system built that way.

Lesson 6 of 14

Predictive AI, the silent workhorse

Predictive AI learns patterns from historical examples and applies them to new cases. It is the most widely deployed kind, the least discussed, and the one making the most consequential decisions about people today.

It learns from examples rather than rules. You supply cases and, usually, the right answer for each. An optimisation process adjusts internal weights until the system's answers on those cases are close to the recorded ones. Nobody writes the logic; it is derived.

Classification puts a case in a bucket. Fraud or not. Spam or not. Which of twelve categories this complaint belongs to. Whether this document is an invoice. The output is a label, usually with a score attached.

Regression predicts a number. Expected loss, time to failure, demand next quarter, likely claim size. The output is a quantity, and it carries uncertainty whether or not the interface shows it.

Anomaly detection flags the unusual. Rather than learning what fraud looks like, it learns what normal looks like and reports departures. Useful precisely where you cannot enumerate the bad cases, and prone to flagging the merely unusual.

Ranking orders things by relevance. Search results, recommendations, which alert an analyst should open first. Quietly one of the most valuable applications, because it does not decide anything; it allocates attention.

The question it answers is narrow and worth memorising. What is likely to happen, or which category does this belong to, based on what has happened before. That is the whole range. It is a great deal, and it is bounded.

It inherits whatever is in the history. A model trained on past lending decisions learns the past, including decisions that were wrong or unfair. The model does not know which patterns are legitimate; it learns the ones that predict the recorded outcome. This is why fairness work concentrates here, where the decisions touch individuals.

It is the kind most likely to be in scope and least likely to be registered. Credit scoring, insurance pricing, hiring screens, churn prediction, clinical triage. These are consequential, often regulated, and rarely what people mean when they say their organisation is "doing AI". If you are inventorying AI, start here rather than with the chatbot.

Lesson 7 of 14

What a prediction can never be

The clearest way to understand predictive AI is to be precise about what it cannot do, because that boundary is what the current confusion erases.

It cannot produce content. A fraud model cannot write the suspicious transaction report (STR), called a suspicious activity report (SAR) in some jurisdictions. It can score the transaction; the words are someone else's job, or a different kind of system's. The score and the narrative are not the same output and do not come from the same place.

It cannot hold a conversation. There is no dialogue in a classifier. Input in, score out. The appearance of conversation in a product comes from something else wrapped around it.

It cannot explain itself in sentences. It can often tell you which features weighed most. That is a different artefact from an explanation, and treating a feature-importance list as a reason given to a customer is a mistake with legal consequences in some jurisdictions.

It cannot handle a question nobody trained it for. A model that scores credit risk has nothing to say about a fraud pattern, even though both concern the same transaction. Capability does not generalise sideways; each task is a separate model unless somebody built otherwise.

It cannot tell you why the pattern exists. A model finding that a variable predicts default has found a correlation. Whether it is a cause, a proxy for something you are not allowed to use, or an artefact of how the data was collected is a question for people. Models do not distinguish these, and the strongest predictors are often the most suspect.

It cannot act. A prediction is information. Something else decides what to do with it. That separation is a safety property worth noticing, and it is exactly what agentic systems remove.

Which is why "AI will write our reports" is usually a category error. The organisation has predictive models, and the task wanted is generative. They are different systems, different budgets, different failure modes and different governance. Noticing this early saves a procurement.

And why the reverse error is expensive too. Asking a generative model to do a scoring job gives you a plausible number with no measurable accuracy and no stability. If the output should be a number with a known error rate, you want a model built and measured for that.

Lesson 8 of 14

Generative AI, completion rather than retrieval

A generative model produces new content: text, code, images, audio. The mechanism is simpler than the output suggests, and understanding it explains almost every strength and failure.

It predicts the next piece, repeatedly. For text, the model takes a sequence and produces a probability distribution over what could come next. Something chooses one, appends it, and the model runs again. Fluent paragraphs are that loop, many times.

The pieces are tokens, not words. Text is cut into subword fragments from a fixed vocabulary. This is why models miscount letters, handle unusual names oddly, and cost more for some languages than others: the unit of operation is not the unit you read.

It is not a database, and this is the crucial point. Nothing is looked up. There is no record retrieved, no source consulted, no index of facts. The model holds statistical regularities from its training, and produces text that resembles what followed similar text before.

Which means plausibility and truth are not connected in the mechanism. The objective rewards text that looks like the training data. A sentence that is well-formed, confident and false satisfies that objective completely. No part of the architecture checks a claim against anything.

The model holds no memory between calls. It sees the sequence given to it and nothing else. What feels like a conversation is the conversation being resent each time by the product around the model. Any continuity you experience is supplied by that wrapper, not by the model remembering you.

Transformers are the architecture that made this work at scale. The mechanism that lets each position attend to every other position, introduced for translation in 2017, is what allowed models to use long contexts effectively. The architecture is worth knowing by name; the behaviour above is what matters for deciding anything.

It is reactive by nature. You provide input, it produces output, it stops. On its own it initiates nothing, pursues no goal and takes no action in the world. Everything beyond that single exchange is built around it, which is what the next lessons are about.

So the right summary is narrow. A generative model is an extremely capable pattern completer with no notion of truth, no memory and no agency. Every useful application and every disaster follows from taking that sentence seriously or failing to.

Lesson 9 of 14

Why confident falsehood is the design working

Fabricated output is usually called hallucination and usually framed as a defect to be fixed. It is better understood as the objective working exactly as specified.

The objective is resemblance, not accuracy. Training raises the probability of text that looks like the corpus. There is no term for truth, no penalty for a false claim, no mechanism comparing an assertion to a fact. A fluent invention is a success by the only measure applied.

A missing fact still produces an answer. The model always has a distribution over what could come next, including where it holds nothing reliable. It does not detect that absence; it continues. What you receive is the most plausible continuation, not an admission of ignorance.

The fabrications are specific and well-formed. Invented citations have real-looking authors, journals and years, because the model has learned the shape of a citation. Plausible form is precisely what is optimised, which is why fabrications are harder to spot than noise would be.

Confidence is a property of style. Training text is mostly written confidently, so output is confidently written. The tone carries no information about reliability, and reading it as though it does is the most common way people are misled.

It worsens where the training data thinned out. Niche topics, recent events, local rules, specific people and organisations: anywhere the corpus held little, the distribution is less informative and invention more likely. This is often exactly where organisations most want answers.

Mitigation is possible; elimination is not. Supplying source material, asking for citations you check, keeping a person between the output and a consequence, measuring on cases where you know the answer: these reduce the rate. None removes the mechanism, because the mechanism is the model.

Which is why the phrase itself misleads. "Hallucination" suggests a malfunction, implying a fixed version exists. The behaviour is inherent to predicting plausible continuations, and the useful question is not how to stop it but what rate is tolerable for the task and how you would know.

And it sets the design rule. Never put a generative model where a false, confident, well-written answer would be acted on without a check. That rule alone prevents most of the serious incidents these systems cause.

Lesson 10 of 14

Grounding, and what it does not fix

Since a generative model holds no reliable record of facts, the obvious remedy is to supply the facts with the question. That is grounding, and retrieval-augmented generation is the common form of it.

The pattern is a search followed by a generation. The question is used to find relevant passages from your own documents; those passages are placed in front of the question; the model is asked to answer using them. An open-book exam rather than a closed one.

It changes the task. Without sources, the model is recalling statistical regularities. With them, it is reading and summarising material in front of it, which is a task language models are considerably better at.

It gives you citations that can be checked. Because the passages came from a known store, the answer can point at them. A reader can verify, which converts an unverifiable claim into a traceable one. This is the largest practical gain.

And it lets you answer about things the model never saw. Your policies, your contracts, your product, this quarter. No retraining, just retrieval. For most organisations this is the first genuinely useful application.

But the retrieval is now the weak point. If the search returns nothing relevant, the model still answers, from whatever it holds. If it returns the wrong passage, the answer is confidently wrong with a citation attached, which is worse than no citation. Most grounding failures are search failures.

Stale or contradictory documents produce stale or contradictory answers. The system has no way to know which of two conflicting policies is current unless something tells it. Document hygiene becomes an AI problem, which surprises people.

And the model can still stray from the sources. Supplying passages makes the correct answer likely; it does not force it. The model can blend retrieved material with learned patterns and produce something not supported by either. Measuring whether answers are actually grounded in the passages is a separate exercise from measuring whether they are right.

So grounding moves the problem rather than removing it. You now own a search system, a document corpus and their maintenance. That is a real improvement over an unverifiable model, and it is a long way from a system you can leave unattended.

Lesson 11 of 14

Agents, from answering to acting

An agent pursues a goal across multiple steps, using tools, and acts on the world rather than producing output for a person to use. This is the sharpest line in the whole subject.

The distinction is content against action. A generative model drafts the email. An agent checks the calendar, drafts the email, sends it, and updates the record. The first produces something you then decide about. The second decides and does.

The loop has four parts. Perceive the current state; reason about what to do next; call a tool, which might be an interface, a database or another system; observe what came back. Then repeat, until the goal is met or something stops it. The published pattern of interleaving reasoning with tool calls is what made this practical.

Tools are what make it consequential. A model with no tools can only talk. Give it the ability to send a message, move money, change a record, open a ticket or run code, and it can act. The capability is in the tools, and so is the risk.

It is stateful and persistent in a way the others are not. An agent carries progress across steps, and may run for minutes or days. There is no single input and output to inspect; there is a trajectory, which is harder to test, harder to reproduce and harder to explain after the fact.

It is proactive rather than reactive. Given a goal, it decides what to do next without being asked each time. That is the whole appeal, and it is precisely what removes the pause where a person used to look at the output.

Autonomy is a dial, not a switch. The same architecture covers an agent that drafts everything and asks before each action, and one that executes freely within limits. Where you set that dial is a business decision, and it should be an explicit one rather than a default.

Most "agents" on sale are nearer the workflow end. A fixed sequence of steps with a model at a few decision points is a sensible, testable design, and it is not the same as a system choosing its own path. Ask how much the system decides versus how much was scripted, because the answer changes what you must control.

And the failure mode is new. The others produce a wrong answer. An agent takes a wrong action, which may be irreversible, and may take several before anybody notices. The next lesson is about why that changes everything.

Lesson 12 of 14

The risk shifts from information to operations

When a system moves from producing content to taking action, the nature of the risk changes rather than the amount. This is the single most important idea in the course.

Informational risk is mediated by a person. A generative model gives you a bad summary. You read it, and you may catch it. The error reaches the world only through a human decision, and the pause where that decision happens is a control, whether or not anybody designed it as one.

Operational risk has no such pause. An agent with authority to act executes. The payment leaves, the record is deleted, the message is sent, the ticket is closed. The error is already in the world when it is noticed, and "noticed" may be days later.

Reversibility becomes the question that matters most. Some actions undo cleanly. Some undo with effort and a record of having gone wrong. Some do not undo at all: money moved to a third party, a message sent to a customer, data deleted, a filing made to a regulator. Sorting an agent's available tools by reversibility is the most useful hour you can spend before deploying one.

Errors compound along the trajectory. A wrong conclusion at step three becomes the input to step four. The agent continues confidently from a false premise, and by step ten it may be far from anything sensible, having taken several actions on the way.

Attribution gets harder. With a single input and output, you can show what was asked and what came back. With a trajectory of reasoning, tool calls and observations, reconstructing why an action was taken requires logging designed in advance. Retrofitting it after an incident is not possible.

Identity and permissions stop being an afterthought. An agent acting in systems needs its own identity, its own least-privilege permissions and its own audit trail. If it acts as a borrowed human account, you have lost both the attribution and the limit, and you have given a probabilistic system a person's authority.

The controls are mostly old controls, newly necessary. Limits on value and volume, approval above a threshold, segregation of duties, reconciliation, a stop that works immediately. These are the controls finance has used on people for a century. The reason they apply is that something is now acting, not advising.

So the decision is about authority, not capability. The question is never only whether the agent can do the task. It is what it is permitted to do unsupervised, what requires approval, and what it must never touch.

Lesson 13 of 14

Hybrids, which is what you actually have

Almost no production system is one kind. Once you can see the parts, you can see the seams, and the seams are where the design decisions live.

Follow one payment through a realistic system. A transfer arrives. Deterministic rules check the hard limits and the mandatory blocks. A predictive model scores it for fraud. If it is held, a generative model drafts a case summary for the analyst. An orchestration layer routes the case and updates the systems. Four kinds, one transaction.

Each part is there for a reason. The hard block is a rule because the obligation is written and must not be probabilistic. The score is a model because no rule captures the pattern. The summary is generative because it is prose. The routing is orchestration because it is action.

The ordering is a control decision. Rules before the model means the mandatory block cannot be overridden by a score. That is deliberate, and reversing it would let a probabilistic judgement sit in front of a legal obligation. When reviewing a hybrid, the order of the parts tells you what the designers were protecting.

The seams are where the failures hide. The model is measured, the rules are tested, and the handover between them is often neither. A score that arrives as a different scale than expected, a null treated as zero, a timeout treated as a pass: these are integration faults, and they produce silent wrong behaviour that neither component's monitoring catches.

Capability from one part gets attributed to another. Because the generative summary is the part a person reads, the whole system gets described as the generative one. The decision was made by a rule and a score, and the fluent paragraph is a description of it. Confusing the two leads to governing the wrong component.

So inventory by part, not by product. A single purchased system may contain all four kinds. Asking the vendor the three questions of lesson two about each stage tells you what you are accountable for, what you can test and what needs an explanation.

The practical benefit is targeted effort. You do not govern "the AI". You test the rules, measure the model, check whether generated text is grounded, and constrain what the orchestration is permitted to do. Four different activities, aimed at four different failure modes.

And a hybrid is usually the honest answer. The question is rarely which single kind to adopt. It is which part of the problem has a known rule, which has a pattern worth learning, which needs prose, and which needs something to act.

Lesson 14 of 14

Choosing, and where the person belongs

The last question is the one that saves the most money and the most trouble: what is the simplest thing that actually answers this problem?

Start by asking whether the rule is already known. If somebody can write down what should happen, write it down. A rule is cheaper, faster, exactly repeatable, explainable to anybody and testable. Choosing a model where a rule exists buys uncertainty and pays for it twice.

Then ask whether the output should be a number with a known error rate. If so, you want a predictive model built and measured for that, not a generative model producing a plausible figure. A number you cannot put an error rate on is not a measurement.

Reach for generation when the output is genuinely content. Prose, a summary, a draft, code, a translation. If what you need is words and a person will read them, this is the right kind, with the caveat of lesson nine attached to it.

Reach for an agent only when the value is in the doing. Multi-step work across systems, where the sequence cannot be scripted in advance and the benefit is that nobody has to carry it between steps. If the sequence can be scripted, script it: you get the same outcome and you can test it.

Cost and fit usually point the same way. A query that runs in milliseconds for a fraction of a penny beats a model call that takes seconds and costs orders of magnitude more, when both answer the question. The expensive option is not more serious; it is more expensive.

Place the person where the error would be costly and irreversible. Not everywhere, which defeats the purpose, and not nowhere. In front of actions that cannot be undone, decisions about individuals that must be explained, and anything a regulator will ask about. Everywhere else, sample and measure rather than review each case.

Decide what you will measure before you deploy, not after. What rate of error is acceptable, on what inputs, observed how, reported to whom, and what happens when it is exceeded. A system with no agreed measure cannot be said to be working, only to be running.

And keep the classification current. Systems change. A rule-based process gets a model added; a generative feature gains tools and becomes an agent without anybody announcing it. The three questions of lesson two are worth asking again at every significant change, because the kind of system determines the kind of care it needs.

Knowledge check

Fifty questions

Answer all fifty questions, then check your answers. You need 45 out of 50 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.

Sources

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

  1. Recommendation of the Council on Artificial Intelligence, which carries the definition of an AI system used in several laws · OECD, OECD/LEGAL/0449
  2. Regulation (EU) 2024/1689 laying down harmonised rules on artificial intelligence, Article 3 for the definition · Official Journal of the European Union
  3. Artificial Intelligence Risk Management Framework (AI RMF 1.0) · National Institute of Standards and Technology, NIST AI 100-1
  4. Artificial Intelligence Risk Management Framework, Generative Artificial Intelligence Profile · National Institute of Standards and Technology, NIST AI 600-1
  5. Computing Machinery and Intelligence, the paper that framed the question · A. M. Turing, Mind, volume LIX, issue 236
  6. Attention Is All You Need, the transformer architecture · Vaswani and others, arXiv 1706.03762
  7. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks · Lewis and others, arXiv 2005.11401
  8. ReAct: Synergizing Reasoning and Acting in Language Models, the interleaved reasoning and tool-call pattern · Yao and others, arXiv 2210.03629
  9. Survey of Hallucination in Natural Language Generation · Ji and others, arXiv 2202.03629