LockedIn FDE Training / The open field library

Build AI for the field.

Practical training for forward-deployed engineers. Turn a client problem into an agentic AI system you can explain, evaluate and hand over.

Choose your first exercise

Free guides and labs. No account or API key required.

THE LEARNING SEQUENCEBuild something you can defend.

New to forward-deployed engineering? Follow the six-session route and build a portfolio from one shared synthetic engagement.

Start the learning route

Have 20–35 minutes? Practice one decision.

Jump straight to a workbook exercise. Each includes a task, supplied material and something concrete to keep. These are optional sessions, not a completion checklist.

Find an exercise

Time available

19 exercises · All practice

25minutes
Choose the right amount of autonomy
Compare direct lookup, a bounded draft, a fixed workflow and a model-directed loop against four client tasks.
Read the supplied synthetic brief; paper or your portfolio is enough.
Your working artifact
An architecture choice, simpler comparison and changed-brief revision.
Related Academy lesson
Requires Academy access.
20minutes
Improve a decision with AI feedback
Write first, ask for one challenge, check the evidence and explain a fresh case without the coach.
Use the lesson coach with existing Academy access, or a peer with the supplied questions.
Your working artifact
A first attempt, supported revision and independent explanation.
Related Academy lesson
Requires Academy access.
20minutes
Make your first bounded code change
Edit one request category, introduce a source conflict and confirm that unauthorized access still stops.
Node.js 24, the free starter and a plain-text editor; tabletop tracing is also available.
Your working artifact
A small explained diff, predictions and five observed outcomes.
Related Academy lesson
Requires Academy access.
25minutes
Inspect a model-output contract
Run eight authored outputs through a local validator and explain why a valid citation cannot establish source support.
Node.js 24 and the free output-contract lab; no model account or API key.
Your working artifact
A contract trace, changed-fixture experiment and support-review gap.
Related Academy lesson
Requires Academy access.
30minutes
Delegate agent work without multiplying authority
Trace two workers against one shared budget, reconcile conflicting references and keep a late result out of a completed manual task.
Read the synthetic worker packet; optional Node.js 24 replay needs no provider account or API key.
Your working artifact
A dispatch ledger, result-selection decision and changed-condition handoff.
Related Academy lesson
Requires Academy access.
30minutes
Resume an agent without inheriting its assumptions
Repair a compressed handoff summary, separate memory from authority and revise the next step as access and source state change.
Read the six synthetic records; no model account, API key or code execution needed.
Your working artifact
A compact context packet, three continuation decisions and a receiver objection.
Related Academy lesson
Requires Academy access.
30minutes
Trace an agent’s proposed tool calls
Run a local dispatcher and investigate revoked access, forbidden actions and a changed plan.
Node.js 24 for the free offline lab; no provider key or network call.
Your working artifact
An execution trace and a bounded tool specification.
Related Academy lesson
Requires Academy access.
25minutes
Keep sources consistent across agent steps
Investigate a source revision and unversioned text change between reading and drafting, then challenge a misleading success result.
Node.js 24 and Edition 2 of the free tool-dispatch lab, or an explicitly unexecuted paper trace.
Your working artifact
A snapshot trace, changed-copy counterexample and receiving note.
Related Academy lesson
Requires Academy access.
20minutes
Check source coverage before drafting
Compare incomplete and complete empty lookups, trace the next page and challenge a proposal built from different snapshots.
Node.js 24 and the free catalog-coverage lab, or a paper trace labeled unexecuted; no provider account.
Your working artifact
A coverage decision table, actual page trace and receiving note.
Related Academy lesson
Requires Academy access.
30minutes
Keep an agent loop within its limits
Investigate failed attempts, resource limits, late drafts, cancellation and repeated work in a local controller.
Node.js 24 and the supplied offline lab; authored responses and virtual time.
Your working artifact
A stopping contract and a changed-boundary experiment.
Related Academy lesson
Requires Academy access.
25minutes
Decide whether an agent should retry
Separate temporary failures from access and credential stops, then trace a wait and a late draft against one deadline.
Node.js 24 and Edition 2 of the free agent-loop lab, or a clearly labeled tabletop trace.
Your working artifact
A retry decision table, changed-boundary experiment and operator receiving note.
Related Academy lesson
Requires Academy access.
30minutes
Keep changing sources reliable
Trace duplicate and late updates, withdrawals and conflicting revisions before deciding which source can be used.
Node.js 24 and the free source-lifecycle lab; sequential synthetic events only.
Your working artifact
Six event traces, a revision counterexample and a receiving contract.
Related Academy lesson
Requires Academy access.
30minutes
Choose an AI route within the service contract
Compare two synthetic routes across twelve paired requests, then challenge a fallback budget and a one-millisecond deadline change.
Open the interactive comparison or use a spreadsheet with the free CSV; no provider account or live model call.
Your working artifact
A complete route comparison, scoped decision and receiving challenge.
Related Academy lesson
Requires Academy access.
30minutes
Check whether an improvement transfers
Compare two fictional candidates across development and fresh tasks, preserving unrun boundaries and unsupported claims.
Read the supplied synthetic packet; no model account or code execution needed.
Your working artifact
A frozen decision rule, claim-level comparison and next-evidence recommendation.
Related Academy lesson
Requires Academy access.
35minutes
Challenge a productivity claim
Calculate whole-task effort across twelve synthetic pairs, including rejected drafts and manual fallback.
A spreadsheet or calculator and the supplied synthetic CSV.
Your working artifact
A comparison table and a scoped value recommendation.
Related Academy lesson
Requires Academy access.
25minutes
Design an agent trace without copying the payload
Inspect eight proposed events, separate model claims from application observations and preserve useful diagnostics without retaining sensitive content.
Read the synthetic trace packet; a text editor or paper is enough. No provider account or code execution.
Your working artifact
An event decision table, two repaired records and a receiving challenge.
Related Academy lesson
Requires Academy access.
30minutes
Roll out a contract across client versions
Trace old browser sessions, design a compatible API response and defend both rollback directions without losing the operator's work.
Read the supplied synthetic client and API contracts; no account or code execution needed.
Your working artifact
A six-row compatibility matrix, deployment order and receiving challenge.
Related Academy lesson
Requires Academy access.
30minutes
Make the operator's next action clear
Repair misleading states, preserve work through an interruption and let a receiver attempt the task unaided.
Paper sketches or a local practice prototype and the supplied synthetic case.
Your working artifact
An operator task, interruption contract and observed revision.
Related Academy lesson
Requires Academy access.
30minutes
Review the evidence behind a rollout
Resolve two reviewers’ disagreement and update only the claims supported by a new candidate’s evidence.
Read the supplied packet; work alone or compare decisions with a peer.
Your working artifact
A traceable review decision and the smallest useful repair plan.
Related Academy lesson
Requires Academy access.

Build your client-delivery portfolio.

Follow the suggested sequence below, or choose the guide for your current task. Start with the learner guide and workbook. Keep your first attempt, the evidence behind it and the revision you would make.

01 / Start guide
Your first client-delivery portfolio
Choose a starting route, prepare your workspace and plan six working sessions.
02 / Working reference
Client delivery workbook
Keep the shared case, practical exercises and artifact templates beside your work.
03 / 30-minute practice
Run a client discovery interview
Use stakeholder role cards to reconcile conflicting accounts and agree a useful first slice.
04 / 40-minute practice
Investigate retrieval before trusting the answer
Trace eight source-backed answers through tenant scope, effective dates, conflicting evidence and unsupported claims.
05 / 30-minute practice
Calibrate draft review
Compare six synthetic drafts with their evidence and explain your review decisions.
06 / 35-minute practice
Recover an agent action when the receipt is missing
Investigate seven action traces, prevent duplicate work and hand over a recovery decision when the destination outcome is uncertain.
07 / Agent engineering lab
Build and test a bounded AI agent
Run real LangChain tool loops and LangGraph SQLite restart labs, compare broken candidates and inspect source-bound review without a provider key.
08 / 35-minute practice
Plan cohort review capacity
Put review work and revision delays on a calendar before committing to the next intake.
09 / 35-minute practice
Defend a changed client brief
Revisit your decision when a source, permission or productivity assumption changes.
10 / 25-minute practice
Review a portfolio with a receiver
Trace six artifacts, attempt one receiving task and request a revision another engineer can verify.
11 / Presentation guide
Rehearse the enterprise walkthrough
Follow an eight-minute Claude Code path in production, then challenge the evidence with a receiving partner.

The thinking behind the work

Engineering judgment comes first.

Explore the decisions behind useful agent systems, then bring an idea back to your next practice session.

ENGINEERING / 8 MIN READ

Before you blame the model, inspect the contract

A composite failure scenario shows how an ambiguous tool schema can turn a capable model into an unreliable operator — and why a common protocol is plumbing, not proof of contract quality.

Read the essay MANIFESTO / 7 MIN READ

Design for operators, not completion.

Watching an expert work is not the same as doing the work. LockedIn Labs is built around that difference — a graph instead of a catalog, proof-of-work instead of completion, and a defined cohort operating model that activates only when a cohort is contracted and staffed.

Read the essay

What does a forward-deployed engineer practice?

A forward-deployed engineer works close to the people using a system. The work begins with understanding a workflow and agreeing what a useful change would do. It continues through implementation, evaluation, deployment planning and transfer to the team that will operate it.

For agentic AI, that includes deciding which tools an agent may call, what evidence supports its output, where a person must approve an action and how the workflow recovers when a tool or source fails. The exercises use synthetic administrative requests so you can practice those decisions without customer data.

The workbook connects six artifacts: a discovery brief, implementation record, service boundary, evaluation report, operator handoff and delivery defense. The client-delivery curriculum adds guided lessons and practice under existing Academy access.

Plan your learning.

Can I start without coding experience?

Yes. Begin with the learner start guide, sketch the request journey and try the discovery interview with a partner. The optional code exercises use Node.js 24; you can first work through the workbook as a tabletop exercise.

What is free, and what requires Academy access?

All guides in this library are free to read and download. The learning kit also includes an offline code starter and synthetic fixtures. Full guided lessons and review use existing Academy access.

How can I check my starting knowledge?

Use the free AI learning diagnostic to explore your learning needs, or try the public foundation practice. Treat these as learning inputs; they do not award an engineering qualification.

Can a team use these materials for a learning session?

Use the discovery role cards for paired practice and the rehearsal guide for a receiving-team handoff. Record what participants can explain and perform. For organizational learning, explore the enterprise training platform and discuss the delivery scope with LockedIn Labs.