Agentic AI Engineering

Building AI agents is engineering, not magic. Stop reading about agents. Start building them.

This is the repo for engineers who want to understand what's behind popular agents like Claude Code, Claude Cowork, Codex, and GitHub Copilot — and how to build one yourself.

• 🔁 The whole path — from your first LLM call to a production eval harness
• 🧱 No fancy frameworks — just an LLM API, some tools, and a loop
• 🌱 No prior AI/ML experience required — Python basics and curiosity are enough

💡 Build one this weekend. You'll understand agents better than reading 100 blog posts.

If you find this useful, a ⭐️ star helps us know we're on the right track. Join the 💬 discussion or report an 🐛 issue — your input directly shapes what we build next.

🎯 Why this repo?

• 📦 First principles, no black boxes. You build the agent loop, the tool executor, the memory layer, the eval harness from scratch — before we introduce a single framework. Learn what each abstraction is hiding before you let one hide it for you.
• ⚡ Runnable in one command. uv run --directory <tutorial> python <script>.py. No conda dance. No Jupyter kernel hunt.
• 🔬 We take production agents apart. The Disassembling AI Agents Substack series reverse-engineers Claude Code, GitHub Copilot, and OpenCode. You read how real agents work, then rebuild the pieces here.

❓ Why you need to learn this?

Agent fluency is the new data-structures interview. We teach it from first principles - you build the loop, the tool calls, the memory, and the evals yourself before we ever introduce a framework. No magic. No black boxes. Just the primitives, in the order they were invented.

All the answers are in this repo. What a tool call is, how the inferencing loop works, what lives in the context — you won't just read the answers, you'll build them with your own hands, starting in 01 - Foundations. Next interview, you're the one at the whiteboard drawing the loop.

⚡ 60-second quickstart

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 keys

uv run --directory 01-foundations/01-simple-llm-call python 01_llm_call_anthropic.py

That's it. Every tutorial is self-contained and idempotent — you can jump in anywhere. Full setup details in SETUP.md. Or open in Codespaces and skip local setup entirely.

---

🎓 01 - Foundations

Your first steps — from a single API call to a fully autonomous agent loop. Build everything from scratch to understand what's really happening under the hood.

1. Simple LLM Call — First API call with token tracking
2. Prompt Engineering — Guide model behavior
3. Chat — Interactive chat with message history
4. Tool Use — Enable function calling
5. Agent Loop — Autonomous tool-using agents
6. Codebase Navigator — The Augmented LLM with RAG, tools, and memory

🧩 02 - Effective Agents Patterns

Architectural patterns that separate toy demos from real agents. Based on Anthropic's "Building Effective Agents" — learn when to chain, route, parallelize, or delegate.

1. Prompt Chaining — Sequential multi-step pipelines
2. Routing — Classify input, dispatch to specialized handlers
3. Parallelization — Fan-out/fan-in, parallel tool calls
4. Orchestrator-Workers — Dynamic task decomposition
5. Evaluator-Optimizer — Self-critique, iterative refinement
6. Human in the Loop — Approval gates, escalation, feedback
7. Content Writer — Full agent composing all agentic workflow patterns

🧬 03 - Advanced Techniques

Practical engineering problems you'll hit the moment agents leave the prototype stage. Context, cost, memory, multimodality, safety — solved one tutorial at a time.

1. Structured Output — JSON mode, schemas, constrained generation
2. Streaming — SSE, token-by-token output, streaming tool calls
3. Context Engineering — Window strategies, summarization, tool context
4. Cost Optimization — Prompt caching, model routing
5. Memory — Short-term, long-term, memory inspection
6. RAG Techniques — Hybrid search, agentic retrieval
7. Multimodal — Vision, image generation, audio
8. Guardrails — Input/output filtering, safety patterns

🧪 04 - Testing & Evaluation

Agents are non-deterministic — testing them requires different thinking. Measure quality, catch regressions, and build confidence before shipping.

1. Unit Testing Agents — Mocking LLMs, deterministic tests
2. Evals — Accuracy, quality, regression benchmarks
3. Tracing & Debugging — Observability during development
4. Red Teaming & Safety — Adversarial testing, guardrails
5. Benchmarking — Comparing models, prompts, architectures head-to-head
6. Eval Frameworks — Promptfoo, Braintrust, Langfuse integration
7. Eval Harness — Complete eval pipeline combining all techniques

🔁 05 - Loop Engineering

Take the bare agent loop and harness it. Skills, hooks, sandboxing, MCP, subagents, and compaction — one control surface at a time — turn a naive loop into a real, extensible agent.

1. Skills — Filesystem Agent Skills, progressive disclosure
2. Hooks & Lifecycle — Intercept pre/post tool-use and stop events
3. Sandboxing — Isolate agent-run code with resource limits
4. MCP Integration — Discover tools from MCP servers, publish your own
5. Subagents & Delegation — Spawn child loops with isolated context
6. Context Compaction — Compact history in long-running loops
7. Extensible Agent — Hooks + sandbox + MCP + subagents + compaction combined

🏗️ 06 - Frameworks

One agent, nine implementations. Build the same system with each framework and compare trade-offs with your own hands.

1. No Framework — Raw SDK baseline
2. LangGraph — Graph-based orchestration
3. Pydantic AI — Type-safe agents
4. Google ADK — Google's Agent Development Kit
5. AWS Strands — AWS agent SDK
6. CrewAI — Role-based multi-agent collaboration
7. AutoGen — Multi-agent conversations
8. LlamaIndex — Data-centric agents
9. Semantic Kernel — Microsoft AI orchestration

🏭 07 - Production

The gap between "works on my laptop" and "runs reliably at scale." Principles, deployment, monitoring, cost control, and security.

1. 12-Factor Agents — Principles for production-grade agents
2. Deployment Strategies — Containers, serverless, scaling
3. Monitoring & Observability — Metrics, logging, tracing in prod
4. Cost Optimization — Token budgets, caching, model routing
5. Security & Guardrails — Auth, sandboxing, injection defense
6. Error Handling & Resilience — Retries, fallbacks, graceful degradation

🗂️ Tutorials Structure

The tutorials are organized into modules (01-foundations, 02-effective-agents) that progress from basics to advanced concepts. Each module contains numbered tutorials that build on previous lessons. Inside each tutorial folder, you'll find:

• Python scripts - Self-contained, runnable examples demonstrating key concepts
• README.md - Detailed explanations, code walkthroughs, and learning objectives

You can explore individual scripts independently or follow the complete learning path from start to finish. Each module ends with a project that combines all concepts from the module into a single, production-style agent.

📚 Companion reading

The tutorials teach you to build. Our Substack gives you the mental model first - a foundational primer on how agents actually work, followed by teardowns of real production agents you use every day. Read the post. Open the tutorial. Rebuild the pattern.

How Agents Work: The Patterns Behind the Magic - the core agentic loop from first principles. The four pattern levels (one-shot → single-tool → ReAct → planning), the role of the system prompt as behavioral design, and Ralph Mode as the outer loop. If you read one thing before opening the repo, read this. Pairs with → 01-foundations.

💜 Support Us

If you find this project useful, consider supporting us:

💬 FAQ

Module not found? Run uv sync in the lesson directory.

API errors or authentication failures? You need API keys from Anthropic, OpenAI, or both, depending on which examples you run. See SETUP.md for details.

⚖️ License

This project is licensed under the MIT License - see the LICENSE file for details.