
[100% Off] Agentic Architecture: Ai Agent Design Patterns In Python
Loops, tools, workflows, multi-agent systems, memory, guardrails and evals, built with Claude and shown in real runs
What you’ll learn
- Decide when a problem needs a single model call, a workflow or an autonomous agent, and justify the choice with cost and risk
- Build an agent loop by hand in Python, then with the Claude Agent SDK, with turn, budget and time limits
- Design tools a model uses well: clear descriptions, strict schemas, errors as results, and write tools that validate in code
- Implement prompt chaining, routing, parallel sectioning and voting, orchestrator-workers and evaluator-optimizer patterns
- Manage context, sessions, external memory and retrieval, including what to do when an agent's memory is out of date
- Keep agents safe with least privilege, human approval, hooks, an audit trail and defences against prompt injection
- Prove an agent still works with evals graded by code, traces for every run, and cost per task
Requirements
- Comfortable reading Python 3. No prior experience with AI agents is needed
- Python 3.12 or newer to run the demo project
- To run the demos yourself: Claude Code installed, with a Claude subscription or an Anthropic API key. Watching the course needs neither
Description
Most agent demos look impressive for five minutes and fall apart the first time a real user writes something unexpected. This course is about what comes after the demo: the architecture that makes an AI agent predictable, affordable and safe.
You build one system from start to finish: the support desk of a small online bookshop. It reads customer tickets, looks up orders, checks a refund policy and writes replies. Some tickets are simple, some need judgment, and one order hides an instruction that tries to trick the agent into issuing a refund.
What you’ll learn:
Workflows vs agents: who decides the next step, and how to choose the simplest shape that works.
The agent loop: built by hand in about thirty lines of Python, then with the Claude Agent SDK, with turn, budget and time limits that really fire.
Tool design: descriptions a model can use, strict schemas, errors as results, and write tools that validate every call in code.
Workflow patterns: prompt chaining with gates, routing with structured output, parallel sectioning and voting.
Multi-agent patterns: orchestrator and workers, subagents with their own context, and an evaluator that grades another model’s work.
State and memory: the context window as working memory, sessions that resume and fork, external memory, and retrieval versus preloaded documents.
Guardrails: least privilege, human approval for risky actions, hooks as policy and audit trail, and prompt injection through tool results.
Evaluation and operations: eval suites graded by code, traces for every run, cost per task, and the failure modes to design around.
Real runs, not slides. Every pattern is a small Python program, and every run in the videos was recorded as it happened: each model call, each tool call, each result, and what it cost. Nineteen runs in total, for seventy-one cents at API prices. When a run went wrong, you see that too: an orchestrator inventing facts because its workers lacked context, a subagent searching ten times for something that isn’t there, an evaluator that was stricter than the policy, and a memory that overruled what the customer just said. Each failure comes with the design rule that fixes it.
The complete demo project is included as a download: every pattern as its own module, an offline test suite, an eval suite, and all recorded traces.
Recorded with the Claude Agent SDK 0.2.164 for Python, October 2026. About 1 hour 40 minutes in 35 lectures of two to four minutes, each with a short recap and many with a quick question.
Author(s): Laurentiu Raducu








