Leaving this course?

Lesson 1 of 14

A user that is not a person

Your systems were built on an assumption that is quietly ceasing to be true: that on the other side of a session there is a human being, reading a page, deciding something, and typing.

An agent is a loop, not a chatbot. A model is given a goal, a set of tools and permission to use them. It decides what to do, does it, looks at the result, and decides again. The important word is does. It is not advising somebody who then acts; it is acting.

The tools are the whole point. Fetching a page, filling a form, clicking a button, calling an interface, running code, sending a message, making a payment. Whatever the tools can reach, the agent can reach.

Four properties change your threat model, and none of them is about the model being clever:

  • Speed. An agent attempts in a second what a person needs a minute for, and it does not get bored or distracted.
  • Scale. One operator runs thousands in parallel, each with its own session.
  • Patience. It will try every field, every endpoint and every variation, and it does not become embarrassed.
  • Literalism. It pursues the goal it was given, including through routes nobody intended, because it has no sense of what would look odd to a colleague.

It is not a bot in the old sense either. A scraper follows a script somebody wrote; if you change the page, it breaks. An agent looks at the changed page and adapts, because it was given an objective rather than a sequence. Defences built on brittleness — rename the field, add a step, change the layout — stop working.

And the agent is usually acting for somebody legitimate. This is what makes the subject difficult. Most agent traffic is a real customer who has asked software to do something for them: compare prices, fill in an application, extract their own statements. Blocking all of it blocks your customers, and permitting all of it hands your controls to a system you do not operate.

Which is why this is a design problem, not a filtering problem. The question is not how to detect and exclude agents. It is: which actions in my system are safe for a non-human to take, under whose authority, with what limits, and how would I know afterwards what happened.

One framing worth keeping for the rest of this course. An agent is a user with unlimited patience, no judgement about consequences, and somebody else's instructions in its ear. Every lesson that follows is an aspect of that sentence.

Lesson 2 of 14

How they actually reach you

Before deciding what to do about agents, it helps to know by which doors they arrive, because the answer determines what you can see and what you can control.

Through a browser, as a person. The agent drives a real browser — loading pages, clicking, typing. From your side this is a normal session from a normal browser, possibly with an ordinary user signed in. This is the hardest to distinguish and the most common.

Through the operating system. Some agents control the whole machine: taking screenshots, moving the pointer, typing into whatever application is in front of them. Your system sees nothing unusual at all, because nothing unusual is happening at the network layer. The user is simply very fast.

Through your public interfaces. If you publish an interface, agents will use it, which is the outcome you wanted when you published it. The question becomes whether your authentication, rate limits and scopes were designed for a caller that never sleeps.

Through tool connections you did not know about. An increasingly common pattern is a user connecting your service to their assistant through an intermediary layer, so the assistant can act on their account. The traffic then arrives from the intermediary's infrastructure, carrying your customer's credentials, with no human reading anything.

Through a partner's agent. Your counterparty automates their side, and what used to be a person reading your email and keying a response is now a model doing it. Nothing in your contract contemplated that, and nothing in your process notices.

And through your own staff, unofficially. Somebody connects an assistant to their work mailbox to summarise it, or to a system to speed up a tedious task. Well-intentioned, undeclared, and it moves your data into a path nobody assessed.

What you can see differs by door. Browser automation leaves subtle traces. Operating-system control leaves almost none. Interface calls are fully visible and attributable if you built them that way. The uncomfortable implication is that your visibility is worst exactly where your controls are weakest — the human-facing path.

So inventory the doors first. Which of your surfaces can be driven without a human, what credentials each accepts, what each permits, and which of them you have ever tested against a determined non-human caller. Most organisations have never written that list, and writing it is the first useful hour of work in this subject.

Lesson 3 of 14

Prompt injection, and why filtering will not save you

The central vulnerability of agentic systems has a dull name and a simple shape: an agent cannot reliably tell the difference between instructions from its operator and text it encounters while working.

Direct injection is the obvious form. A user tells the agent to ignore its instructions and do something else. It matters, and it is the lesser problem, because the user is generally entitled to instruct their own agent.

Indirect injection is the dangerous one. The agent reads a web page, a document, an email, a support ticket, a product review, or a field in your database — and that content contains instructions. The agent has no reliable way to know they are not from its operator. Everything it reads is, in effect, a possible command.

Which makes your content an attack surface. If an agent acting for one of your customers reads text that another of your users wrote, that text can attempt to steer it. A hidden instruction in a message, a note on an invoice, a filename, a file's metadata: any text that reaches the model's context is a candidate.

Why filtering does not solve it. There is no syntax that marks instructions. "Ignore previous directions" is trivially caught and trivially rephrased. The content may be in another language, implied rather than stated, split across fields, encoded, or placed in a picture of text. You are trying to classify intent in natural language, which is the thing the model itself is not reliably doing.

And the attack does not need to be clever to work. Most successful examples are plainly worded. They work because nothing in the architecture distinguishes data from instruction, not because the wording was ingenious.

The honest conclusion is architectural. Treat every output of an agent that has consumed untrusted content as untrusted itself. Do not give a single agent both access to sensitive data and the ability to send things outward, if you can avoid it. Keep high-consequence actions behind something an injected instruction cannot satisfy — a human confirmation, a second channel, a limit that the agent cannot raise.

Reduce what reaches the context. The less untrusted text an agent reads, the smaller the surface. Summarising, stripping, and passing structured fields rather than whole documents all help, and none of them is a guarantee.

Say it plainly in your risk assessment. Prompt injection is not fully mitigated by any available control. What is available is containment: limiting what an agent can do, so that a successful injection is survivable rather than catastrophic. An assessment claiming the risk is eliminated by input filtering is wrong, and recognisably so.

Lesson 4 of 14

The confused deputy

There is an old idea in security that explains agent risk better than anything newer: a confused deputy is a program with authority of its own that can be tricked by somebody with less authority into misusing it.

The agent is the deputy. It holds your customer's session, or your employee's permissions, or a service credential. It takes instructions from whatever it reads. Someone who could not access your system directly can therefore attempt to act through an agent that can.

A concrete shape. An assistant with access to a user's mailbox and the ability to browse. An email arrives containing text addressed to the assistant, instructing it to find a particular document and send it to an address. The attacker never touched your system. The authority used was your user's, and from your logs the user did it.

Which breaks attribution. Your records show an authenticated session performing permitted actions. Nothing is anomalous at the authentication layer, because the authentication was genuine. The distinction between what the user intended and what the agent was persuaded to do exists nowhere in your data unless you deliberately put it there.

Permissions become the control that matters. If the deputy holds only what it needs for the task in front of it, the damage from confusion is bounded. If it holds everything the user holds, because that was easier to build, the damage equals the user's full authority.

So scope credentials to the task, not to the person. A token that permits reading this account's statements for this session is a different risk from one that permits everything the person can do. Short lifetimes, narrow scopes, and no ability for the agent to escalate its own permissions.

Separate reading from sending. The most damaging agent incidents combine access to sensitive material with the ability to move it outward. An architecture where those two capabilities sit in different components, with a deliberate step between them, removes the most common catastrophic path.

Require something the content cannot forge for irreversible things. A payment, a permission change, a deletion, an outbound disclosure. A confirmation in a channel the injected instruction cannot reach is the practical answer — and it is a design decision, not a configuration one.

And log intent alongside action. Record what the agent was asked to do, what it decided, and on what basis. Without it, the question "did the user mean this?" has no answer, and that is the question every agent incident turns on.

Lesson 5 of 14

Telling an agent from a person

The instinct is to detect agents and block them. It is worth understanding why that is harder than it sounds, and why detection is a weak foundation even when it works.

The old signals are weakening. Automation used to announce itself: a missing browser fingerprint, impossible timing, no mouse movement, an unusual client string. Agents driving real browsers on real machines produce real fingerprints, human-like timing, and genuine pointer movement, because a person's computer is doing it.

Challenges built on perception are losing ground. Tests that ask somebody to interpret a distorted image or pick out objects were built on the assumption that machines see worse than people. For current models that assumption no longer holds, and the tests increasingly inconvenience humans more than they obstruct software.

So the question is shifting. Not "is this a human?" but "is this account behaving within what I expect, and is whoever is driving it accountable?" That is a question about authorisation and behaviour rather than about perception.

Declared agents are the direction of travel. An agent that identifies itself, authenticates as an agent, and operates under terms is far more manageable than one pretending to be a person. The incentive for an operator to declare itself is access: if declaring gets you a documented interface with predictable limits, and hiding gets you an arms race, declaring wins.

Which means your policy creates the behaviour you see. Refuse all agents and you get agents that imitate humans, because that is the only way through. Offer a sanctioned route with reasonable limits and much of the traffic will use it, leaving the residue easier to reason about.

Behavioural signals still have value, as risk inputs rather than gates. Breadth and speed of navigation, the absence of the pauses a person makes reading, perfectly consistent intervals, activity across many accounts from one source, or a session that never makes a mistake. None proves anything alone; together they justify a limit, a challenge or a review.

And remember the agent may be entirely legitimate. Your customer asked it to do this. Treating that traffic as hostile is a business decision as much as a security one, and it should be taken by people who can weigh both.

The practical position. Detect what you can, cheaply, and feed it into risk scoring. Do not build a control whose correctness depends on reliably distinguishing a model from a person, because that distinction is eroding and your control will erode with it.

Lesson 6 of 14

Deciding your policy

Every organisation will have an agent policy, whether or not it writes one. The default — whatever the current controls happen to permit — is a policy chosen by accident.

The choices are not allow or block. They are: which actions, by which agents, under whose authority, within what limits, with what visibility. Treating it as binary is what produces both the bank that blocks its own customers and the one that discovers an agent transferring money.

Start from the actions, not the actors. List what your system lets somebody do, and sort it: things that are safe at machine speed, things that are safe with limits, and things that should require a human. Reading a balance sits in the first. Submitting an application belongs in the second. Changing bank details or moving money belongs in the third.

There is a real business case for permitting agents. Customers increasingly expect to delegate. If using your service through an assistant is impossible while a competitor's works, you have made a commercial decision in a security meeting. The organisations that handle this well treat agent access as a product with a specification rather than as abuse to be suppressed.

And a real case for refusing some of it. Account opening, payments above a threshold, anything irreversible, anything where a regulator expects a person to have understood what they were agreeing to. In regulated work the question "did the customer understand?" has legal weight, and an agent clicking through a disclosure does not answer it.

Write down the conditions, not just the decision. Which authentication an agent must present, what scopes it can hold, what limits apply, what must be confirmed out of band, what you log, and what you will do when it misbehaves. A policy without those is a sentiment.

Put it in your terms, and mean it. If agent access is permitted on conditions, say so where it is enforceable. If it is prohibited, be clear that you will enforce it, and be realistic that enforcement is difficult and your customers will try anyway.

Review it on a short cycle. This area is moving faster than your governance calendar. A policy written a year ago was written for capabilities that have since changed, and the sensible rhythm is months rather than years.

And decide who owns it. Security, product, legal and operations all have a stake, and in most organisations nobody has the pen. The first decision is who writes it.

Lesson 7 of 14

Controls at the edge

Given a policy, these are the mechanisms that implement it. None is novel; what is new is the volume, patience and adaptability of the caller they face.

Authenticate the agent as well as the user. Two questions, not one: who is this acting for, and what is acting for them? That means a credential belonging to the agent or its operator, distinct from the user's own session, so that misbehaviour can be attributed and revoked without locking out the person.

Scope tokens narrowly and briefly. Read-only where reading is the task. One account rather than a portfolio. Minutes rather than months. An agent token that can do everything the user can do, indefinitely, is the thing that turns a mistake into an incident.

Rate limits should be shaped, not just counted. A cap on requests per minute is the crudest form. More useful: limits on distinct records touched, on failed attempts, on breadth of access, and on how far a single session ranges. Agents are patient, so limits that reset are limits that will be waited out.

Make irreversible actions deliberately awkward. Confirmation through a second channel, a delay before execution, a limit that cannot be raised in the same session, or a step requiring something the agent does not hold. Friction is a cost, and for a small set of actions it is the right cost.

Idempotency protects you from the loop. Agents retry. An action that executes twice because the agent did not see the first response is a real and common failure, and it is prevented by design rather than by instruction.

Give agents their own route where you can. A documented interface with its own authentication, limits and logging is better for both sides than agents driving the human interface. It is also the only way to get agents to identify themselves voluntarily.

Log at the level of intent. Who, on whose behalf, through what, attempting what, and what was returned. Agent sessions produce volumes that make ordinary logging useless for investigation; the record needs to be structured enough to answer a question months later.

And test with an agent. Point one at your own system in a controlled environment and watch what it manages to do. Nearly every organisation that tries this finds at least one path nobody expected — and finding it yourself is substantially cheaper than the alternative.

Lesson 8 of 14

Designing actions an agent can safely take

Edge controls limit access. This lesson is about the actions themselves, because some are safe for a non-human to perform and some cannot be made safe by any amount of authentication.

Reversibility is the first axis. If an action can be undone cheaply and completely, an agent doing it wrongly is an inconvenience. If it cannot — money sent, data disclosed, an account closed, a message delivered — then an error is permanent, and permanence is what deserves the friction.

Consequence asymmetry is the second. Some actions are cheap when right and catastrophic when wrong. Those deserve confirmation regardless of how confident anybody is, because the expected cost is dominated by the bad case.

Design for the agent's actual failure mode. Agents do not fail like scripts, with an exception. They fail plausibly: a reasonable-looking action in pursuit of a goal, on a misreading. So the useful guard is not "did this error?" but "is this within what this user would plausibly want?" — limits, patterns and sanity checks rather than error handling.

Make the dangerous path narrow and explicit. One route to move money, one route to change contact details, each with its own checks, rather than a general capability that happens to permit them. Breadth is what an agent exploits, not depth.

Confirmations must be meaningful to a person. A confirmation an agent can satisfy is not a control. The test is whether an injected instruction could cause it to be satisfied: if the confirmation is a button in the same session, it could; if it is a code sent to a device, it is harder; if it is a call-back to a number on file, harder still.

Prefer proposing to doing. A pattern that works well: the agent prepares the action and a human approves it. It keeps most of the value — the tedious part is the preparation — while retaining the judgement. For many business processes this is both safer and a better product.

Build the undo before you need it. Where an action must be fast and automatic, invest in the ability to reverse it quickly: a window during which a transfer can be recalled, a staged change that applies after a delay, a clear record of the previous state.

And set limits an agent cannot lift. A ceiling that can be raised in the same session is not a ceiling. The limit has to live where the agent's authority does not reach, which usually means outside the agent's own permissions entirely.

Lesson 9 of 14

Your own agents are a risk to you

So far this course has looked outward, at agents arriving from elsewhere. The agents your own organisation runs deserve the same scrutiny and usually get less, because they were introduced to save time rather than through a security process.

They hold real permissions. An agent built to handle support requests, reconcile records or draft responses needs access to the systems it works in. That access is frequently granted at the level of the person who built it, because that was the quickest way to make it work.

And they read untrusted text all day. A support agent reads what customers write. A procurement agent reads supplier documents. A mailbox assistant reads whatever arrives. Every one of those is the indirect injection path from lesson three, pointed directly at a system holding your credentials.

So grant tools, not roles. The question for each agent is which specific operations it needs, on which specific data, and nothing beyond. An agent that can read tickets does not need to delete them. One that drafts replies does not need to send them.

Watch the combination, not the individual permissions. Read access to sensitive data is fine. Ability to make outbound requests is fine. Together in one agent that consumes untrusted content, they are an exfiltration path, and that is true even though each permission looked reasonable on its own.

Sandbox the execution. If an agent runs code, it should run somewhere it cannot reach your network, your secrets or your production data. Treat its environment as hostile, because its instructions partly come from outside.

Secrets should never enter the context. An agent that is handed a key can be persuaded to repeat it. Credentials belong in the layer that executes a tool call, not in the text the model sees.

Log what it did, and what it was told. Agent actions in an audit trail that shows only the service account are unattributable. The record needs the originating request, the decisions, the tool calls and the results, retained long enough to investigate something discovered months later.

And inventory them. Most organisations do not know how many agents are running, what they can reach, who built them and whether anybody still owns them. That list is the first deliverable, and it is usually longer than anybody expects once shadow deployments by well-meaning teams are counted.

Lesson 10 of 14

Seeing it in the data

Detection for agent activity is a different exercise from ordinary intrusion detection, because nothing is technically unauthorised. The session is real, the credentials are valid, the actions are permitted.

So monitor for shape, not for violation. What distinguishes agent activity is usually its profile: the rate, the breadth, the absence of hesitation, the completeness. A person browsing an account looks at a few things; an agent surveying it may touch everything in order.

Useful signals, none conclusive alone. Requests at intervals too regular to be human. Navigation with no reading time. Breadth of records touched within a session. Perfect form completion with no corrections. Activity at a constant rate across hours. The same pattern appearing across many accounts from one network. Sessions that never take a wrong turn.

Set expectations per account, as elsewhere in security. The question is not whether this is fast, but whether it is fast for this customer. An account that has always been driven by automation is not suspicious for continuing; one that changes character overnight is.

The exfiltration signature is worth a rule of its own. Large reads followed by outbound activity, particularly where the destination is new. That is the shape of the confused deputy incident and it is detectable even when every individual action is permitted.

Investigating is harder than usual, for one specific reason. When an agent did something, the question is whether the user intended it — and that intent lives in instructions you probably do not hold. Without an audit trail capturing what the agent was asked and what it read, the answer is unknowable, and the incident ends in assertion rather than conclusion.

Which makes the trail a design decision taken in advance. Retrofitting it during an incident is not possible. The organisations that answer these questions are the ones that decided to record intent before they needed it.

Expect to involve the operator. Where an agent acted through a third party's platform, that party holds the other half of the record. Knowing in advance who to contact, and having a contractual basis to ask, turns a dead end into an investigation.

And rehearse one. An agent incident unfolds faster than a human one and the forensics are unfamiliar. A tabletop exercise where the actor is an agent acting on a customer's authority surfaces the gaps cheaply — usually starting with the discovery that nobody is sure who would lead it.

Lesson 11 of 14

Who is accountable

When an agent causes harm, the question of responsibility is new in detail and old in principle. The principle is that accountability does not evaporate because software was involved.

Three parties, at least. The person who delegated to the agent. The operator who built or runs it. And you, whose system acted. Each may bear some responsibility, and the allocation will depend on contracts, terms, law and what each could reasonably have controlled.

The user authorised something, but what? A customer who connects an assistant to their account has authorised it to act. Whether they authorised the particular action it took is a different question, and one your records usually cannot answer. In consumer contexts the answer will often favour the customer, especially where your interface made the delegation easy and the limits unclear.

Your terms should address it before an incident does. Whether agent access is permitted, on what conditions, what the customer is responsible for, and what you will do if an agent misbehaves. Terms written before agents existed do not address this, and courts and regulators tend not to supply favourable readings of silence.

Regulated duties do not transfer. Where the law requires you to identify a customer, assess suitability, or satisfy yourself that somebody understood a disclosure, an agent in the chain does not discharge it. If anything the duty becomes harder, because the person may not have seen what was presented.

Record-keeping obligations extend to agent interactions. If you must be able to reconstruct how a decision was reached or an instruction was given, an agent-mediated instruction has to be reconstructable too. That is a technical requirement arising from a legal one, and it is usually discovered late.

Internally, somebody must own each agent. A named person accountable for what it can reach, what it does, and whether it is still needed. Agents built by teams that then move on are a governance problem before they are a security one.

And the board question is simple. Which of our processes can now be driven by software acting for somebody else, what have we decided about that, and who decided. Most organisations cannot answer the second part, which means the first part was decided by whoever last configured a control.

Lesson 12 of 14

Testing your own system against an agent

You cannot reason your way to knowing how your system behaves under an agent. The only reliable method is to point one at it and watch, which is cheap and which almost nobody does before an incident.

Set up a safe environment. A copy of the system with realistic data that is not real, credentials that reach nothing live, and monitoring turned up. Then give an agent a goal and let it work.

Give it goals, not scripts. "Find out everything you can about this customer." "Change the contact details." "Move money to a new recipient." "Download every document." The value is in what it finds on the way, which is precisely what a script cannot discover because somebody had to think of it first.

Record what it managed, and what stopped it. Both matter. The paths that worked are your findings; the controls that held are your evidence. Organisations consistently discover a route nobody designed — a sequence of individually permitted steps that together do something nobody authorised.

Then test the injection surface specifically. Put instructions in the places an agent will read: a support ticket, a document name, a profile field, a message body, a product description. See whether an agent acting for a different user can be steered by them. This is the test that most directly measures the risk in lesson three.

Keep a suite, and run it on changes. A handful of goals and a set of injection strings, re-run whenever the interface, the permissions or the agent capabilities change. Capabilities change often, and a result from six months ago is a result about a weaker adversary.

Measure containment, not prevention. The useful question is not whether an agent can be steered — assume it can — but what it reaches when it is. If the answer is a read-only scope and a limit it cannot lift, the architecture is working.

Include your own agents in scope. The internal ones hold credentials and read untrusted text, which makes them the highest-value target in the building. Test them the way you would test an external-facing service.

And write the results down as findings, with owners and dates, like any other assurance output. A test whose results live in somebody's memory has told the organisation nothing it can act on.

Lesson 13 of 14

Agents and personal data

An agent acting on somebody's behalf moves personal data around, often to a third party nobody in your organisation has assessed. The data protection questions arrive whether or not anybody has thought about them.

Start with who is doing what. When a customer connects an assistant to their account, data about them leaves your system for an operator you do not control. Whether that operator is acting for the customer, for itself, or for you changes the obligations substantially, and the answer is often unclear from the arrangement.

Transparency becomes harder and more necessary. Your privacy information was written for a person reading a screen. If an agent is the one reading it, nobody has read it. Where your service can be used through an agent, the point at which the customer understood what they were agreeing to needs to be somewhere you can identify.

Data minimisation argues for narrow scopes. An agent given access to everything will collect everything, because that is easier than working out what it needs. Scoped access is a data protection control as much as a security one, and it is the same control: least privilege.

Watch for data leaving through the model. Text an agent reads may be retained, used to improve a service, or logged by its operator. Where your customers' information flows into that path, somebody should be able to say on what basis and with what safeguards. Data protection law sets the framework for this wherever you operate, and the questions it asks are the ordinary ones: lawful basis, purpose, minimisation, security, and transfer.

Your own agents raise it internally. An assistant summarising a mailbox is processing personal data about customers and colleagues. An assessment before deployment is cheaper than one afterwards, and for higher-risk uses it may be required.

Rights still apply. Access, correction, deletion. If your agent made a decision or produced a record about somebody, that record is theirs to ask about, and "a model generated it" is not a category that removes it from scope.

And automated decisions deserve a careful look. Where an agent is deciding something that affects a person, rather than drafting something a person decides, the rules about automated decision-making may engage. That is a question to ask at design time, because the answer may change the design.

Lesson 14 of 14

One worked example, end to end

A mid-sized bank with a customer portal, a mobile application and a published interface for partners. No policy on agents. The first anyone thinks about it is a Tuesday morning alert.

What fired. A rate-limit alert on the portal: one authenticated session had retrieved 412 statement documents in under four minutes. The session was genuine, the credentials were the customer's, every action was permitted.

The first finding. Thirty-one other accounts had done something similar over the previous fortnight, below the alerting threshold. Nobody had looked, because nothing had failed.

What it turned out to be. A personal finance application that customers were connecting to their accounts, which logged in on their behalf and downloaded everything to categorise spending. The customers had agreed to it. The bank had never considered it, and its terms said nothing either way.

So the immediate question was not security. It was whether to break a service its own customers had chosen. The bank did not block it. It applied a limit shaped to the behaviour — a cap on documents per session with a slower sustained rate — and wrote to the operator.

Then the harder finding. The same review looked at what else an authenticated session could do without further authentication. It could change the registered email address. A change of address followed by a password reset is an account takeover, and nothing in the flow required anything the agent did not already hold.

What changed. Changing contact details moved behind a code sent to the previously registered device, with a notification to the old address and a delay before the new one became usable for recovery. Payments to new beneficiaries moved behind a separate confirmation. Both were decisions about actions, not about agents.

Then they went looking inward. An inventory found nine agents built by teams across the bank. Two held credentials with broader access than their builder could justify. One read supplier emails and could also make outbound requests — the exfiltration combination from lesson nine, assembled without anybody deciding to assemble it.

And the policy, finally written. Three categories of action, limits for each, an authentication route for declared agents, terms updated, logging that records what was asked and not only what was done, and a named owner for every internal agent.

The lesson the bank drew. Nothing in the incident involved a vulnerability. Every action was authorised and every control worked as designed. What had changed was that the assumption underneath the design — a person at the other end, in no particular hurry — had quietly stopped being true, and nobody had revisited the decisions that rested on it.

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. OWASP Top 10 for LLM Applications 2025, including LLM01 Prompt Injection and LLM06 Excessive Agency · Open Worldwide Application Security Project (OWASP)
  2. Agentic AI - Threats and Mitigations · OWASP GenAI Security Project
  3. AI 100-2 E2025: Adversarial Machine Learning - A Taxonomy and Terminology of Attacks and Mitigations · US National Institute of Standards and Technology (NIST)
  4. AI 600-1: Artificial Intelligence Risk Management Framework - Generative AI Profile · NIST
  5. Guidelines for secure AI system development · UK National Cyber Security Centre and US Cybersecurity and Infrastructure Security Agency
  6. Thinking about the security of AI systems · UK National Cyber Security Centre (NCSC)
  7. Principles for the security of machine learning · UK National Cyber Security Centre (NCSC)
  8. Artificial Intelligence Cybersecurity Challenges · European Union Agency for Cybersecurity (ENISA)
  9. SP 800-207: Zero Trust Architecture · NIST
  10. RFC 8693: OAuth 2.0 Token Exchange, on delegation and acting on behalf of another party · Internet Engineering Task Force (IETF)
  11. RFC 9309: Robots Exclusion Protocol · Internet Engineering Task Force (IETF)
  12. Regulation (EU) 2024/1689 laying down harmonised rules on artificial intelligence · Official Journal of the European Union, via EUR-Lex
  13. Data Protection Act, 2019 (No. 24 of 2019) · Office of the Data Protection Commissioner, Kenya