agentic-ai-engineering: build an agent loop from scratch in Python
Hands-on tutorials for building AI agents from scratch. Learn LLM APIs, prompt engineering, tool calling, and the agent loop through practical examples.
At a glance
- What is it?
- A hands-on Python course repository that teaches LLM calls, tool calling and the agent loop without a framework, aimed at engineers who want the primitives before the abstractions.
- Who is it for?
- Adopt it if you want to write the loop, the tool executor and the eval harness yourself in Python 3.11 or newer, and you are willing to supply your own Anthropic, OpenAI or Google API key. Skip it if you want a library to import into an existing production service, or if you need a documented upgrade path between lesson folders, because the README does not describe one.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 40 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 18, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What agentic-ai-engineering is for, and who it is not for
The repository is a Python course, not a library. Its README states the goal plainly: you build the agent loop, the tool executor, the memory layer and the eval harness from scratch before a single framework is introduced. The intended reader is an engineer who can already write Python and wants to know what a tool call actually is, how the inferencing loop is structured, and what lives in the context window. The README frames this as interview-level baseline knowledge and points at Claude Code, Codex and GitHub Copilot as the systems whose internals the tutorials reverse-engineer.
That framing sets the boundary. If you need an agent runtime to drop into a service this week, this is the wrong repository: nothing here is packaged as a reusable dependency for your application. The lessons are self-contained folders, and pyproject.toml at the root only packages the cli module, explicitly excluding the lesson directories. What you take away is understanding and code you can copy, not a versioned artifact you can pin.
The lesson architecture: numbered folders, one environment each
The repository is organised as numbered modules, each holding numbered lesson folders: 01-foundations, 02-effective-agents, 03-advanced-techniques, 04-testing-evaluation, 05-loop-engineering, 06-frameworks and 07-production. Inside 01-foundations the sequence runs from a simple LLM call with token tracking, through prompt engineering, an interactive chat with message history, tool use, the agent loop, and a capstone codebase navigator that combines RAG, tools and memory. The README describes the whole path as running from a first LLM call to a production eval harness.
The structural decision worth noting is that each lesson folder carries its own pyproject.toml and uv.lock, according to the comment in the root pyproject.toml. That keeps lessons independent, so a lesson can pin a different dependency set without breaking its neighbours, and you can jump into any folder without resolving the whole repository. The cost is duplication: dependencies are declared many times over, and the root pyproject.toml is not a single source of truth for what any given lesson needs. The Makefile reflects this, with a sync-all target that installs dependencies for every lesson folder.
Installing it and running your first LLM call
The README gives a 60-second quickstart. The package manager is uv, installed through Homebrew or pipx, and the environment file is copied from .env.example, which holds slots for ANTHROPIC_API_KEY, OPENAI_API_KEY and GOOGLE_API_KEY. You need at least one of those keys; the repository does not ship credentials or a local model.
brew install uv # or: pipx install uv
git clone https://github.com/agenticloops-ai/agentic-ai-engineering.git
cd agentic-ai-engineering
cp .env.example .env # add your Anthropic and/or OpenAI keysThe first real use is the simple LLM call lesson. The README's command runs the script from the lesson directory rather than the repository root, which is the pattern every tutorial follows.
uv run --directory 01-foundations/01-simple-llm-call python 01_llm_call_anthropic.pyAccording to the README, that lesson performs a first API call with token tracking, so the output you should look for is the model's reply alongside token counts. The README also notes that every tutorial is self-contained and idempotent, and that Codespaces is offered as an alternative if you would rather skip local setup. SETUP.md holds the full setup details; the README does not reproduce them.
Where the repository is thin
The README is a marketing surface as much as a map. It carries translated links, a Substack link, a LinkedIn link and a request for stars, and it truncates before the later modules are described in the same detail as 01-foundations. A reader trying to judge 05-loop-engineering or 07-production from the README alone gets a folder name and little else.
There is also no documented upgrade path. Lesson folders each own a pyproject.toml and a uv.lock, and the README does not describe how to move a lesson forward when its pinned dependencies age, nor whether the lessons are expected to stay in sync with each other. The Makefile offers check, fix, verify, sync-all and clean, and verify imports every script in every lesson, which suggests the maintainers care about the scripts continuing to run. But the mechanism for keeping dozens of independent lockfiles current is not described anywhere in the README.
Finally, the repository assumes you bring a hosted model. There is no offline mode, no local model path and no fallback if a provider key is missing. The .env.example lists three providers, and the tutorials appear to be written per provider, so the practical dependency is your API account and its rate limits, not the code.
agentic-ai-engineering compared with a framework-first tutorial
The obvious alternative is learning from a framework's own documentation, for example LangGraph or the OpenAI Agents SDK, where you import an agent class, hand it tools and let the library own the loop. The difference is not quality but what remains hidden. A framework tutorial teaches you its API surface; this repository teaches the loop that the API surface wraps, and 06-frameworks is placed after the from-scratch modules rather than before them, which is consistent with that ordering.
The trade-off is real in both directions. Building the loop yourself means you write retry handling, message assembly and tool dispatch that a framework would give you in a few lines, and the course code is teaching material rather than hardened production code. If your goal is to ship an agent feature, a framework will get you there faster and with more of the failure modes already handled. If your goal is to be able to debug that framework when it misbehaves, the from-scratch path is the one that gives you the mental model, and this repository is explicitly organised around that goal.
Maintenance, licence and what the project does not promise
The repository is not archived, and the last push was on 2026-08-09. The most recent release listed is v2026.04.07, labelled Testing & Evaluation Module, from 2026-04-07, with v2026.02.18 before it. The release cadence visible in the repository is roughly two months apart, and the release notes name the module they add, which is a useful signal that new material arrives as whole modules rather than as patches.
Licensing is MIT, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That matters here because copying lesson code into your own project is the intended use. The repository does not state a policy for contributed lessons, and the README routes feedback to GitHub Discussions and Issues rather than to a contribution guide. Nothing in the README describes a support commitment, a deprecation policy or a compatibility guarantee between lesson folders, so treat the lessons as reference implementations you adapt rather than as code you track upstream.
Editorial conclusion
Adopt it if you want to write the loop, the tool executor and the eval harness yourself in Python 3.11 or newer, and you are willing to supply your own Anthropic, OpenAI or Google API key. Skip it if you want a library to import into an existing production service, or if you need a documented upgrade path between lesson folders, because the README does not describe one. Before you commit, read SETUP.md, check whether the provider you intend to use has a key slot in .env.example, and run the 01-foundations quickstart once to confirm the uv workflow matches your machine.
Frequently asked questions
What is agentic AI engineering in the context of this repository?
It is the practice of building the agent loop, tool executor, memory layer and eval harness yourself, from an LLM API upward, rather than starting from a framework. The repository teaches that path in numbered Python lesson folders, from a first LLM call through to a production eval harness.
What is an agentic AI engineer?
The README describes the skill set as knowing what a tool call is, how the inferencing loop works, and what lives in the context, to the point where you could draw the loop on a whiteboard. It frames this as baseline knowledge for software engineers rather than a separate job title.
Is ChatGPT an agentic AI?
The repository does not discuss ChatGPT. Its README names Claude Code, Claude Cowork, Codex and GitHub Copilot as the agents whose internals the tutorials reverse-engineer, and the course builds its own loop rather than evaluating an existing product.
Community notes