AI agents: how they actually work
From a model that answers to a system that acts, and that you can put into production
A complete written course on AI agents, independent of any vendor or framework: what separates an agent from a chatbot and from an automated workflow, how the loop that drives it works, how to design the tools it acts through, how to handle memory, context and long tasks, when several agents help and when they get in the way, how to evaluate an agent on real cases, and how to protect it from excessive permissions and prompt injection. The last chapter explains why so many projects stall before production and what it takes to get there. Pass the final test and you get a certificate of attendance with a verifiable Open Badge.
- Tell an agent apart from a chatbot and from an automated workflow, and decide when an agent is really needed
- Describe the agent loop — observe, decide, act, verify — and the design choices it contains
- Design tools with clear descriptions, the right granularity, compact results and errors the agent can recover from
- Handle context, memory and long tasks with compaction, retrieval on demand, explicit plans and external state
- Judge when several agents help and when they only add cost and lose information
- Build an evaluation on real cases that measures outcome and path and guards against regressions
- Reduce risk with least privilege, defences against prompt injection and well-designed human confirmation
Prerequisites
- Having used a conversational assistant built on a language model
- Basic familiarity with ideas such as APIs, JSON and software testing: you never write code during the course
- No knowledge of the Model Context Protocol or of any agent framework is needed: where they matter, the course introduces them
Chapter 01
What makes a system an agent
A language model answering a question produces text and stops. An automated workflow runs a sequence of steps decided by whoever wrote it: at some point it may call a model to classify an email or summarise a document, but the order of operations is fixed in code. An agent, on the other hand, picks its own next step based on what it observes, uses tools to act, and keeps going until it judges the goal reached, or until something stops it.
The difference is practical rather than terminological: it changes who decides. In a predefined workflow every possible path was anticipated by a developer, so the behaviour can be checked in advance, branch by branch. In an agent the path emerges as it runs: give it the same task twice and it may solve it with two different sequences of steps. That makes it more flexible, and for the same reason less predictable. There is no way to get the first property without paying for the second; you can only decide how much to pay.
Between the two extremes there is a spectrum, and its rungs are worth knowing. You can chain several model calls in a fixed order, each with its own job. You can leave the model only the choice of branch — does this request go to technical support or to accounts? — and keep everything else fixed. You can run several calls in parallel and compare their results. Only at the last rung does the model also decide how many steps to take and which tools to use. Every rung adds autonomy, and with it cases nobody anticipated.
That leads to a clear rule for choosing. If the process is stable and the steps can be listed, a predefined workflow is simpler, cheaper, faster and easier to verify. An agent earns its place when the cases are too varied to anticipate one by one: a support request that might need three lookups or none, a code fix whose scope you can't know in advance. Reaching for an agent where a workflow would do is a common and expensive mistake, because you pay for unpredictability you didn't need. The opposite mistake — forcing a genuinely open problem into a rigid workflow — produces a chain of special cases that at some point nobody can maintain any more.
A concrete example helps pin the idea down. A coding agent such as Claude Code, which has its own course on Rinoova Academy, gets a request like “fix the failing test”: it reads the files it thinks are relevant, edits the code, runs the tests, looks at the result and decides whether it's done or needs another attempt. Nobody wrote that sequence in advance. The rest of this course is about exactly that: how the loop is built, what it needs to work well, and what the people building it need in order to trust it.
Chapter 02
The agent loop: observe, decide, act, verify
Underneath any agent, however sophisticated, there is a simple loop. The model receives a context: the goal, the instructions, the tools available and the history of what has happened so far. From that context it produces a decision: give a final answer, or call a tool with certain parameters. The code around the model — often called the harness, or the agent runtime — actually makes the call, collects the result and adds it to the context. Then it starts again. The model executes nothing by itself: it proposes actions, and something else carries them out.
def run_agent(goal, tools, max_steps=20):
context = [system_instructions, goal]
for step in range(max_steps):
decision = model(context, tools) # observe + decide
if decision.is_final_answer:
return check(decision, goal) # verify before declaring done
result = execute(decision.tool, decision.args) # act: the harness runs it
context.append(decision)
context.append(result) # the next observation
return stop("step limit reached", context)Those ten lines already contain almost every choice that matters. What goes into the initial context. Which tools are available and how they are described. How many steps are allowed before stopping. What happens when a tool fails. And above all, who decides that the work is finished. The step limit in particular is not a detail: an agent with no explicit ceiling can spin in place, repeating the same call or flipping between two strategies, and every turn of the loop costs time and money.
The four phases don't carry equal weight. Observing means having the right information in the context, neither too much nor too little: that's the subject of the chapter on memory. Deciding is the model's job, and it's the part you have the least direct control over: you influence it with instructions, examples and well-described tools. Acting always goes through tools, which are your own code and therefore the most controllable part of the system. Verifying is the phase prototypes skip most often, and it's the one that separates a useful agent from one that declares itself satisfied too early.
The best verification is the kind that doesn't depend on the model's opinion of itself. A coding agent that runs the tests after a change has an objective signal; an agent that merely rereads its own work and decides it's fine has a much weaker one. When a mechanical check exists — a test, validation against a schema, a comparison with a known total, a command's exit code — give it to the agent as a tool and tell it explicitly to use it before it wraps up. When no such check exists, a second pass by the model with different instructions can do it, or a person can.
Finally, the loop has to know how to stop properly. There are three legitimate exits: goal reached and verified; goal not reachable with the tools and information available, stated plainly; limit reached — on steps, time or cost — with an account of what was done and what is missing. An agent that, rather than stopping, makes up a result just to close the task is more dangerous than one that gives up. The instructions should make it explicit that “I couldn't do it, and here's why” is an acceptable answer, and the surrounding code should treat it as one.
Chapter 03
Tools: how an agent acts
An agent touches the world only through the tools you give it: querying a database, calling an API, reading or writing a file. Every tool has a name, a description and a parameter schema, usually written in JSON Schema, and the model decides which one to use, and with which arguments, by reading exactly those three things. It doesn't see the code behind the tool, doesn't know how it's implemented, doesn't know about the edge cases you handled: it sees only what you write for it.
{
"name": "search_orders",
"description": "Search a customer's orders by customer ID and optional date range. Returns at most 20 orders, newest first, with ID, date, status and total. Does not return line items: use get_order for those.",
"inputSchema": {
"type": "object",
"properties": {
"customer_id": {
"type": "string",
"description": "Customer ID, e.g. C-10482. Not the email address."
},
"from_date": { "type": "string", "format": "date", "description": "Inclusive start date, YYYY-MM-DD." },
"to_date": { "type": "string", "format": "date", "description": "Inclusive end date, YYYY-MM-DD." }
},
"required": ["customer_id"]
}
}Which has a consequence that catches out people coming from conventional development: a tool description is code, in every practical sense. The one in the example says what the tool does, what it returns, how many results and in what order, what it doesn't do, and which other tool to turn to in that case. The individual parameters have descriptions too: “not the email address” heads off a mistake you would otherwise discover in production. An ambiguous description produces wrong calls as reliably as a wrong type produces a compile error, and it deserves the same care: you write it, review it and version it.
Broadly speaking, tools fall into two families that are worth keeping apart. Read tools — search, look up, list — change nothing in the world, and using one wrongly costs at most a wasted step. Write tools — create, modify, send, delete — have effects, and some of those effects can't be undone. Keeping them separate lets you give the agent all the freedom to explore it needs while concentrating checks, limits and confirmations where the consequences are real. We'll come back to this in the chapter on security.
The parameter schema is the first line of defence, but not the only one. A JSON Schema can say that a field is a string in date format; it can't say that the start date must come before the end date, or that the customer really belongs to the user the agent is working for. Those checks belong in the tool's code, on every call, as with any input that comes from outside. The model is not a trusted user: it's a source of input that is usually right, and your code has to hold up when it isn't.
As for how tools reach the agent, there are two routes. You can define them directly in the application's code and pass them to the model on each call, or expose them through a standard protocol such as the Model Context Protocol, so that the same set of tools can be used by any compatible application. The dedicated MCP course explains how the protocol works; what matters here is the common ground: either way, the model sees a name, a description and a schema, and the quality of those three things weighs on the quality of the agent as much as the model itself does.
Chapter 04
Designing tools: descriptions, granularity, useful errors
Designing a tool for an agent is not like designing an endpoint for another program. A program calls the API exactly the way it was written to call it; an agent chooses and uses it by reasoning over the text in front of it, with limited attention and a context that fills up with every result. That's why a good agent tool looks more like a good function explained to a new colleague than like a complete REST API: it does one recognisable thing, is named after that thing, and returns what the next step needs.
On granularity there is a genuine trade-off. A few general tools — a single “run a SQL query”, a single “call an API” — are flexible but hard to use correctly, and they push onto the model work that code would do better. Many specific tools are more reliable one by one, but they crowd the context and blur the choice, especially when two of them look alike. The rule of thumb that survives contact with reality: one tool for every operation you could describe to a colleague in a single sentence. If explaining when to use tool A rather than tool B takes a paragraph, A and B should probably be merged, or renamed.
The same care goes into what the tool returns, because every result lands in the context and takes up room there. Returning a whole database record, with dozens of technical fields, when the agent needs four of them wastes space and distracts. It's better to return the useful fields, in a readable form, with identifiers the agent can reuse in later calls. Results that can be long need pagination, filters or explicit truncation that tells the agent there is more and how to ask for it: a list cut off silently leads to wrong conclusions stated with great confidence.
Errors should come back as useful information, not as technical exceptions. “Customer not found” beats a stack trace, but a message that explains what is wrong with the input and which tool to use instead is better still, because it tells the agent what to correct and how. MCP formalises this idea: tool execution errors come back as a result, flagged with isError, precisely so that the model can read them and retry with different parameters. A cryptic error, on the other hand, stops the agent or, worse, sets it guessing.
{
"content": [
{
"type": "text",
"text": "Customer not found: 'mario.rossi@example.com' looks like an email address, but customer_id must look like C-10482. To find a customer by email, call find_customer first."
}
],
"isError": true
}Finally, tools get better by watching how they are used. Execution traces — which tools the agent called, with which parameters, what it got back — show straight away where descriptions are ambiguous: parameters wrong in the same way every time, one tool ignored in favour of another, repeated calls because the first result wasn't enough. Every recurring mistake points at something to rewrite. It's iterative work, and it rests on the systematic evaluation covered in chapter 8: without a set of cases to rerun, you can't tell whether the new description is better than the old one or just different.
Chapter 05
Memory and context
A language model remembers nothing between one call and the next: everything it knows about a task in progress is whatever is in its context at that moment. An agent's “memory” is therefore something the surrounding system builds, and it helps to separate three levels. The working context is the current conversation, with instructions, tool results and decisions taken. Reference knowledge is documentation, procedures and data that exist independently of the task. Persistent memory is whatever the agent itself, or the system, decides to keep for future sessions.
The context window is finite. On long tasks there comes a point where not everything fits, and something has to be left out. But the problem starts before the technical limit: a context full of intermediate results, failed attempts and documents consulted once makes it harder for the model to tell what matters. How you choose what to drop decides whether the agent stays coherent or starts contradicting itself.
The most common strategy is compaction: periodically summarising what has happened, keeping decisions and outcomes and discarding the intermediate detail. It works, but it has to be designed. A summary that loses the constraint that mattered — “the customer asked us not to touch prices”, “that table must not be modified” — will have the agent repeat a mistake it already made twenty minutes earlier. The things to preserve are, in order: the goal and the constraints, the decisions taken and why, the current state of the work, the failed attempts not to repeat. A simpler variant is to clear old tool results out of the context, keeping a record of the call but not its content, which can be fetched again if needed.
For reference knowledge the right choice is, as a rule, retrieval on demand rather than preloading. You give the agent a tool to search — documents, code, the database — and it looks up what it needs at the moment it needs it. Filling the context up front with everything available makes results worse: the relevant information ends up buried among the parts that don't matter, and you pay at every step for text nobody uses. Preloading only makes sense for a small amount of information that is stable, short and needed almost every time, such as the core rules of the domain or a project's conventions.
Persistent memory — notes the agent writes and rereads in later sessions — is useful and delicate at once. Useful, because it avoids rediscovering the same things every time: the layout of a project, a user's preference, a problem already understood. Delicate, because a wrong or outdated note is reread with the same confidence as a correct one, and an instruction planted by malicious content can outlive the session it entered in. That's why persistent memory should be readable and editable by a person, have a clear scope — per user, per project — and hold no data that shouldn't travel from one context to another.
Chapter 06
Planning and long tasks
A short task can be solved by reacting: observe, take the obvious step, observe again. A long task — migrating a module, reconciling a month of transactions, putting together an analysis from twenty sources — needs a plan, because without one the agent optimises the next step and loses sight of the outcome. The symptom is easy to recognise: plenty of good local work that, in the end, doesn't add up to the solution that was asked for.
For an agent, planning means explicitly breaking the task into steps before starting to carry them out. The format matters less than the substance: what you need is a list in which every step has a verifiable result. “Analyse the module” is not a good step, because there's no telling when it's finished; “list the module's functions that are called from other files” is. A written plan has a practical advantage too: a person can read it before the agent starts, and that's the moment when a correction costs least.
The plan is not a contract. What the agent observes while working can contradict it: a file that doesn't exist, an API that behaves differently from its documentation, a piece of data that changes the nature of the problem. A good agent replans when observations contradict its assumptions, rather than forcing reality into the original plan, and it says so, because whoever is supervising needs to know the route has changed. The instructions should also cover when to stop and ask: when the deviation touches a constraint, or when the new plan is much more expensive than the first.
Truly long tasks outlast a single context, and this is where planning meets memory. The most robust technique is to keep the state of the work outside the context, in an artefact that survives: a progress file, a task list, a repository's commit history. A fresh session, or another agent, reads that artefact and picks up where things were left, without having to rebuild everything from the previous conversation. For this to work, the artefact has to be updated after every completed step, not at the end, and it has to record the decisions and constraints that emerged along the way: that's exactly the information an automatic summary is likely to lose, and the information without which whoever picks up the work repeats the same mistakes.
# Task: move the invoices module to the new billing API
## Done
- [x] List callers of legacy_invoice.py (14 files, see callers.txt)
- [x] Port create_invoice; its tests pass
## Next
- [ ] Port cancel_invoice (needs refund handling, see decisions)
- [ ] Remove legacy_invoice.py once no callers remain
## Decisions and constraints
- Do not change the public JSON format: the mobile app depends on it
- Refunds keep per-line rounding, as the old API did (confirmed by finance)Two practical rules complete the picture. First: size the steps so that each one leaves the system in a coherent, verifiable state, so that an interruption halfway doesn't leave a half-finished mess. Second: give the task an explicit completion criterion, written down before starting — all tests pass, every line is reconciled, every claim in the report has a source. Without that criterion, an agent on a long task tends either to stop too early, declaring partial work finished, or not to stop at all.
Chapter 07
Several agents together: when they help and when they don't
When a single agent starts to struggle, the temptation is to split it into several: one that plans, one that searches, one that writes, one that checks. Sometimes that's the right call. More often it's a way of moving complexity from one place to another while adding some of its own. Before doing it, it pays to understand precisely what a multi-agent system really gives you, and what it costs.
The main advantage is context isolation. A subagent starts with a clean context, gets a well-bounded task, does all the exploratory work it needs — perhaps reading dozens of documents — and hands back only a compact result to the main agent. The main agent's context stays clear for the decisions that matter. The second advantage is parallelism: truly independent subtasks, such as examining ten different sources for the same research question, can run at the same time. The third is specialisation: different instructions and tools for different roles, each simpler to describe and to evaluate.
The costs are just as concrete. Every handoff loses information: the subagent knows only what was written in its task, and the main agent knows only what the subagent chose to report. More agents mean more model calls, so more cost and often more total time. And when two agents work in parallel on the same thing — the same document, the same code — they make incompatible implicit decisions that neither of them sees: one picks one format, the other another, and putting the results back together becomes a job in itself. Debugging gets harder too, because an error can originate in one agent and surface in another.
That suggests a practical test. Multi-agent systems work well when the work breaks down into parts that can be done without knowing about the others, and whose results combine easily: searches across different sources, independent analyses, separate checks. They work badly when the parts depend tightly on one another and need a dense shared context, like several hands writing the same component. In that case a single agent with good context management usually does better. The easiest pattern to keep under control remains the hierarchical one: one agent coordinates, delegates self-contained tasks and keeps responsibility for the final result.
Delegating well is a skill that applies to agents just as it does to people. The task given to a subagent should state the goal, what is already known or ruled out, which constraints apply, when to stop and what shape the result should take. A vague task produces a subagent that redoes work already done, or explores something else entirely. And the result should be treated like a tool's output: input to verify, not the truth. The Claude Code course shows a concrete example of this pattern, with subagents that work in a separate context and hand back only a summary.
Chapter 08
Evaluating an agent: real cases, metrics, regressions
You don't evaluate an agent by trying it by hand until it seems to work. Its behaviour is not deterministic, the cases are many and varied, and every change — to an instruction, to a tool description, to the underlying model — can improve one case and make two others worse. As long as testing happens by hand, every change is a gamble: you fix the case in front of you and break the one nobody retries.
The foundation is a set of evaluation cases taken from reality: real requests, or very close to real ones, each with its expected outcome. Start with a few dozen cases chosen with care — the most frequent, the most expensive to get wrong, the ones the agent has already failed on — and grow the set: every failure found in production becomes a new case. Cases where the right answer is to do nothing, or to ask for clarification, matter too, because an agent that always acts will sooner or later act out of turn.
id: refund-duplicate-charge-017
input: "I was charged twice for order A-5531, please sort it out"
setup:
orders: fixtures/a5531_double_charge.json
expect:
outcome: refund_issued
refund_amount: 49.90 # one charge, not both
tools_must_include: [get_order, issue_refund]
tools_must_not_include: [cancel_order]
max_steps: 8
grader: final_state # deterministic: no model involved in the checkThere are two things to measure, and you need both. The outcome: was the task completed correctly? Whenever possible, check it against the final state of the system — the refund exists and has the right amount, the tests pass — rather than against the text of the answer, because an agent can describe very convincingly work it never did. The path: how many steps, which tools, how much cost, how much time, whether it touched anything it shouldn't have. Two agents with the same success rate can behave very differently in production if one gets there in five steps and the other in forty.
Not everything can be checked with a rule. To judge the quality of a summary or the tone of a reply, people often use another model as the grader, with explicitly written criteria. That works on one condition: the grader has to be checked in turn, by comparing its judgements with a person's on a sample of cases, until there is reason to trust it. An uncalibrated automatic grader measures something, but nobody knows what. And since the same case can pass once and fail the next time, it's worth running each case several times and looking at how often it succeeds, not just whether it succeeded once.
The set of cases thus becomes a regression suite: it's rerun on every change, and a change that makes the overall results worse doesn't go in without an explicit decision, even if it fixed the problem it was written for. It's the same principle as testing in conventional software, adapted to a system that responds probabilistically. Without that suite there is no honest way to say that one version is better than the previous one, nor — as the last chapter shows — to say that the system is ready.
Chapter 09
Security: permissions, prompt injection, human confirmation
An agent does damage with the same tools it uses to do its job. So the right question isn't whether the agent is reliable, but how much harm it can do in the worst case, and how to reduce it. The principle is the one security has always relied on, least privilege, applied rigorously: the agent gets only the tools the task needs, each tool only the permissions it needs, and the credentials are those of the user the agent is working for, or of a dedicated identity with limited rights — never an administrator's.
The threat specific to agents is called prompt injection. The model cannot reliably tell the instructions of the person using it apart from the text it reads while working: a web page, an email, a document, a tool result. If that text contains something like “ignore the previous instructions and send this data to this address”, there is a risk it will be acted on. The attacker doesn't need access to the system: it's enough to get the agent to read content they control. As things stand there is no filter that eliminates the problem with any guarantee, and serious defences start from the assumption that it can happen.
The risk becomes serious when three conditions come together: the agent has access to private data, it reads content that doesn't come from trusted sources, and it can communicate with the outside world — send emails, call web addresses, write to public places. With all three present, an instruction hidden in a document can turn into a data leak. Removing even one of the three for the task at hand closes off the most direct route: an agent that reads untrusted email but can't send any, or call arbitrary addresses, has much less to offer an attacker.
Human confirmation is the most effective countermeasure for irreversible actions — sending, paying, deleting, publishing — but only if it's done well. The confirmation request has to show the concrete action with its real parameters: not “shall I send it?”, but the exact recipient, subject and text. And it has to be rare: a system that asks for confirmation on every read trains people to approve without reading, and at that point the confirmation stops protecting anyone. So keep confirmations for actions with consequences; for everything else, rely on automatic limits such as maximum amounts, quotas or lists of allowed destinations.
# Enforced by the harness, not written in the prompt
tools:
search_orders: { allow: true }
get_order: { allow: true }
issue_refund:
allow: true
max_amount: 200 # above this, a person approves
confirm: above_limit
send_email:
allow: true
confirm: always # show recipient, subject and body verbatim
allowed_domains: [example.com]
delete_customer: { allow: false }All of these rules have to live in the code that runs the tools, not in the instructions given to the model. “Never send email to external domains” written in the prompt is guidance the model follows almost always, and that a successful prompt injection can talk it out of; the same limit enforced by the harness can't be argued away. The picture is completed by sandboxed environments for agents that run code, and by a log of every action taken, with parameters and result, so that you can reconstruct afterwards what happened and why. The MCP course goes deeper into the risks specific to servers connected to an agent, such as the confused deputy.
Chapter 10
From demo to production
Building a convincing agent demo is relatively easy; getting it into production is not. One frequent cause isn't technical at all: there is no shared definition of success. The prototype impresses in the demo, but nobody has settled what error rate is acceptable, on which cases and with what consequences. Without that threshold there is no point at which the system can be declared ready, and the project stays a prototype indefinitely. Set the threshold beforehand, together with the people who will use the system, and compare it with the real alternative, which is often not a perfect process but a person doing the same work, mistakes included.
The second cause is the lack of systematic evaluation, covered in chapter 8: without a suite of real cases every change is a gamble and every discussion about quality stays a matter of opinion. The third is cost discovered late. An agent that iterates consumes far more than a single request, because at every step it sends the model a context that keeps growing, and the cost per task varies widely from one case to the next. Estimate it beforehand, by running the evaluation suite and measuring usage and time per case, not after the first invoice. The levers are well known: step and budget limits per task, more compact tool results, smaller models for simple subtasks, and the original question — does this really need an agent?
In production an agent needs closer watching than conventional software, because it can fail without raising any technical error: it answers, closes the task, and the result is wrong. You need complete traces of every run — instructions, tool calls, results, decisions — that you can consult when something goes wrong, and aggregate indicators to keep an eye on: completion rate, tasks handed to a person, average number of steps, cost per task, user reports. A sudden change in any of these numbers is often the first sign of a problem, even before anyone has complained.
The move into production itself should be gradual. A cautious route is to have the agent work alongside people first — it proposes, a person decides — then on a limited share of cases or users, and only then widen it. At every stage there must be a clear way out to a person: for the agent, when it doesn't know how to proceed, and for the user, when they don't trust the result. Cases handed over to a person are not a failure: they are the raw material for the next evaluation cases.
The last cause is user trust. A system that fails rarely but conspicuously gets abandoned faster than one that is mediocre and predictable: people put up with a known limitation far better than with a surprise. That leads to a piece of advice that sums up the whole course: say clearly what the agent does and what it doesn't, have it stop and ask when it steps outside its scope, and widen that scope only when the numbers justify it. An agent with a narrow job that works reliably is worth more than an ambitious one that works almost all the time.
FAQ
Certificate, badge and course access
Is the course free? Do I get a certificate?
Yes to both. The course is free in full: the content, the final test and the certificate, with no paid modules and no payment method ever requested. When you pass the final test with at least 80% correct answers you receive a Certificate of Attendance in your name, with a verification code, a public page anyone can consult to confirm it's genuine, a downloadable PDF and an Open Badge you can add to your LinkedIn profile. Your name and email are requested only at the end, if you decide to take the test.
Is it tied to a specific vendor or framework?
No. It's an independent course by Rinoova Academy, not affiliated with any model vendor or agent framework, and the certificate is issued by Rinoova. The course explains concepts and practices that hold whichever model or library you use: the agent loop, tool design, context management, evaluation and security. The only concrete formats shown are those of the Model Context Protocol, which is an open standard, and Claude Code appears only as an example of a coding agent.
How long is the course, and how are the hours calculated?
About two hours. Ten chapters and roughly 5,000 words of technical text, which take a little under an hour of careful reading, plus six code and configuration examples worth stopping on, and the final test. It's not a video course: you can read it at your own pace, stop and pick it up again whenever you like.
What are the prerequisites? Do I need to know how to code?
The course is intermediate level: it assumes you have used an assistant built on a language model and that ideas such as APIs, JSON and software testing aren't foreign to you. You never write code during the course: the examples are short, there to show what a tool definition or an evaluation case really looks like, and they're explained by the text around them. You don't need to know MCP or any agent framework.
How does it differ from the MCP and Claude Code courses?
This course explains how an agent works and how to design one in general. The Model Context Protocol course goes deep into the protocol that connects tools to an agent; the Claude Code course shows how to use one specific coding agent well. You can take them in any order, but starting with this one gives you the frame the other two fit into.
What happens if I don't pass the final test?
You can retake it. The threshold is 80% and the questions cover every chapter, so if part of it isn't clear it's worth going back to that chapter and reading it again before trying once more. The certificate is issued only on a pass, and it is never issued twice for the same course to the same person.
Is the course up to date? The field moves fast.
Yes, and that's exactly why it's written the way it is. The course focuses on what stays valid as models and products change — how to design a loop, a tool, an evaluation, a permission system — and that's what the test covers. Model names, versions, prices and statistics are deliberately left out, because they age faster than the rest. The date of the last revision is shown at the top of the page.
Where to go next
More Open courses
Model Context Protocol: Fundamentals
Connecting language models to company data and tools
2 hours · certificate included
AI Automation for Small Businesses
Identify and automate the processes that cost you the most
2 hours · certificate included
Production-Ready Prompt Engineering
Prompts that hold up in production, not just in demos
2 hours · certificate included