GyaanStack. Blog

Articles / agentsfree-resourcesroadmap

The best free resources to learn AI agents (2027 edition)

Twenty-two free guides, courses, papers and repos for learning AI agents, in the order I'd use them, from first loop to deep agents and evals.

By Raghunath · · 6 min read

There's more free material on AI agents than anyone could read. Most of it either repeats the same diagram of a loop calling tools, or it's a framework tutorial that dates the moment the API changes.

This list is the short version. I picked 22 resources from the GyaanStack agents and deep-agents subjects, which together hold about 875 links, and put them in the order I'd read them if I were starting today. I checked every link before publishing.

The order matters more than the list. Read the design guides before you pick a framework, and build one agent loop by hand before you let a library hide it from you.

Stage 1: understand what an agent is#

Start here even if you've used ChatGPT with tools. These four pieces give you the vocabulary everyone else assumes you have.

Building Effective AI Agents (Anthropic). The best single starting point. It separates workflows (fixed code paths that call a model) from agents (the model decides the next step), and names the common patterns: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer. Its main advice, to use the simplest thing that works, will save you weeks.

LLM Powered Autonomous Agents (Lil'Log). Older, but still the clearest map of the parts: planning, memory and tool use. It also links the research papers behind each part, so it doubles as a reading list.

A Visual Guide to LLM Agents. The same ideas as diagrams. Good if you think in pictures, or to review a few days after the two above.

A Practical Guide to Building Agents (OpenAI, PDF). A short business-facing guide: when an agent is worth building, how to design tools and instructions, and where to put guardrails. Useful for explaining agents to people who aren't engineers.

Stage 2: build one loop yourself#

Before any framework, write the loop: send messages, read a tool call, run the tool, append the result, repeat. It's about 50 lines of code. Doing it once makes every framework easier to read.

Let's build an agent from scratch (AI Engineer talk, video). Live-coding an agent loop with no framework. Watch it, then close it and write your own.

ReAct: Synergizing Reasoning and Acting in Language Models (paper). The paper behind "think, act, observe". You don't need every table, but read the method section so you know where the pattern came from.

Writing effective tools for AI agents (Anthropic). Many agent failures are really tool problems: vague names, overlapping tools, huge outputs. This covers how to name, scope and test tools, and how to let a model help you improve them.

neural-maze/agentic-patterns-course (GitHub). Four agentic patterns (reflection, tool use, planning, multi-agent) built from scratch in plain Python. Good practice after your first loop.

Stage 3: learn a framework, properly#

Pick one framework and go deep. Each of these courses is free.

Hugging Face Agents Course. The most complete free course: theory, then smolagents, LlamaIndex and LangGraph, with a final project and certificate. If you only take one course, take this one.

LangChain Academy. Free courses on LangGraph from the people who build it. LangGraph is widely used for agent work, so it's a sensible default.

AI Agents in LangGraph (DeepLearning.AI). A short course that builds an agent from scratch and then rebuilds it in LangGraph, which makes the framework's choices easy to see.

Large Language Model Agents MOOC (UC Berkeley). A full university course with lectures from people at the big labs. Watch selected lectures when you want depth rather than how-to.

Stage 4: context, memory and protocols#

Once an agent runs for more than a few turns, what goes into the context window decides whether it works.

Context Engineering for Agents (LangChain). A clear breakdown of the four moves: write context out, select what comes back in, compress it, and isolate it across sub-agents.

Context Engineering for AI Agents: Lessons from Building Manus. Lessons from a team running agents in production: keep the prompt prefix stable for caching, use the file system as memory, keep errors in context so the model learns from them.

What is the Model Context Protocol (MCP)? (official docs). MCP is the protocol most agent clients now support for connecting to tools and data. Read the intro, then build a small server (I wrote a walkthrough: MCP from zero).

a2aproject/A2A (GitHub). The Agent2Agent protocol, for agents talking to other agents. Read the README so you know where it fits next to MCP; you'll probably not need it on day one.

Stage 5: multi-agent systems and deep agents#

How we built our multi-agent research system (Anthropic). A rare honest write-up of a production multi-agent system: why an orchestrator with sub-agents helped, what it costs in tokens, and what went wrong.

Agents 2.0: From Shallow Loops to Deep Agents. Explains why simple loops fail on long tasks and what "deep" agents add: explicit planning, sub-agents, a file system and detailed system prompts.

langchain-ai/deep-agents-from-scratch (GitHub). Notebooks that build those deep-agent pieces one at a time: to-do lists, a virtual file system, sub-agents. Then compare with the deepagents library itself.

12-factor agents (GitHub). Principles for agents that survive production: own your prompts, own your context window, treat tools as structured output, keep control flow in your code. Read it before you design anything serious.

Stage 6: evaluate what you built#

An agent you can't measure is a demo. These two are where I'd start.

Demystifying evals for AI agents (Anthropic). How to grade agents: checking outcomes versus checking the path, code-based versus model-based graders, and how to build a task set.

τ-bench (paper). A benchmark where an agent must use tools while talking to a simulated user under a company policy. Worth reading for its idea of measuring reliability across repeated runs, not just one pass.

For a hands-on version, I wrote an eval harness for a tool-using agent that runs with no API key.

How I'd use this list#

  • Week 1: Stage 1 and Stage 2. Write your own loop with two tools.
  • Weeks 2–3: one course from Stage 3, start to finish. Rebuild your loop in that framework.
  • Week 4: Stage 4. Add memory and one MCP server to your agent.
  • After that: Stages 5 and 6 as your project needs them. Add evals before you add more agents.

Don't try to read everything. Twenty-two links is already a lot. Finish one course and one project before you go looking for more.

The full lists live in the GyaanStack agents (355 links) and deep agents (520 links) subjects. They're sorted into topics and updated daily.