oreilly-ai-agents, eighteen unpinned requirements and a date-bound Python

Eighteen requirements and not one version constraint

The requirements file has eighteen lines and no version numbers on any of them.

That is unusual for a repository people install repeatedly over the course of a training programme. Every one of these packages will move, and several of them move fast enough that a six-month-old environment will not resolve the same way.

One line is not a package name at all. It is a git URL pointing at an experimental agent framework maintained by OpenAI, with no tag or commit reference. An unpinned URL means the version you get today is whatever the default branch of that repository pointed at when you installed, and there is no way to ask later what you got.

The rest are ordinary names: a streaming library, two agent frameworks plus a tools companion, two search libraries, a notebook environment, three LangChain provider packages, a graph library, a dataset library, a plotting library, two more agent frameworks, a runtime, and a development kit.

For a course this is a deliberate simplification rather than an oversight. You are not installing a service, you are opening notebooks, and pinning eighteen packages across five competing frameworks would be a worse place to spend an afternoon.

Python 3.11 is requested with a phrase that dates itself

The setup section opens by telling you that at the time of writing you need a Python 3.11 environment.

That parenthetical is doing the work. It is an acknowledgement by the author that the pin is temporary and that the file will eventually be wrong, which is more honest than a bare requirement that looks permanent.

The instruction is specific rather than a floor. Not three or newer, not three point eight or newer, exactly 3.11. The environment is then created with the interpreter named explicitly, the activation command is given separately for Unix-like systems and for Windows, and the reader is told to confirm the virtual environment marker appears in the prompt.

The install instructions for the interpreter itself cover three platforms. A versioned formula for a package manager on macOS. A single command pair that installs the interpreter and its environment module on Debian-family systems. And a pointer to the official downloads page for Windows, with a note to tick the option that puts it on the executable path.

The Debian path is the one to check on your machine. It installs a specific point release without mentioning any additional package source, so on a distribution whose default repositories do not carry it you will need to look up where to get it.

The first step and the last check run the same command

The setup is written as two paths, and the longer one has a small redundancy at both ends.

The first path assumes you already have the interpreter and walks through six numbered steps: check the version, create a virtual environment, activate it, verify the version, install the requirements, and deactivate. Then a separate verification section at the bottom of the whole section prints the version command again.

Step one and the closing check are the same command with the same purpose. The only difference is that step one comes before anything has happened and the closing one comes after, which is a reasonable instinct for a tutorial and an unnecessary line for a reader.

The install step itself is a single command with no platform branching, which is the one place where the two activation paths differ and the instruction does not. Packages install the same way on Windows as elsewhere; only the activation command changes.

pip install -r requirements.txt

The last instruction in that block, deactivating, appears as step six of six. It is the one step in a setup guide that exists for tidiness rather than necessity.

Two search libraries and two generations of OpenAI agents

The requirements list contains duplicates of purpose, and reading them tells you which frameworks the material moves between.

There are two search packages. One is the long-standing DuckDuckGo client; the other is the successor package under a shorter name that the same project publishes. Both are installed, so whichever one a notebook imports will work.

There are also two generations of OpenAI's agent library installed. One is the experimental framework installed straight from its git repository. The other is the newer packaged SDK, and both have an introductory notebook.

The LangChain family is split by provider rather than duplicated: a community package, an OpenAI integration, and an integration for a second inference provider.

Two Google-related dependencies sit alongside each other for different reasons. One development kit has its own notebook with a built-in search tool and custom tools. The other is a search results scraping package with no notebook of its own named in the listing, which suggests it exists to support a specific exercise.

The duplication is not sloppiness. It is the cost of covering five frameworks in one environment so that a learner can run any notebook without installing anything first.

Four model families, one measurement of positional bias

The evaluation notebooks are the strongest part of the repository and they are the reason to read it beyond the framework intros.

One notebook measures how accurately different models choose the right tool, and quantifies the positional bias present in autoregressive models: the tendency to favour a tool because of where it appeared in the list rather than what it does. It is followed by four addendum notebooks extending the same measurement to a later version with distilled models, to a reasoning model, and to one open-weights family.

That is five notebooks on one finding. Whatever the conclusion, the author clearly wanted it checked against more than one model before putting it in a course.

A second thread runs in parallel. One notebook explores a rubric prompt for judging generated output, and notes the same positional problem when choosing between two agent responses. A longer follow-up goes deeper into how a model can be used as a judge of an agent's answers. A workflow evaluation notebook grades the retrieval example from the same section.

So evaluation appears three times in the index: for a retrieval workflow, for generated text, and for tool choice. That is a deliberate thread and it is unusual to see it woven through example code rather than left to a separate section.

Two notebooks live outside the repository

The notebook index links to files that are not in the tree, which tells you where the material is spread.

A chess notebook, described as two reason-and-act agents playing each other, is a hosted notebook link rather than a file in the repository. So is the notebook on building your own agent framework from the ground up.

Both are cases where the code is a Colab session that is easier to run in a hosted environment than to check out, and both are linked from the same section that points at the author's own small framework on another repository. That pattern is consistent: the two exercises that need a live interactive environment are the two that live outside, and everything else is checked in.

The rest of the multi-agent section is local. Three notebooks cover the patterns a reader would build first: parallel node execution with fan-out and fan-in, a dynamic network where agents route to each other through a generic handoff tool, and a supervisor that delegates to specialised sub-agents.

The same section also carries the framework the author wrote himself, with a hello-world notebook and a multimodal variant that adds image generation to the squad.

Five top-level entries and no licence file

The repository root is short enough to list completely, and one entry is missing.

There is a notebooks directory, a requirements file, a readme, an images directory, and a streamlit directory. The streamlit directory is referenced from the CrewAI notebook as an example of deploying a crew as a web application, so it is a worked artefact rather than a framework.

There is no licence file. The project's licence is not recorded, and the repository carries an ignore file but nothing that grants permission.

That matters more here than for a typical repository of course material, because the material is published by a commercial training company and the author is the instructor. A learner who wants to reuse a notebook in their own work has no stated terms, and an instructor who wants to reuse a learner's adaptation has none either.

The maintenance signal is reasonable but dated. The last push to the main branch is 10 July 2026, which is close to three months before this was checked, and the repository is not archived. There are no releases, so the notebooks are versioned by commit and the environment by nothing at all.

Editorial conclusion

Use this repository if you are working through an agents course and want the exercises in the order the author intended, because the notebook grouping is the curriculum and the evaluation notebooks are the part most worth your time. Check four things before you start. Whether you can accept an unpinned environment, since nothing in the requirements file carries a constraint and one dependency installs straight from a git URL. Whether Python 3.11 is what you have, since the instructions ask for it by patch-level intent rather than by floor. Which framework you actually want, because the set installed covers several competing ones at once. And how you will read the outputs, since the notebooks print model answers rather than assert on them and there is no test suite in the repository.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. sinanuozdemir/oreilly-ai-agents on GitHub