Harness Engineering for FDEs

A model proposes a patch. A check passes. Then the source changes, the worker restarts, or a tool times out after changing a customer record. What does the system actually know, and what may it do next?

Harness Engineering for FDEs teaches the software around the model that answers those questions. Across 44 lessons, including ten projects, you will build a coding harness and a domain-specific procurement workflow. Each lesson includes a mechanism diagram, supplied practice inputs, a worked review, a changed-input exercise and a short drill.

The course follows Northstar Components, a fictional distributor. Its engineering team needs an agent to repair a purchasing workbench. Its buyers need an assistant that reads the right policy, prepares an exact amendment and waits for appropriate approval. The examples share runtime controls while keeping the two jobs' permissions and completion criteria distinct.

Build two systems you can explain

The coding project starts with a one-character threshold defect. You will repair a real source file in a disposable repository, keep the evaluator separate, verify the HTTP and browser behavior, and build a bounded repair loop that can either finish with evidence or leave a useful handoff.

The procurement project begins with scoped documents and one order. You will maintain an incremental evidence index, reject unauthorized tool requests, persist exact action intent, kill and recover a worker, and run a graph that pauses for review before recording a matching amendment receipt.

The two result paths matter. A passing patch has not been deployed. An amendment receipt does not mean a supplier has accepted or shipped an order. You will preserve those distinctions in code, tests and the delivery review.

Choose your starting point

If you are new to harness engineering, start with the first free lesson and follow the syllabus in order. You need basic Python and software delivery experience, but no agent framework background.

If you already build agents, try one of these complete public lessons:

• Make the repository inspectable: give a fresh coding worker a reliable route to the contract, architecture and checks.
• Design tools around customer operations: separate useful capabilities from unnecessary authority.
• Resume from a checkpoint: preserve the facts a new worker needs after the conversation disappears.
• Choose the right verification: connect code checks to the behavior a customer actually uses.
• Compare current runtimes by evidence: evaluate a runtime against the same permission, recovery and acceptance packet.

A free account also opens the self-contained minimal harness project. Run its Python example without downloading the Premium companion.

From first loop to operating handoff

The ten modules build on one another:

1. Define the task, typed decisions and acceptance boundary.
2. Create repository instructions, architecture checks and a repeatable initializer.
3. Design scoped tools, execution boundaries and reviewed extensions.
4. Compile context and maintain current, authorized retrieval evidence.
5. Persist state, fence stale workers and reconcile uncertain effects.
6. Verify the product, protect the evaluator and compare complete outcomes.
7. Build bounded repair, scheduling and independent-review loops.
8. Coordinate graph nodes, compatible joins and durable approval pauses.
9. Study four runtime designs through worked mechanisms, traces and failure analysis.
10. Adapt the harness to a changed customer brief and defend its release and operation.

The companion includes a learner controller starter with staged checks, a persistent policy desk, a feedback-driven coding graph, original Python implementations, deliberate mutations and a delivery worksheet. The project evolution map shows what each milestone inherits and what you build next. The capstone adds a second policy, persistent follow-up history and revision-aware evidence rather than stopping at the original threshold repair. Core execution is offline with recorded decisions. The reference tests demonstrate the specified control behavior; live-model quality and production containment require the separate integration checks described in the course.

Access that is clear before you start

Eight lessons are public. Eight more open with a free account. Premium opens the remaining 28 lessons, including the advanced projects and capstone. Every lesson's access is shown in the syllabus.

The downloadable companion requires active paid Premium or approved complimentary download access. Referral Premium includes the online lessons. Public and account lessons provide their own examples and do not require the paid download. See current access terms and pricing.

Current tools, durable engineering

Four dedicated design studies explain Codex repository and runtime contracts, Claude Code hooks and specialist review, Pi session trees and context, and DeepSeek Harness services and event replay. Each follows a mechanism through original code, diagrams, a failure and an FDE adaptation, with dated official references and explicit integration limits. They also cover scoped instructions, skills, MCP security and durable graph persistence. Product details are kept in dated notes so changes in SDK syntax do not bury the underlying engineering lesson.

The practical work remains specific: exact verdict parsing, long-paragraph chunking, deleted-source cleanup, proposal-bound receipts, stale-worker rejection, immutable verification artifacts and accounting for missing evaluation cases. You will see successful paths and the failures that should stop them.

Continue through the rest of FDEInterviews

Use FDE Foundations for the role and first engagement. The FDE Engagement connects the implementation to discovery, acceptance and customer handoff. Production AI Agents builds a complementary support-agent workflow, while Hard Deployments develops the infrastructure and operating constraints.

Lessons link directly to the relevant concepts, interview questions, browser labs and research papers. Those references let you revisit a mechanism or challenge a design without losing the course's next step.

Questions before you begin

What is harness engineering?

Harness engineering is the design of the runtime around a model: how it receives context, proposes actions, uses tools, stays within authority, verifies results and recovers interrupted work. This course applies those responsibilities to coding and customer-specific operations.

Do I need a paid model API or a GPU?

No. The core projects use Python's standard library, Git, synthetic records and recorded decisions. Optional live-runtime integrations need the chosen provider and environment. The course distinguishes those integrations from the offline tests you can reproduce locally.

How is this different from the Production AI Agents course?

Production AI Agents builds a connected support workflow. This course concentrates on the harness itself: repository preparation, instruction loading, context and state lifecycle, protected verification, bounded loops, graph coordination and adaptation across coding and business operations. The courses share concepts and link to each other where the practice is complementary.

Are there solutions when I get stuck?

Yes. Each lesson supplies a worked review or expected result and then changes an assumption. The Premium companion contains the original reference implementations, test fixtures, focused exercise guide and delivery worksheet. You can inspect the solution, rerun the failure and explain why the repair satisfies the contract.