Where to go deeper
The reading list turned into a route: which talks, courses, essays, books and papers to take in, in what order, and how to keep up once you have read them.
Anyone who wants to understand agents properly, from a complete beginner to an engineer. Nothing is assumed at the start; the later groups expect some programming or mathematics, and each part says so.
- A week-by-week path through the list, easiest first
- What to read if you only have one hour
- What each group teaches, what to start with in it and what level it assumes
- Where first-hand news appears: specifications, changelogs, vendor documentation and evaluations
How to use this list
The list has six groups, from short videos to research papers. Follow the path below from the top, and skip ahead only when a part feels easy.
The groups run from least to most demanding: short talks, longer talks, free courses, essays by people who build agents, books, and the papers the field rests on. Videos and courses carry a level (beginner or intermediate), and videos a length. You do not need all of it. Most people who build with agents read the essays closely, take one course with code, and dip into the rest when a question comes up.
Read actively. After each item, write down in two or three sentences what it claimed and what evidence it gave. Where an essay gives a rule (start with the simplest design, keep tool definitions short, test on real failures), try it on a small task of your own, such as an agent that finds three flights to Lisbon within a budget and writes them into a spreadsheet. A rule you have tried sticks; one you have only read does not.
Choose by what you want to do. If you will use agents at work rather than build them, the first two weeks are enough, plus the short course on skills. If you will build them, the courses with code, the evaluation course and the book AI Engineering matter most. If you want to understand the models themselves, spend your time on the long talks, the transformer chapters, the from-scratch books and the papers. Dates matter throughout: the talks from 2023 and 2024 describe models that have since been replaced, but the mechanisms they explain (next-token prediction, the loop, tool calls) still hold.
Watch: start here
Five short talks that explain what a language model is and what turns one into an agent. No background is needed.
This group gives you the picture before the details. Start with 3Blue1Brown's eight-minute primer: it shows a model as a machine that predicts the next token, the small piece of text it works in, and how pre-training on vast amounts of text and then training on human feedback turn it into an assistant. Andrej Karpathy's one-hour talk covers the same ground more slowly and adds what matters for agents: tool use, the model as the core of a new kind of operating system, and security.
The other three talks are about agents. Karpathy's Software Is Changing (Again) describes applications with partial autonomy, where the person can adjust how much the model does on its own. Andrew Ng's talk names four design patterns (reflection, tool use, planning and multi-agent collaboration) that recur across the whole field. IBM's explainer places agents in the move from single models to compound systems that reason and act. Level: beginner throughout. Anything that stays unclear comes back in the next groups. If you watch only two, take the 3Blue1Brown primer for the model and Andrew Ng's talk for the agent; together they take under half an hour.
Watch: go deeper
Longer talks for a second pass: how models are trained and how the transformer works inside, then how engineers who build agents for a living approach the work.
Two kinds of talk sit here. Karpathy's Deep Dive into LLMs, about three and a half hours, follows the full training stack for a general audience, from pre-training to fine-tuning and reinforcement learning, and explains hallucinations and tool use from that angle. The two 3Blue1Brown chapters build up the transformer and attention visually, step by step. Watch them to understand why the model processes its whole input on every step, which is the root of most context costs; skip them if you only want to build.
The two talks by Anthropic engineers are short and practical. Tips for building AI agents covers the difference between agents and workflows, the anatomy of an agent prompt and common pitfalls; Barry Zhang's talk argues for keeping agents simple and for thinking from the agent's point of view, with only what it can see in its context. Watch them straight after the essay Building effective agents, which comes from the same authors. Level: intermediate; the transformer chapters help most if you remember a little linear algebra, but they explain as they go.
Free courses
Free courses that make you build: write a small agent, give it tools, then trace and test it. Most of them assume basic Python.
Reading about agents is not the same as debugging one, so take at least one course here. The Hugging Face AI Agents Course starts with agent fundamentals (tools, thoughts, actions and observations, the cycle behind the ReAct pattern), then implements them in three frameworks: smolagents, LlamaIndex and LangGraph. It plans three to four hours of work a week, assumes basic Python and some idea of language models, and offers free certificates. Microsoft's AI Agents for Beginners has 18 lessons with Python notebooks, from design patterns to MCP, memory, computer use and security; its samples use Microsoft's own agent framework and an Azure account.
The other three fill gaps. Evaluating AI Agents (DeepLearning.AI with Arize) teaches you to record a trace of a run and grade both its steps and its result, including with an LLM as judge. Claude Academy's Introduction to agent skills shows how to write and share skills and how they compare with sub-agents, hooks and MCP. Andrew Ng's Agentic AI course, free to audit, works through the four patterns from his talk plus evaluation, at an intermediate level. Order: one of the first two, then evaluation, then the rest as needed.
Whichever course you take, build its exercises around a task you care about rather than the sample task, and keep a log of what went wrong. The failures you record (a wrong tool chosen, a loop that never stops, a result too long for the context) become your first evaluation set, which is exactly where the evaluation course and the essays start.
Essential reading
Five essays from Anthropic's engineering team that practitioners cite more than anything else. They are short, free and the best value on this page.
If you read only one group, read this one, in this order. Building effective agents (2024) separates workflows, where code fixes the path, from agents, which choose their own steps, and names five patterns: prompt chaining, routing, parallelisation, orchestrator-workers and evaluator-optimizer. Its main advice, to start with the simplest design and add complexity only when it measurably helps, runs through every guide on this site. Effective context engineering treats the context window as a finite budget and explains compaction, structured notes, sub-agents and loading information just in time.
The next three are narrower. Writing effective tools explains how to design and test tools so that a model uses them well. Equipping agents with Agent Skills describes skills as folders of instructions and scripts, loaded through progressive disclosure. Demystifying evals for AI agents covers code, model and human graders, the difference between pass@k (at least one of k tries succeeds) and pass^k (all k succeed), and why 20 to 50 tasks drawn from real failures are enough to start. Level: beginner to intermediate; no code is needed to follow them, though they make more sense after one course.
Books
Books give a complete, ordered picture, from building applications on top of existing models to coding a model or an agent yourself from scratch.
Books are slower than essays but connect the pieces. For people who build products, Chip Huyen's AI Engineering is the one to start with: evaluation, retrieval (rag), agents, fine-tuning and deployment, all on top of existing foundation models. Hands-On Large Language Models by Jay Alammar and Maarten Grootendorst is a richly illustrated, practical tour of tokens, embeddings, prompting, retrieval and fine-tuning, with code.
The two from-scratch books are for readers who learn by writing code. Sebastian Raschka's builds a GPT-style model step by step, from attention to pre-training and fine-tuning. Build an AI Agent (From Scratch) does the same for an agent in Python without a framework: the loop, context, tools, memory, planning and evaluation. Russell and Norvig's Artificial Intelligence: A Modern Approach is the standard university textbook, organised around rational agents; read it for the older, broader meaning of the word agent, not for language models. Level: the from-scratch books assume working Python; the textbook assumes university mathematics. You need at most two: one for building on top of models, and one from-scratch book if you want to see every moving part of a model or an agent with your own eyes.
The research behind it
Five papers, in order of publication, that introduced the ideas behind today's agents. Read the abstract and the first figure first, and the whole paper only when you need the detail.
Each paper here started a line of work the field still follows. Attention Is All You Need (2017) introduced the transformer, the architecture of today's language models. The original retrieval-augmented generation paper (2020) paired a retriever with a generator so that answers rest on fetched passages. Chain-of-thought prompting (2022) showed that asking for intermediate steps improves multi-step reasoning. InstructGPT (2022) showed how training on human feedback turns a pre-trained model into one that follows instructions. ReAct (2022) interleaved reasoning with tool actions, which became the template for the agent loop.
Read them in three passes: the abstract, the first figure and the conclusion; then the method; then the experiments, only if you need to judge a claim. For a practitioner the main idea of each fits on a page. ReAct is the one to read in full if you build agents, because its worked examples show the thought, action and observation steps directly. Level: intermediate to advanced; the transformer and InstructGPT papers assume some machine learning, the others are readable with a general technical background. Remember their age: every one of them predates the models you use today, so treat the numbers in their tables as history and the ideas as the part that lasts.
How to keep up with the field
The field changes month by month. Follow the primary sources (specifications, changelogs, vendor documentation and evaluation results) rather than summaries, and check every claim for its date.
Most news about agents is second-hand. The fastest reliable route is to the documents that define things. Specifications have changelogs: the MCP specification publishes the key changes of each dated revision (the current one is 2026-07-28), the A2A specification carries a version number (latest release 1.0.0, October 2026), and the Agent Skills format has a short public specification. When a post says that a protocol now supports something, the changelog tells you whether it is in the core, an optional extension or only a proposal.
Vendor documentation and engineering blogs come second. The release notes of the harness you use tell you when a feature changed its name or behaviour; slash commands being merged into skills is one recent case. Read engineering posts for their numbers and the conditions behind them: who measured, on which tasks, against which baseline.
For claims about capability, look at evaluations rather than announcements. SWE-bench Verified is 500 coding tasks checked by human annotators. METR's time-horizon page reports the length of task, in expert human time, that frontier models complete half the time; it says it is no longer actively updated (last updated 8 September 2026). Public benchmarks age, and test items can leak into training data (benchmark-contamination), so the most useful evaluation is your own: 20 to 50 real tasks with clear pass criteria, run with an open-source framework such as Inspect, developed by the UK AI Security Institute and Meridian Labs, whenever a model or prompt changes.
A few careful writers save time. Simon Willison's blog tries out new releases and tags its posts by topic, such as prompt injection. Whatever you read, note the month: in this field a fact without a date is a fact you cannot use.
A routine that works: once a month, read the changelog of every specification you depend on and the release notes of your harness. Once a quarter, run your own evaluation set again on the current models, because a newer model can be better on average and worse on your tasks. And when a claim matters for a decision, open the primary source it cites before acting on it; summaries drop the conditions, and the conditions are usually where the claim stops being true.