Go from junior developer to Agent Engineer: the person who ships AI that acts safely in the real world
For developers ready to move beyond prompting and build, secure, and operate production AI agents that hiring managers are actively hunting for.
35 chapters, 30 lessons
14-day refund on the yearly plan. Real pricing on the plans page, no surprises.
30
lessons, yours to run
Easy to pick up, built to get you the next job
No coding background needed, and you write code with Claude as you go.
Every section below turns into something a hiring manager recognises, not just notes.
Build the agent loop from scratch, no framework crutches
- You'll write the raw observe-think-act loop from primitives so you understand exactly what every framework is hiding from you
- You'll hand-trace agent trajectories and spot unsafe or non-terminating behaviour before it reaches production
- No prior coding background is assumed: every concept is introduced with a runnable snippet and a plain-English explanation of what it does and why it matters
- This is the foundation every agent-engineer job description is quietly testing for, even when it doesn't say so
Manage state, survive failures, and keep a run alive across interruptions
- You'll implement resumable state graphs so a long-running agent can pause, checkpoint, and restart without losing progress
- You'll wire human-in-the-loop approval gates at the exact moments a model is most likely to take an action it shouldn't
- You'll replay a real mid-run incident and debug it from a trace, the same skill a hiring manager will test you on in a live interview
Connect tools securely and defend against prompt injection
- You'll set tool permission scopes so an agent can only touch what it genuinely needs, nothing more
- You'll detect and block prompt-injection attacks that try to hijack your agent's action sequence
- You'll configure MCP correctly, with the security checks that separate a portfolio-quality build from a demo someone is afraid to ship
Evaluate, monitor, and roll back a production agent like someone who owns it
- You'll write eval cases that catch regressions before they reach users, and wire them into a monitoring dashboard you can read at 9am after a bad overnight
- You'll run a full rollback drill so you can demonstrate, not just claim, that your agent is safe to operate
- Every artifact you build becomes a portfolio piece that shows a hiring manager a real incident you handled, not a demo that worked once
Finish this course and you can do all of this, no prior background required:
- You'll be able to design and build an agent loop from primitives, demonstrating to a hiring manager that you understand what every framework is abstracting, not just how to call it
- You'll be able to implement resumable state and human-in-the-loop gates, the two capabilities teams ask for most after their first production incident
- You'll be able to audit tool permission scopes and defend an agent against prompt injection, which is now a standard expectation on any team that has shipped an agent to real users
- You'll be able to write eval cases, monitor cost and latency in production, and articulate the rollback path for any agent you own, making you the safe pair of hands a senior engineer wants on the tea
- You'll be able to decide confidently when a task should not be an agent, the judgment that separates engineers who have operated agents from engineers who have only demo'd them
- You'll be able to present four portfolio artifacts, each with a real incident narrative, turning your job application from a list of claimed skills into a body of work a hiring manager can examine
30 lessons, 35 chapters
Built by practitioners, not influencers
Every agent, skill file, and dataset is drawn from 25+ years and 50+ Oracle ERP implementations across pharma, manufacturing, semiconductor, and distribution.
Kept current with the stack
Claude Code, skills, and MCP move fast. Your licence includes every system update for as long as you're subscribed. Your system gets better, not obsolete.
Most developers who say they build agents have built a chatbot with a tool call bolted on. Hiring managers know this immediately, because when they ask 'what happens when the model is confidently wrong mid-run at 3am?', the answer is a blank stare. Job listings for Agent Engineers are multiplying, but the bar is rising just as fast: teams have been burned by agent-shaped architectures that looked great in a demo and caused silent, expensive failures in production. If your portfolio is a notebook that calls an API and prints a response, you are not competing for those roles. You are competing for the same junior prompt-engineering position as everyone else who watched the same YouTube tutorial.
What you'll be able to do, module by module
Every module leaves you able to build and run something real. Here is the syllabus, in the order you work through it.
Curriculum
35 chapters · 30 lessons
Orientation (Pre-Week 1)
You can articulate, precisely and without notes, why an agent's deliverable is a trajectory rather than a response, place any task in the correct quadrant of the RPA-backend-AI-Agent decision framework, and read a raw trace to find the step where something went quietly wrong.
0.1 · What Is an Agent Engineer, Really?1 item
- 0.1 · What Is an Agent Engineer, Really?🔒
0.2 · Meet the Case Study: Pelham Goods Wants Zero Humans1 item
- 0.2 · Meet the Case Study: Pelham Goods Wants Zero Humans🔒
0.3 · The 4-Week Roadmap: What You'll Be Able to Run by Week 41 item
- 0.3 · The 4-Week Roadmap: What You'll Be Able to Run by Week 4🔒
0.4 · Setting Up Your Toolkit1 item
- 0.4 · Setting Up Your Toolkit🔒
Quiz: The Role & the Case Study0 items
Week 1: The Raw Agent Loop
You can build the observe-think-act loop from primitives, identify when a task genuinely needs an agent versus a backend script, and instrument the loop so you can see every action the model takes before it causes harm.
1.1 · What Actually Makes Something an Agent1 item
- 1.1 · What Actually Makes Something an Agent🔒
1.2 · The "Do You Even Need an Agent?" Framework1 item
- 1.2 · The "Do You Even Need an Agent?" Framework🔒
1.3 · Tool Design: The Skill Hiding Inside Every Good Agent1 item
- 1.3 · Tool Design: The Skill Hiding Inside Every Good Agent🔒
1.4 · Termination, Budgets, and the Loop That Wouldn't Stop1 item
- 1.4 · Termination, Budgets, and the Loop That Wouldn't Stop🔒
1.5 · Case Study Checkpoint: The Raw-Loop Refund Agent, and Why "No Humans" Dies Today1 item
- 1.5 · Case Study Checkpoint: The Raw-Loop Refund Agent, and Why "No Humans" Dies Today🔒
1.6 · Week 1 Portfolio Artifact: A From-Scratch Agent, Documented1 item
- 1.6 · Week 1 Portfolio Artifact: A From-Scratch Agent, Documented🔒
Quiz: The Loop & Restraint0 items
Week 2: State, Resumability, and the First Bad Day
You can implement a state graph that checkpoints mid-run so your agent survives interruptions, wire a human-in-the-loop approval gate at the right moment, and replay a real incident from its trace to find and fix the root cause.
2.1 · Hitting the Wall: Why the Raw Loop Stops Scaling1 item
- 2.1 · Hitting the Wall: Why the Raw Loop Stops Scaling🔒
2.2 · Workflows as State Graphs1 item
- 2.2 · Workflows as State Graphs🔒
2.3 · Checkpointing and Resumability: Surviving the Mid-Run Crash1 item
- 2.3 · Checkpointing and Resumability: Surviving the Mid-Run Crash🔒
2.4 · Human-in-the-Loop: Gates, Approvals, and Escalation1 item
- 2.4 · Human-in-the-Loop: Gates, Approvals, and Escalation🔒
2.5 · Case Study Checkpoint: Pelham's Agent Survives Its First Bad Day1 item
- 2.5 · Case Study Checkpoint: Pelham's Agent Survives Its First Bad Day🔒
2.6 · Same Graph Pattern, Different Universe1 item
- 2.6 · Same Graph Pattern, Different Universe🔒
2.7 · Week 2 Portfolio Artifact: A Stateful, Resumable, Gated Workflow1 item
- 2.7 · Week 2 Portfolio Artifact: A Stateful, Resumable, Gated Workflow🔒
Quiz: State, Gates & Resumability0 items
Week 3: Connecting, Securing, and Multi-Agent
You can connect external tools via MCP with correct permission scopes, detect and block prompt-injection attempts that try to redirect your agent's action sequence, and coordinate a multi-agent hand-off without creating a new blast radius.
3.1 · MCP: Standardized Hands1 item
- 3.1 · MCP: Standardized Hands🔒
3.2 · Memory: What the Agent Should Remember, and Mostly Shouldn't1 item
- 3.2 · Memory: What the Agent Should Remember, and Mostly Shouldn't🔒
3.3 · Prompt Injection: Your Agent Reads Untrusted Text and Then Acts1 item
- 3.3 · Prompt Injection: Your Agent Reads Untrusted Text and Then Acts🔒
3.4 · Sandboxed Execution and Least Privilege1 item
- 3.4 · Sandboxed Execution and Least Privilege🔒
3.5 · Case Study Checkpoint: The Injection Incident and the Runaway Loop1 item
- 3.5 · Case Study Checkpoint: The Injection Incident and the Runaway Loop🔒
3.6 · Multi-Agent: When One Agent Isn't Enough (and Usually It Is)1 item
- 3.6 · Multi-Agent: When One Agent Isn't Enough (and Usually It Is)🔒
3.7 · Week 3 Portfolio Artifact: A Connected, Defended Agent1 item
- 3.7 · Week 3 Portfolio Artifact: A Connected, Defended Agent🔒
Quiz: Capability & the Attack Surface0 items
Week 4: Evals, Production, and the Interview
You can write an eval suite that catches regressions before users do, read a production monitoring dashboard and diagnose an overnight anomaly from its traces, execute a clean rollback drill, and tell the full incident story in an interview the way a senior engineer does.
4.1 · Agent Evals: Grading Journeys, Not Answers1 item
- 4.1 · Agent Evals: Grading Journeys, Not Answers🔒
4.2 · Production Monitoring: Traces, Metrics, and the 2am Question1 item
- 4.2 · Production Monitoring: Traces, Metrics, and the 2am Question🔒
4.3 · Pelham in Production, and the Rollback Call1 item
- 4.3 · Pelham in Production, and the Rollback Call🔒
4.4 · Turning the Case Study into a Portfolio Piece1 item
- 4.4 · Turning the Case Study into a Portfolio Piece🔒
4.5 · The Agent Engineer Interview: What They're Actually Testing For1 item
- 4.5 · The Agent Engineer Interview: What They're Actually Testing For🔒
4.6 · Your 30-Day Post-Course Plan: Landing the First Role1 item
- 4.6 · Your 30-Day Post-Course Plan: Landing the First Role🔒
Quiz: Production Ops & Getting Hired0 items
Hiring managers are saturated with CVs that say 'built AI agents' and thin out immediately under interview questioning. When you can show four production-quality artifacts, each with a traced incident, an eval suite, and a rollback story you personally executed, you are in a category of one: the candidate who has clearly operated an agent, not just shipped a demo.
From subscribing to running your first artifact
Subscribe and open the course immediately
You get instant access to all modules, the Pelham Goods case-study codebase, and the live session calendar. No waiting for a cohort to fill. Open the orientation lesson today and run your first snippet before you finish your coffee.
Build week by week, portfolio artifact by portfolio artifact
Each week you build one production-quality artifact around the Pelham Goods refund-agent story. You follow plain, step-by-step lessons with runnable code, mentor review in daily live sessions, and a Workbook that saves your progress so you pick up exactly where you left off.
Ship a real incident story, not just a demo
By Week 4 you have four portfolio artifacts, each paired with a genuine incident you debugged and resolved, an eval suite, a monitoring dashboard, and a rollback story you can walk through in an interview without notes. That is the package that gets you the role.
The Pelham Goods duplicate-refund drill: from trace to fix to eval
Spot the anomaly on the dashboard
You open the overnight monitoring dashboard and see escalation rate climb from 8% to 14%. Cost per run is flat, so this is not a runaway loop. You pull ten traces from the escalated runs to read them directly.
Read the trace and find the root cause
Eight escalations are correct. Two show the agent calling check_refund_policy and receiving a new error string the policy service started returning overnight. The agent cannot verify eligibility, decides it cannot act safely, and escalates. The trace is clean. The failure is the gap between what the tool can return and what the agent was written to handle.
Write the eval case before touching the code
You add a two-line eval that replays the exact error string as a fixture and asserts the agent either handles it gracefully or escalates with the right reason code. This case now lives in the suite permanently and will catch any regression if someone changes the policy-service contract again.
Patch the tool handler and run the suite
You update the tool's error-handling to recognise the new error code and map it to a known policy outcome. You run the full eval suite, watch the score, and ship the change behind a feature flag to 5% of traffic. Escalation rate returns to baseline within the hour.
Write the incident post-mortem for your portfolio
You document the sequence: anomaly spotted, trace read, eval written first, fix shipped, flag widened, rollback path confirmed. That narrative is the portfolio artifact. In an interview you can walk through it step by step and name every decision point. That is what a hiring manager means when they say 'show me an agent you've operated in production.'
The toolkit you'll build and run in this program
You leave with working assets, not notes.
Real things you can demo in an interview.
A working raw-agent-loop implementation built from primitives, no framework required, with inline comments explaining every design decision
A resumable state-graph artifact with a human-in-the-loop gate, ready to demo or extend in a take-home interview
An MCP tool integration with documented permission scopes and a prompt-injection defence layer
An eval suite and production monitoring dashboard wired to the Pelham Goods refund agent, with a real overnight anomaly baked in for the interview story
A rollback runbook you executed yourself during the course, paired with the incident post-mortem you wrote around it
A Workbook of trace analyses and quadrant decisions that functions as a personal reference and a portfolio supplement during interviews
You'll get the most from this if
Junior or mid-level developers who have built AI features and are ready to move into a dedicated Agent Engineer role
Backend engineers who want to own the full agent lifecycle, not just the API integration layer
Developers who have followed agent tutorials but cannot yet explain what happens when the model is wrong at 3am with production credentials
Anyone preparing for an Agent Engineer interview who needs a real incident story and a working portfolio, not just conceptual knowledge
Yearly plan: 14-day keep-the-system guarantee
14-day refund on the yearly plan. Finish the first two modules, and if you haven't run your first live pipeline, take a full refund.
Straight answers before you subscribe
Do I need a coding background or AI experience to take this course?
No prior AI or agent experience is assumed. Every lesson introduces new concepts with a plain-English explanation and a runnable snippet before asking you to build anything. The orientation module is deliberately designed to make the core ideas concrete from the very first run, and daily live sessions with a mentor mean you are never stuck alone with a confusing error for long.
Will this work with my current setup, operating system, and tools?
The course uses a terminal, Python, and standard open tooling that runs on any modern operating system. The Pelham Goods codebase is provided to you on enrolment and the orientation lesson walks you through confirming your environment before Week 1 starts, so you are not troubleshooting setup during the lessons where the real building happens.
What if I start and it is not the right fit? Is there a refund?
Yes. There is a 14-day refund policy. If you work through the orientation and Week 1 material and decide this is not what you needed, contact support within 14 days of purchase and you will be refunded without a dispute process.
The field moves fast. How do I know the content will stay current?
The course is updated when the underlying tooling or production patterns change in ways that would make a lesson misleading. Enrolled students receive access to those updates without paying again. The core curriculum is built around primitives and principles that remain stable even as specific framework versions change, so you are not learning something that expires with the next library release.
Can I use what I build during the course in my own work or show it to employers?
Yes. The artifacts you build are yours. You can include them in your portfolio, show them in interviews, and adapt them for your own projects or employer. The Pelham Goods scenario is a teaching case study, so the context is fictional, but the code and the skills are entirely real and entirely yours to use.