FDEInterviews logo

Production AI Agents for FDEs

Build production AI agents in Python through 18 lessons and six projects. Practice tool permissions, crash recovery and evaluation. Start with three free lessons.

6 modules18 lessons~11.5 hours3 free to read

Production AI Agents for FDEs is a self-paced Python course for forward deployed engineers and software developers learning to build agent systems. It starts with basic Python and develops intermediate skills in evidence retrieval, tool permissions, human approval, crash recovery and agent evaluation.

A support agent gives a convincing answer. Then the policy changes, the reviewer approves an old proposal, or a replacement request succeeds just before its response disappears. What should the system do next, and how would you prove it did the right thing?

You will answer those questions by building one system for Calder Equipment, a fictional industrial-equipment company. Begin with a small support baseline. Add applicable policy evidence, bounded model decisions, scoped tools, separate approval and recoverable actions. Finish with a release review that includes the code, its failures and the operator workload.

Each lesson explains one mechanism, shows it in a diagram, gives you a concrete exercise and then changes an assumption. Six projects connect those mechanisms into a reviewable implementation.

One case, from evidence to accepted action

The whole course fits in one picture. Put a finger on any stage and you can say what the case looks like at that moment: which policy governs it, what the model has proposed, what a person approved and what the service has committed. Stage 6 is the one the course turns on.

What happens to one support case, from message to accepted request EVIDENCE DECISION EFFECT after a lost reply 1 Support request authenticated case lookup 2 Applicable policy tenant · product · effective date 3 Context packet required evidence intact, or hold 4 Model proposes replace · clarify · deny · handoff 5 Validate the proposal schema first, then identity 6 Exact approval digest of six fields, expiring 7 Persist intent unknown, written before the send 8 Service commits one transaction: request + receipt 9 Confirm or reconcile lookup by action identity On 2026-01-01 policy P1 has ended and P2 governs; the end date is exclusive. A ticket note or another tenant's policy never enters the packet at all. P1 2025-01-01..2026-01-01 P2 2026-01-01.. "replace" is a proposal. Nothing has been approved, sent or shipped when the model says the word. Approval binds tenant, case, serial, revision, policy and action. Change the serial and the digest changes, so the old approval no longer applies. C01 · P-17 · rev 3 · P2 expires at t=130 The receipt proves an accepted request, not a shipped pump. It commits with the case update or not at all. R-<digest[:16]> status replacement_requested A timeout leaves the ledger at unknown. The worker looks the receipt up by identity; it never resends under a new key and never writes failed on a guess.

You will preserve the boundary between a suggested replacement, an approved request and an accepted service receipt. A receipt does not mean the item shipped. That distinction runs through the diagrams, fixtures, tests and capstone.

Start free, then build the complete system

Read three complete lessons without an account:

Three more lessons unlock with a free account: build the baseline, select applicable policy evidence and design a scoped read tool. Their examples run independently.

Premium opens twelve further lessons: context validation, adversarial approval tests, crash recovery, evaluator calibration, paired release analysis and the capstone. The downloadable companion includes original fixtures, a reference implementation, learner exercises, deliberate test mutations and a release-review worksheet. It requires active paid Premium or approved complimentary download access. Referral Premium includes the online lessons.

Frameworks you can reason about

Dated September 2026 field notes and a companion migration lab cover Google ADK 2.0, Anthropic's Claude Agent SDK, LangGraph, OpenAI Agents SDK and Pydantic AI. You will map workflow nodes, tools, approval pauses, retries and stored state onto the same support contract. The durable lessons remain useful when SDK syntax changes.

The supplied implementation runs offline with recorded model decisions. It tests control behavior, including actual worker process death. The optional framework lab specifies the additional live-runtime checks to perform; it does not claim those integrations have already passed. All cases and evaluation outputs are synthetic, with no customer data or paid model account required for the core course.

Where this fits

Use FDE Foundations for the role and first customer engagement. Use The FDE Engagement for the complete delivery lifecycle. This course gives you a connected agent implementation to explain and inspect; Hard Deployments extends the operating constraints afterward.

Plan to work in order on your first pass. Save your acceptance contract, failing tests and release decision as you go. The final artifact is a system you can defend with evidence, including an honest account of what remains untested.

Questions before you start

Is this AI agents course suitable for beginners?

It suits beginners to agent engineering who can already write Python functions, work with dictionaries and handle exceptions. You should recognize JSON and HTTP requests. The lessons introduce agent control, recovery and evaluation from the beginning, then build toward an intermediate capstone. If you are new to the forward deployed engineer role itself, begin with FDE Foundations.

What will I build in the six projects?

You will build a reproducible support baseline, repair its evidence path, test its authority boundary, recover an interrupted write, compare two releases and assemble the final support system. Each project supplies the records and expected behavior needed to begin. The capstone asks you to defend the implementation using tests and a record of what remains unverified.

Does the course teach Google ADK 2.0 and Anthropic's agent framework?

Yes. The September 2026 field notes and Premium companion map the course's contracts to Google ADK 2.0 and Anthropic's Claude Agent SDK, alongside LangGraph, OpenAI Agents SDK and Pydantic AI. The reference implementation uses Python's standard library. Framework migration exercises specify the live checks you must run before relying on a port; they are not pretested SDK integrations.

Do I need a paid model API or a GPU?

No paid model API, API key or GPU is needed for the supplied local projects. They run with Python 3.10 or later and recorded model decisions. Optional live framework experiments need the chosen runtime and any provider access it requires. The local checks establish control behavior; they do not measure a live model's answer quality.

Which lessons are free, and what does Premium include?

Three lessons are public, and a free account opens three more. Premium opens the remaining twelve lessons. The downloadable project companion requires active paid Premium or approved complimentary download access and includes recovery exercises, adversarial checks, evaluation fixtures and the release-review worksheet. Referral Premium covers the online lessons. See current access terms and pricing, or start the first free lesson.

When you finish, you can

  • Choose where an agent helps, define a completed customer task and build a baseline you can reproduce
  • Select applicable evidence and validate model decisions without confusing a policy packet with permission
  • Bind tool access and approval to the exact case, caller and current record
  • Recover from a worker crash or lost response while preserving one accepted replacement request
  • Compare releases using paired cases, missing outcomes, unsafe effects and operator capacity
  • Map the tested contracts to ADK 2.0, Claude Agent SDK and other current runtimes, then defend what still needs verification

BEFORE YOU START · Basic Python functions, dictionaries and exceptions, plus familiarity with JSON and HTTP requests. No agent framework, distributed-systems or evaluation background required. The local projects need Python 3.10 or later; they use recorded decisions and require no API key.

Premium companion · Python

Run the project and investigate its failures

Get the runnable Calder project, synthetic policy and evaluation records, learner exercises, reference solutions, failure tests and release worksheet. The framework migration lab covers ADK 2.0, Claude Agent SDK, LangGraph, OpenAI Agents SDK and Pydantic AI.

Python 3.10 or later. The core exercises run offline with recorded decisions and no API key. Live framework integration is a separate exercise.

Syllabus

01

Contract and baseline

Choose one support outcome and establish the evidence needed to judge it.

02

Evidence and context

Select applicable policy and assemble a bounded input the model can use.

03

Tools and authority

Give the model useful read tools and keep write authority in the service.

04

Durable actions

Persist intent, reconcile uncertain effects and rehearse process failure.

05

Evaluation and improvement

Inspect paired outcomes, calibrate judgments and reject misleading improvements.

06

Release and ownership

Fit review demand to capacity and defend a staged operating decision.