These are the 12 resources I’d send anyone asking how to learn AI agents in 2026: the primary-source canon from Anthropic, OpenAI, Google, Microsoft, and LangChain, plus the two standout free courses. Every entry is a real engineering reference or curriculum from the people building the agent ecosystem, not a tutorial-of-tutorials. Use this as the syllabus; the rest of the AI Agents category on Iqraa covers the hands-on builds.
The list is grouped by learning path: start with fundamentals to set the mental model, move into frameworks and SDKs to pick a tool, study patterns and architecture to compose agents that don’t fall over, and finish with courses if you want a full structured pass. Skip around if you already know which layer you’re weak on. The sections are independent.
Fundamentals: the mental model
Two resources set the vocabulary everyone else uses. Read these first.
Effective Context Engineering for AI Agents (Anthropic). The single best plain-English write-up of what “context engineering” actually means once you stop saying “prompt engineering.” Covers context window budgeting, tool-output hygiene, retrieval-vs-injection trade-offs, and how to keep an agent from drifting as its working memory fills up. If you’ve ever had a long-running agent degrade after step 6, this explains why.
AGENTS.md (community spec). The emerging open standard for declaring “this codebase is agent-ready”: what an AI coding agent should read first, which commands are safe, which files are off-limits, what tests it should run. Read it less as a tutorial and more as a spec you’ll eventually adopt in your own repos. The closest thing agents have to a package.json.
Frameworks and SDKs: pick a tool
Four SDK-grade options. Don’t learn all four. Pick the one that matches your platform.
OpenAI Agents SDK docs, from OpenAI (repo openai/openai-agents-python). The successor to the experimental Swarm framework. If you’re on OpenAI’s API and want agents, tools, handoffs, guardrails, and tracing without a third-party framework, this is the canonical reference. The docs site is unusually good. Work through the examples in order and you’ll have a real agent running in an afternoon.
Google Agent Development Kit (ADK), from Google (repo google/adk-python, ~21k stars). A framework-agnostic agent runtime designed for Vertex AI and Gemini, with bidirectional streaming, multi-agent orchestration, and built-in evaluation. Pairs naturally with Google Cloud, but the runtime itself is open source and model-agnostic. If OpenAI’s SDK is the simplest possible agent loop, ADK is the production-grade one.
How and when to build multi-agent systems (LangChain). The honest architectural answer to a question every team asks too late. When does single-agent-plus-tools stop working? When is a multi-agent supervisor pattern worth the complexity? LangChain has shipped enough production agents to have real data. Read this before you decide your system “needs to be multi-agent.”
Build an Agent tutorial (LangChain). The canonical hands-on tutorial for LangGraph, the graph-based agent runtime. If you’ve never built an agent and want to start, this walks through one end-to-end. Pair it with LangChain’s Academy course for the full structured pass.
Patterns and architecture: compose agents that don’t fall over
How to design systems of agents, not just one agent. The hardest layer to learn, and the most underserved by free material.
Multi-Agent Research System (Anthropic). The architectural write-up of how Anthropic built the multi-agent system that powers their deep research product. The trade-offs they document (lead agent + subagent isolation, context passing, parallelism, evaluation) are the trade-offs every multi-agent system makes. This is the rare primary source on production multi-agent design.
Writing Effective Tools for Agents (Anthropic). Tools are where most agent projects fail. This is the field guide: how to name tools, how to shape the input schema so the model actually uses it, how to handle errors inside tool code, when one big tool should be three small ones. Read this before you write your first MCP server.
Google Cloud for Startups: AI Agents (Google Cloud). Less engineering-deep than Anthropic’s pieces, but useful for the build-vs-buy decisions specific to a startup: managed agent services vs rolling your own, cost projection at scale, when to commit to a cloud’s native agent runtime. Skim the table of contents; read what applies to your stage.
Azure AI Foundry Agent Service (Microsoft). The docs surface for Microsoft’s hosted agent runtime (formerly Azure OpenAI Service agents). Skip the marketing layer; the Agent orchestration patterns section under concepts is the useful part: the standard patterns (single agent + tools, supervisor + sub-agents, parallel fan-out) rendered as Azure Foundry configurations. Translateable to any stack.
Courses and curricula: full structured learning
Two free courses that turn the articles above into a sequenced curriculum.
AI Agents for Beginners (Microsoft). 70,336 stars. 18 lessons covering the agent design space: intro and use cases, agentic frameworks compared, design patterns (ReAct, reflection, tool use, multi-agent), evaluation, integration. Every lesson ships a written README, a short video walkthrough, and Python code samples against Microsoft Agent Framework. We have a full Creator Picks spotlight on it here.
MCP for Beginners (Microsoft). 16,834 stars. We have a full Creator Picks spotlight on it here. The Model Context Protocol-specific sequel: a curriculum for building MCP servers and clients across .NET, Java, TypeScript, JavaScript, Rust, and Python. MCP is becoming the default tool layer for agents; this is the free, vendor-neutral curriculum that gets you fluent.
How to use this list
If you’re new to agents, the shortest path is: read Anthropic’s Effective Context Engineering + Writing Tools for Agents, do Microsoft’s AI Agents for Beginners course end-to-end, then build one real agent against whichever SDK matches your platform (OpenAI Agents SDK if you’re on OpenAI, Google ADK if you’re on Gemini, LangGraph if you need model-agnostic portability). Skip multi-agent patterns until you’ve shipped a single-agent system. Most projects don’t need them and the complexity cost is real.
If you’re already building agents and want depth, jump straight to Anthropic’s Multi-Agent Research System and the LangChain How and When post. Those two pieces will sharpen your architecture decisions more than any course.
The primary-source canon for learning AI agents in 2026 is small enough to read in a week and dense enough to keep you building for months. Bookmark this page, work the fundamentals first, and pick one course rather than collecting all of them.