What changed between the 2025 and 2026 editions
The six stages are the same. These are the shifts inside them that a 2026 learning plan should reflect.
Structured output is the default
Major model APIs can now constrain responses to a JSON schema. Learn to define the output contract first, then still validate values the schema cannot check.
Take away: A model call whose fields your code can trust or reject.
Build the application layerAgent frameworks have settled
LangChain and LangGraph both reached version 1.0 in late 2025, and model providers ship their own agent SDKs. Learn the underlying loop of state, tools and stopping rules before choosing one.
Take away: An agent you can trace step by step and stop safely.
Design a bounded agentMCP is a mainstream integration path
Many AI assistants and developer tools can now act as MCP hosts. The skill is no longer just connecting a server, but deciding what it exposes and who may call it.
Take away: A read-only server with tested access boundaries.
Understand MCP architectureLong context has not replaced retrieval
Larger context windows help, but retrieval still controls cost, freshness and which documents a user is allowed to see. Hybrid search and reranking are now standard tools.
Take away: Retrieval tests that run separately from answer tests.
Learn RAG through an exampleEvaluation is a core skill
Teams now expect a test set, tracing and regression checks before a change ships. Treat evaluation as part of every stage, not a final polish.
Take away: Evidence that a change improved quality rather than a single good demo.
Create regression checksCost and latency are design inputs
Reasoning models, prompt caching and model routing give more options and more ways to overspend. Measure tokens, latency and cost per task from the first prototype.
Take away: A cost and latency record for each version of your project.
Create the service interface
How the six stages fit together
Each stage builds on the previous one: Python and software habits, then reliable model calls, then retrieval, then tools and agent workflows, then MCP integration, then deployment and hardening. The detailed syllabus for each stage, with a milestone you can demonstrate, is below.
MCP is an integration option, not a prerequisite for every application. Learn its host, client and server boundaries when your project needs reusable capabilities that more than one assistant or tool can call.
Started with the 2025 edition? Audit before upgrading
You do not need to restart because the year changed. Record how your project starts, what input it expects and which external services it calls. Identify where credentials belong without printing or committing them.
Try a normal request, an empty input and a simulated provider failure. Keep the observed results, then compare installed SDK and framework versions with their current documentation and upgrade one dependency at a time.
Worked example: bring a 2025 RAG demo up to date
Suppose a fictional demo answers one sample question but has no source identifiers. First add traceable document records and tests for an exception and an unanswered question.
Then apply the 2026 changes in order: a schema for the answer and its citations, a retrieval test set, and a cost and latency log. Only after that consider replacing the retrieval package, so you can see whether the real gap was the library, source preparation or missing evaluation.
The six-stage syllabus, 2026 edition
What to learn in each stage, and the milestone that shows you can do it. Use the milestone roadmap to plan your pace. Progress is demonstrated by working milestones, not a fixed promise of mastery in a particular number of weeks.
- 1. Python foundations: functions, classes, modules, file I/O, JSON, environment configuration, HTTP APIs, exceptions and logging. Milestone: a script that calls a public API, handles an error and writes a validated response to a file. Experienced API developers can demonstrate these skills rather than repeat introductory lessons.
- 2. LLM APIs and prompting: messages and instructions, few-shot examples, structured outputs constrained to a JSON schema, tool schemas, reasoning-model settings, prompt caching, token usage and cost measurement. Milestone: classify fictional support tickets with a defined label set, validation and held-out tests. Check provider-specific settings instead of assuming every model accepts the same parameters.
- 3. Retrieval-augmented generation: embeddings, vector search, document loading, chunking, metadata filters, hybrid retrieval, reranking and evaluation. Explore a suitable library or database such as FAISS, Chroma or Pinecone without treating them as identical products. Milestone: a document assistant with citations, retrieval tests and an abstention path.
- 4. Agentic workflows: state, tools, routing, bounded loops, retries and human checkpoints. LangGraph (1.0 since late 2025), provider agent SDKs and multi-agent frameworks are implementation options, not prerequisites for every workflow. Milestone: a research assistant that gathers approved sources and produces a structured report, with action logs and a step limit.
- 5. Model Context Protocol: host/client/server roles, capability discovery, tool schemas, local and remote servers, authorisation and access boundaries. Milestone: a custom server exposing a read-only training database to a compatible client, with validation and denied-access tests. Do not connect a production database merely to complete a lab.
- 6. Deployment and hardening: FastAPI, containers, asynchronous I/O, timeouts, rate limits, logging, tracing, monitoring, evaluation in CI, cost tracking and review controls. Milestone: deploy a tested assistant to an appropriate environment with recovery instructions and observable failures. A deployed demo is not automatically production-ready.
Repair, extend or restart an older project?
| Situation | Approach | What to check |
|---|---|---|
| The project runs and its purpose is clear | Add tests, then extend it | Keep the working baseline |
| Dependencies no longer match the tutorial | Isolate and upgrade deliberately | Version-specific documentation and regression results |
| You cannot explain the copied code | Rebuild a smaller example | Clear inputs, outputs and failure handling |
Syllabus exercise
Map your skills against the 2026 syllabus
Use a fictional or public-data project and record which stages you can already demonstrate and the smallest next improvement.
What to produce
- A stage-by-stage checklist with evidence for each completed milestone.
- Three baseline tests for your current project.
- One scoped improvement and its measured result.
Acceptance checks
- Another person can follow the setup.
- Sensitive data is excluded.
- The improvement has observable evidence.
- Unresolved gaps are recorded.
This is an illustrative learning exercise, not a client case study or a measured outcome.
Common questions
How is this different from the AI engineering roadmap page?
This page lists what to learn in each of the six stages and what changed for 2026. The AI engineering roadmap page helps you plan the pace, review points and portfolio around that syllabus. Most learners use both: the syllabus for topics, the roadmap for planning.
Do I have to restart if I followed the 2025 edition?
No. The six stages are unchanged. Audit your project, keep what works and add the 2026 emphasis: structured outputs, evaluation, access boundaries and cost tracking. Upgrade one dependency at a time with tests in place.
Continue learning
Prefer a guided learning path?
Explore the live-online AI Engineering course, its prerequisites and portfolio work. Choose training based on the skills you need to practise, not a promised job outcome.
Explore the AI Engineering course →Sources and further reading
- Python — official language tutorial
- MCP — current architecture documentation
- LangGraph — stateful orchestration
Examples and decision frameworks are original teaching material. Product-specific implementation details should be checked against the version you use.