ed-donner/agents: a course repository for building AI agents with six frameworks

What ed-donner/agents is for, and who it is not for

The README describes a six week journey to code and deploy AI agents, and the repository is the working material for that course. It is aimed at people who already write code and want to see several agent frameworks side by side rather than read one vendor's documentation. The top-level directories follow that plan: 1_foundations, 2_openai, 3_crewai, 4_langchain_langgraph, 5_agent_frameworks and 6_mcp, with guides, setup, assets and community_contributions alongside them.

If you want a package to import into an existing service, this is the wrong repository. Nothing here is published to a package index under the name agents; pyproject.toml declares version 0.1.0 and a dependency list, which is a course environment, not a distributable library. The value is in the notebooks and the setup instructions, and the cost is that you adopt the author's choices about which frameworks to learn and in what order.

How the repository is organised across the six frameworks

The structure is the mechanism. Each numbered directory corresponds to a stage of the course, so the data flow is a reader moving from foundations through one framework at a time. 2_openai covers the OpenAI Agents SDK, 3_crewai covers CrewAI, 4_langchain_langgraph covers LangChain and LangGraph, and 5_agent_frameworks collects the rest, which the README names as Google ADK and Pydantic AI. 6_mcp is the Model Context Protocol material. The guides directory holds the supporting notebooks, including an introduction at guides/01_intro.ipynb and a notebook on APIs and Ollama at guides/09_ai_apis_and_ollama.ipynb.

The dependency list in pyproject.toml tells you how broad that spread is. It includes openai-agents with the viz extra, crewai, langchain, langgraph, langgraph-checkpoint-sqlite, google-adk with the a2a and mcp extras, pydantic-ai-slim with the mcp and openai extras, agno with the mcp extra, strands-agents with the openai extra, deepagents, agent-framework-core, agent-framework-openai and langchain-mcp-adapters. Supporting entries cover fastapi, uvicorn, gradio, plotly, pypdf, python-pptx, wikipedia, requests and rich. That is a single environment carrying competing agent runtimes, and it is the main reason to expect dependency resolution to be the first thing you fight.

Setting up the course environment and opening the first notebook

The README does not give install commands itself. It points Windows users to setup/SETUP-PC.md, Mac users to setup/SETUP-mac.md and Linux users to setup/SETUP-linux.md, and says the API key setup happens in those instructions. The repository also carries .python-version and uv.lock, and pyproject.toml sets requires-python to >=3.12, so the environment is built with uv on Python 3.12 or newer.

The README gives one concrete environment variable in its prose: it asks you to be sure to have fun with the course. That is not configuration, so the honest answer is that this repository documents no install command in the files available here. Follow the setup file for your platform, then open the first guide notebook, guides/01_intro.ipynb, in your editor or notebook server.

Before any notebook that calls a frontier model, you need an API key. The README says the key is set up in the SETUP instructions, and python-dotenv is in the dependency list, which points to a .env file in the project root. The course also documents cheaper and free options in guides/09_ai_apis_and_ollama.ipynb, so if you do not want to spend on API calls, read that notebook before configuring a paid provider.

One warning the README gives directly: be sure to monitor your API costs. For OpenAI it links the usage dashboard at platform.openai.com/usage. Notebooks that loop over agent turns can spend more than a first estimate suggests.

Where this repository will frustrate you

The dependency list is the first limitation. Pinning openai-agents, crewai, langchain, langgraph, google-adk, pydantic-ai-slim, agno, strands-agents and agent-framework in one environment means a version bump in any one of them can break resolution for all of them. uv.lock exists precisely because that resolution is fragile, and a lockfile only helps if you use it.

The second is that the material is a moving target by design. The README states this is the refreshed version from Summer 2026 with the latest tools, models and techniques, and links three pages about what changed, why, and how to upgrade code mid-course. There are no releases in the repository, so there is nothing to pin a course run against except a commit. If you are halfway through week three and the author pushes an update to a notebook you depend on, you have to reconcile that yourself.

The third is scope. This teaches agent construction with hosted and local models. It does not give you deployment infrastructure, evaluation harnesses or cost controls beyond the advice to watch your usage dashboard. If your goal is a service in production, the notebooks show the shape of an agent loop but leave the operational parts to you.

How it compares with building directly on one framework

The obvious alternative is to skip the course repository and work from one framework's own documentation, for example the OpenAI Agents SDK or LangGraph on its own. The difference is breadth against depth. A single framework's docs go further into that framework's abstractions, its tracing, its deployment path. This repository instead puts several of them in one environment so you can compare how each expresses an agent, a tool call and a handoff. The pyproject.toml is the evidence: it installs openai-agents, crewai, langgraph, google-adk, pydantic-ai-slim, agno and strands-agents together, which no production project would do.

A second alternative is a single-framework tutorial series that never touches MCP. The 6_mcp directory and the langchain-mcp-adapters and mcp extras in the dependency list are the distinguishing part here, because they treat tool connectivity as its own topic rather than an afterthought. If your interest is specifically how agents reach external tools, that section is the reason to pick this repository over a general course.

Maintenance, licence and what an upgrade costs you

The repository is not archived and the last push was on 2026-09-19, three days before this writing, so the material is current. There are no retrieved releases, so upgrades are not versioned. The README's own upgrade guidance is a set of linked pages rather than a changelog in the repository, and the course has already gone through one full refresh. Practically, an upgrade means re-reading the setup file for your platform, re-resolving the environment from uv.lock, and checking whether the notebooks you were working through changed.

The licence is MIT, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are included. That covers the code and notebooks in the repository. It does not cover the third-party frameworks the environment pulls in, each of which carries its own licence, and it does not cover the course videos or written material hosted on the author's site. Check those separately if you plan to reuse them. This is a description of the licence text, not legal advice.

Editorial conclusion

Use ed-donner/agents if you want a guided, notebook-first path through several agent frameworks and are willing to spend a small amount on model API calls or point the code at Ollama. Do not use it as a runtime dependency or a production template: it is a course workspace whose dependencies move with each refresh, and there is no release history or changelog to pin against. Before you start, open pyproject.toml and confirm that Python 3.12 or newer is acceptable on your machine, then read the setup file for your operating system.

Frequently asked questions

Official sources

1. ed-donner/agents on GitHub
2. Issues
3. License: MIT
4. README