Track B / 7 volumes

Building trustworthy agents

A conversion programme for existing engineers. Volume 1 completion means foundations completed: a gated workflow in the local mock. It is not a deploy-ready credential or permission to connect customer systems.

Sample available Linked samples are ready to read. Other modules show planned outcomes and are marked “Coming soon”.

Volume 1

Build a gated local workflow

Sample lesson available · remaining lessons coming soon

Local foundations only, after the minimum preflight. The first engineering volume: a system model you can defend, a first path through one customer workflow, and eight labs in the starter repo.

B1.01Coming soon

The job of a forward-deployed engineer

Completed artifact: Owner brief and versioned initial scorecard. Outcome: You can state what you are there to do: put one workflow into the customer's tools, with control the customer can see.

  • You are not there to install a chatbot and leave.
  • Success is a handoff the business owner can run the following week.
  • You wear three hats: translator (you say the business back in its own words), designer (you shape the workflow, the gates and the evidence), and keeper of reusable methods (you leave the next engagement a head start).

Practice note: An FDE's job is to find the real workflow, write a reusable method, and leave the owner able to run it. Plan time for access and data-quality work, not only implementation.

Lab B1.01: Inspect the observe-only failure and agree a small owner brief before coding. See the cumulative fixture/assertion contract in the lab specifications. (~45 min (pilot estimate))

B1.02Coming soon

A system model: outcome, connectors, gates, log

Completed artifact: Four-component diagram and boot/unknown-action tests. Outcome: You can draw the same four parts Track A uses, as runtime components.

  • The agent proposes; connectors execute; the gate can refuse; the log is append-only.
  • If a component is missing from the diagram, it will be missing in the incident.

Lab B1.02: Build the four-component boundary and deny unsupported execution. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B1.03Coming soon

Identity: who the agent is, and who it acts for

Completed artifact: Principal/authority map with forged-caller rejection. Outcome: You can separate the agent's principal from the user or mailbox it is allowed to act on.

  • "Logged in as the founder" is not an identity design.
  • Every action in the log should say who acted, and on whose behalf.

Practice note: The person signs in and completes two-factor authentication themselves. Agents must not copy or type credentials, and must not use a switch that skips permission prompts. Keep each agent's access narrow and reviewable.

Lab B1.03: Separate authenticated principal, resource and acting-for authority. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B1.04Coming soon

Permissions that match the workflow

Completed artifact: Resource-scoped grant map and explicit declined capabilities. Outcome: You can map each step to a read or write scope, and refuse a tenant-wide grant.

  • The payment connector is not implied by the invoice-read connector.
  • Revocation should be possible without a vendor ticket.

Lab B1.04: Grant only the read/draft access the owner brief needs. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B1.05Read the lesson

Approval gates

Completed artifact: Envelope-bound approval state machine with positive and negative evidence. Outcome: You can design a hard stop before a sensitive action, bound to the complete execution envelope the human approved.

  • A gate is a control, not a notification that something already happened.
  • Timeouts escalate or hold; they do not silently approve.

Lab B1.05: Implement the shared envelope, approval and durable dispatch contract. See the cumulative fixture/assertion contract in the lab specifications. (~90 min (pilot estimate))

B1.06Coming soon

Action logs that would stand up in a review

Completed artifact: Minimal intent/outcome review with snapshot expiry. Outcome: You can specify a log that answers what happened, who approved it, and which record was touched.

  • If the action can proceed without a log write, the log is optional in practice.
  • Payloads in the log are personal data and need the same care as the source systems.

Lab B1.06: Deepen log minimisation, review access and retention without weakening B1.05. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B1.07Coming soon

Send, pay, delete: irreversible actions

Completed artifact: Action inventory with gated send/pay/delete tests. Outcome: You can tag irreversible or hard-to-reverse actions and refuse an ungated path to them.

  • These three are the starting list, not a complete one.
  • A draft in a side folder is reversible; a message in the customer's inbox is not.

Practice note: No outbound message, payment, or deletion leaves without a named person's approval — including when you are running the agents yourself.

Lab B1.07: Exercise the same boundary for delete, drafts and alternate call paths. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B1.08Coming soon

One customer workflow, end to end

Completed artifact: Cumulative local-run report and owner-readable design. Outcome: You can walk a single workflow from brief to pilot, naming identity, scopes, gates, and log events.

  • Prefer one boring, checkable path over a platform tour.
  • The business owner should recognise the design in their own words.

Lab B1.08: Run an owner-readable end-to-end local workflow and explain its limits. See the cumulative fixture/assertion contract in the lab specifications. (~90 min (pilot estimate))

Volume 2

Identity and access

Coming soon

How the agent is represented in the customer's directory, how connector authorisation is granted and revoked (separate from privacy consent), and how approvers are identified as people rather than as a shared inbox.

B2.01Coming soon

The customer identity landscape

Outcome: You can locate the directory, mail, and SSO the workflow will actually use.

  • Start from what the customer already runs, not from a preferred stack.
  • Write down the tenant, the domains, and who can create apps or grants.

Lab B2.01: Discover an unfamiliar directory from evidence instead of copying answers. See the cumulative fixture/assertion contract in the lab specifications. (~45 min (pilot estimate))

B2.02Coming soon

Acting as the company versus acting as a person

Outcome: You can choose a service principal or delegated user access on purpose, and defend the choice.

  • Shared mailboxes, "send as", and personal mailboxes are different risks.
  • The log must still name a human when a human's authority was used.

Lab B2.02: Test delegated authority without impersonating the person. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B2.03Coming soon

Mapping a workflow to roles

Outcome: You can turn a Track A brief into roles for the agent, the approver, and the business owner.

  • Role names should match how the customer already talks about the work.
  • Do not reuse a privileged IT role because it is convenient.

Lab B2.03: Map workflow roles and handle overlapping small-team duties. See the cumulative fixture/assertion contract in the lab specifications. (~45 min (pilot estimate))

B2.04Coming soon

Just-enough scopes

Outcome: You can request the narrowest scopes that make the steps possible, and list what you refused.

  • Mail.read on one mailbox is not Mail.read on the tenant.
  • Record the unused scopes you were offered, and that you declined them.

Lab B2.04: Narrow inherited provider capabilities while preserving approved execution. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B2.05Coming soon

Grant, review, and revoke

Outcome: You can document how access is granted, how it is reviewed, and how it is taken away.

  • A grant without an owner will outlive the project.
  • Test revocation before go-live, not after a scare.

Practice note: In the supplied fixture, 401 means an expired session and 403 means a denied scope. Diagnose error details, identity and grant state; real providers may use these codes for other reasons. Never relocate credentials as a repair.

Lab B2.05: Diagnose grant/session faults and verify live revocation. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B2.06Coming soon

Approver identity, backups, and segregation of duties

Outcome: You can bind a gate to a person (and a backup), and avoid letting the agent approve its own work.

  • A distribution list is a notification target, not an approver.
  • The person who can edit the brief should not be the only control on a payment gate.

Lab B2.06: Enforce authenticated backups and separation of duties through role changes. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B2.07Coming soon

Break-glass and emergency paths

Outcome: You can design a rare, logged override that still requires a person.

  • Emergencies still leave a record.
  • Emergency routing needs bounded authority, an independent second check, expiry and review. It never bypasses scope, approval, freeze or the log.

Lab B2.07: Bound emergency handling without creating a bypass. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B2.08Coming soon

Common identity failures

Outcome: You can recognise stale tokens, departed users, shared passwords, and over-broad connector authorisation.

  • Most serious failures in this volume look like "it still worked after it should have stopped."
  • Build a short review list and use it on every engagement.

Lab B2.08: Detect inherited identity regressions in an isolated review fixture. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

Volume 3

Data, connectors, and interfaces

Coming soon

The agent only touches the customer through connectors. This volume treats those interfaces as a contract that should still make sense when a tool or a model is replaced.

B3.01Coming soon

What the agent needs to read

Outcome: You can list the minimum objects, fields, and time window for the workflow.

  • "The whole drive" is not a read model.
  • Prefer filters you can explain to the business owner.

Lab B3.01: Add field and time minimisation inside already narrow access. See the cumulative fixture/assertion contract in the lab specifications. (~45 min (pilot estimate))

B3.02Coming soon

What the agent is allowed to write

Outcome: You can define write actions as explicit, idempotent operations, not free-form updates.

  • Drafts and labels are different from sends and deletes.
  • A second run should not create a second bill.

Lab B3.02: Make reversible writes idempotent and revision-aware. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B3.03Coming soon

Connectors as a contract

Outcome: You can describe each connector by the actions it exposes, the auth it uses, and the errors it can return.

  • The workflow should depend on the contract, not on a vendor's UI.
  • Version the contract; do not let it drift in a prompt.

Practice note: Prefer one connector identity per agent so access is reviewable and revocable. The human completes the sign-in.

Lab B3.03: Version action, authentication and error contracts without exposing adapters. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B3.04Coming soon

Tool interfaces when the products change

Outcome: You can sit MCP or an equivalent tool layer behind the same contract, so a new app does not rewrite the gates.

  • Tools will change; the names of sensitive actions should not.
  • A new connector still has to honour the same gate and log rules.

Lab B3.04: Swap a backend and retain every earlier invariant. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B3.05Coming soon

Handling messy, human-shaped data

Outcome: You can plan for attachments, forwards, mixed languages, and missing identifiers.

  • The agent should extract, then check, then escalate — not guess a purchase order into existence.
  • Confidence is not evidence.

Lab B3.05: Validate supplied messy extraction and refuse unsupported facts. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B3.06Coming soon

Retention, minimisation, and PDPA duties

Outcome: You can set what is stored, for how long, and who can see it, under Singapore's PDPA and, where relevant, Thailand's PDPA.

  • Logs, prompt traces, and cached attachments are in scope, not only the source mailbox.
  • Collect less, retain on a purpose, and know how you will answer an access or correction request.

Practice note: Some sources should stay out of the store until a redaction-safe refresh is reviewed. A hold list can be hashed identifiers plus a review date, not the records themselves. Credential vaults are never ingested.

Lab B3.06: Apply retention and controlled correction to all personal-data copies. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B3.07Coming soon

Consistency and retries

Outcome: You can design retries that cannot double-send or double-pay.

  • Every write needs an idempotency key the connector honours.
  • A retry after a timeout must check the world, not repeat the intent blindly.
  • A long run should resume from its last checkpoint, not start again and redo finished steps.

Lab B3.07: Extend durable idempotency to crashes, batch checkpoints and concurrent workers. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B3.08Coming soon

When a connector is the wrong shape

Outcome: You can stop an engagement from forcing a workflow through an API that cannot support a gate or a log.

  • If another operation embeds an unpreviewable send that cannot be disabled, refuse that operation or recut the workflow; an ordinary send call can be gated before it is called.
  • Change the workflow, or change the tool; do not paper over it in the prompt.

Lab B3.08: Refuse an operation with an inseparable unapproved side effect. See the cumulative fixture/assertion contract in the lab specifications. (~45 min (pilot estimate))

B3.09Coming soon

Knowledge the agent can cite

Outcome: You can prepare a customer's knowledge (price lists, policies, past good replies) so the agent finds the right piece, says where it came from, and stays current.

  • Every source has an owner, a scope, and a refresh date. Without an owner, it goes stale and nobody notices.
  • Use representative synthetic questions in public labs and independently labelled variants. Hold stale financial evidence and conflicting sources for owner resolution; verify answer support as well as retrieval rank.
  • Start with a short glossary and the few things that matter (products, customers, suppliers, terms). Most SMB workflows do not need a knowledge graph.

Lab B3.09: Ground useful answers in authorised, current, nonconflicting evidence. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

Volume 4

Evaluation, safety, and failure

Coming soon

Before go-live, you need a way to say the workflow is good enough — and a clear view of how it fails.

B4.01Coming soon

What "good" looks like for a workflow

Outcome: You can turn the business owner's idea of a good week into checks you can run.

  • Accuracy, time-to-approval, and unhandled exceptions beat model-benchmark folklore.
  • Agree the bar in writing before you start tuning.
  • Score three layers: the task (accuracy, edit rate, how often a person takes over), the workflow (cycle time, rework, waiting, first-time-right), and the business (days to pay, supplier disputes). Add a guardrail and a before-and-after baseline.

Lab B4.01: Version a three-layer scorecard before tuning. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B4.02Coming soon

Evaluation sets from real cases

Outcome: You can build a small, anonymised set of past items that includes the awkward ones.

  • Happy-path samples alone will pass a bad design.
  • Use synthetic data in public labs. Tokenisation alone does not anonymise data or authorise export; reuse requires rights, confidentiality and privacy review.
  • Ask the person who does the work today to score the awkward cases. Record disagreements and independent labels; owner preference cannot waive mandatory control floors.

Illustrative only: a single small internal practitioner run, not a performance guarantee. The same model and harness answered eight real questions from a personal vault: one arm explored freely, while the other scored an index, opened one best file and attached an evidence block. The free-exploration arm already had a compiled wiki and the questions were not held out. Both arms scored 8/8; reported average times were 63.6 versus 25.2 seconds (about 2.5× faster for retrieval), variable tokens were 96 thousand versus 66 thousand (about 31 percent fewer), and tool calls were 22 versus 8. The underlying evidence has not been independently verified, and the source store was not fully searched. These results do not establish causation or predict quality, cost or speed on other work.

Lab B4.02: Evaluate awkward cases against independent owner labels. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B4.03Coming soon

Policy is not a prompt

Outcome: You can keep permissions and gates in enforceable config, not in instructions the model may ignore.

  • Prompts shape drafts; they do not replace access control.
  • If the only copy of a rule is in natural language, it is a hope.

Lab B4.03: Show why prompts cannot replace controls using isolated doubles. See the cumulative fixture/assertion contract in the lab specifications. (~45 min (pilot estimate))

B4.04Coming soon

Testing the gate, not just the draft

Outcome: You can test skipped gates, stale approvals, expired requests, and backup approvers.

  • A good draft that can be sent without a pass through the gate is a failed test.
  • Automate the unhappy paths; do not only demo the happy one.

Lab B4.04: Turn earlier invariants into an adversarial release suite. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B4.05Coming soon

Failure modes: skipped gates, silent writes, log gaps

Outcome: You can name the failure modes that matter, and show how the design blocks them.

  • The dangerous bugs look like success.
  • If you cannot detect a missing log event, you will not find it in an incident.

Practice note: A check that under-reports is worse than no check, because it ends the search. State what a check covers whenever you report what it found. A secret scan must be a real gate: it has to see what will actually be committed, and a piped or empty run is not a pass. Measure a stale page against its live source before you rewrite it.

Lab B4.05: Detect silent writes and incomplete records without hiding uncertainty. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B4.06Coming soon

Human override and correction loops

Outcome: You can take a correction from an approver and feed it back into config, retrieval, or eval — not only into a chat.

  • Overrides are logged.
  • A pattern of overrides is a change request.
  • Approvals need checking too. Rapid approvals are a heuristic flag for review workload and evidence presentation, not proof that the approver did not read.

Lab B4.06: Convert corrections into reviewed changes and measure approval workload. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B4.07Coming soon

Cost, latency, and model choice without drama

Outcome: You can pick a model for a step based on the cost of being wrong, not on habit.

  • Matching a line item and drafting a delicate supplier email are different jobs.
  • Track spend per workflow, not only per tenant.

Practice note: Compare deterministic and model-based routes against quality, latency, cost and human review effort. Attribute tokens to the work they served — the opportunity, the project, the person, and the artifact — not only to a single bill.

Lab B4.07: Choose routes from quality, latency, cost and reviewer effort. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B4.08Coming soon

Red-teaming a workflow before go-live

Outcome: You can try to make the agent exfiltrate, over-send, or skip a gate, and record what you found.

  • Include a person who did not build the workflow.
  • Fix all critical control findings. Only noncritical residuals may have authorised owner/reviewer acceptance with compensating controls and an expiry.

Lab B4.08: Run realistic offline attacks and constrain residual-risk acceptance. See the cumulative fixture/assertion contract in the lab specifications. (~90 min (pilot estimate))

Volume 5

Deploy, observe, and hand over

Coming soon

Taking the workflow from a working design to something the customer can live with — and that the next engineer can understand.

B5.01Coming soon

A quiet pilot in one team

Outcome: You can scope a pilot with real data, real approvers, and a tight blast radius.

  • One team, one workflow, one week of daily presence.
  • Sending and paying stay gated; some pilots keep the last mile off entirely.
  • Write the go-live conditions before the pilot starts (eval bar met, gate tests green, revocation tested, on-call named, owner briefed), and check them on the day.

Practice note: Use fictional work for the first supervised trial and keep human review mandatory. Time to first useful result was the test. In one case the build took days while access took weeks, and a data-quality issue held the result below the target.

Lab B5.01: Prepare a bounded local pilot with real readiness evidence. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B5.02Coming soon

Environments, config, and promotion

Outcome: You can promote a workflow the way you would promote any other production change.

  • Config is reviewed; secrets are not in the brief.
  • There is a way back if the new version misbehaves.

Lab B5.02: Promote and roll back a reviewed configuration in the local simulation. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B5.03Coming soon

Observability: status, blocks, and traces

Outcome: You can show idle, working, blocked, and failed in terms the business owner already uses.

  • A trace should lead from a business item to the log event, not only to a request ID.
  • Alert on silent stalls, not only on hard errors.
  • Each week, look through four lenses: quality, risk and compliance, the people and the business it serves, and cost.

Lab B5.03: Expose status and a scoped operational summary from evidence. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B5.04Coming soon

On-call for an agent that does real work

Outcome: You can define who is called, during what hours, and what they are allowed to do.

  • "The model was down" is not an incident close.
  • Include a path to freeze the workflow.

Lab B5.04: Operate freeze, recovery and accountable incident escalation. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B5.05Coming soon

When the model or the tool moves

Outcome: You can re-run evals and review gates when a model, connector, or permission changes.

  • Treat those changes as releases.
  • The four-part model is how you decide whether the handoff is still intact.

Practice note: The tools under a fleet will change. Keep the pattern — identity, memory, gates, a check-in, cost discipline — and treat a stack change as a release, not a rewrite of the operating idea.

Lab B5.05: Treat a model or connector change as a versioned release. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B5.06Coming soon

Documentation the next engineer can use

Outcome: You can leave a short pack: diagram, scopes, gates, log location, revocation steps, known exceptions.

  • If it only exists in your head, the customer does not have a system.
  • Write it so the business owner can recognise the workflow in the first page.
  • Answer the owner's five questions: who answers for the result, who controls access, how errors are found, how to roll back or freeze, and where the record of each decision lives.

Lab B5.06: Prove a handover pack works for a different operator. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

B5.07Coming soon

Customer handover at steady state

Outcome: You can hand the workflow to the owner with least privilege still in place.

  • Your temporary admin access should expire.
  • The customer should be able to add a backup approver without calling you first.

Lab B5.07: Remove temporary authority and leave bounded owner administration. See the cumulative fixture/assertion contract in the lab specifications. (~60 min (pilot estimate))

B5.08Coming soon

From one workflow to a small fleet

Outcome: You can reuse the pattern without copying privileges from the first job to the second.

  • Each workflow earns its own scopes and gates.
  • A fleet without a shared log and a shared review is just a pile of agents.

Practice note: A founder can run a small fleet of specialist agents behind a manager that routes the work, with a short session identity and a daily memory, and with spend visible enough to adjust.

Lab B5.08: Add a second workflow with isolated data and shared authorised oversight. See the cumulative fixture/assertion contract in the lab specifications. (~75 min (pilot estimate))

Volume 6

The FDE in the room

Coming soon

The "forward-deployed" half of the job. This volume brings the FDE model forward from Track E and teaches the customer-facing skills that reading and labs cannot: discovery calls, scoping, saying no, and the weekly check-in. Each module ends in a studio — a written or role-played exercise against Lane & Hoy, reviewed with the same honesty as a lab, but not auto-checked by a compiler.

B6.01Coming soon

What a forward-deployed engineer actually does

Outcome: You can state the job in the customer's language: sit in the work, find the real workflow, write a reusable method, and leave the owner able to run it.

  • You are not there to install a demo and leave.
  • Success is a harness the customer still uses the following month.
  • Go-live is not the finish line. You are done when the owner can run it, and the next engagement starts with a method and evidence it can reuse.

Practice note: An FDE's job is to find the real workflow, write a reusable method, and leave the owner able to run it. Plan time for access and data-quality work, not only implementation.

Studio B6.01: Rewrite a "we installed the agent" trip report as a one-page job statement for Lane & Hoy, in Mei's words, with a definition of done the owner can run next week. (~45 min)

B6.02Coming soon

Discover the real workflow and the harness

Outcome: You can treat the first weeks as discovery of how the work really runs — and of memory, context, verification, tools, and guardrails as they actually are.

  • The diagram you arrived with will be wrong in useful ways. So is the process manual.
  • Where systems keep timestamps, read them. The real path, with its rework loops, detours, and long waits, shows up in the event log, not in the manual.
  • Much of what drives the work never enters a system: a call, a chat thread, someone's memory. Write down what you found in the customer's language.

Studio B6.02: From a Lane & Hoy discovery packet (how invoices actually arrive, who really approves, where exceptions hide) and a month of order-to-cash event logs, find the rework loop and the longest wait. Then map memory, context, verification, tools, and guardrails as they are — not as the arrival diagram said. (~75 min)

B6.03Coming soon

The discovery call

Outcome: You can run a first conversation that finds the work, the owners, the tools, and the gates, without turning it into a product tour.

  • Ask where the work lives today, what "done" looks like, who signs off, and what must never go out alone.
  • Leave with one candidate workflow, or with a clear reason there is not one yet.

Studio B6.03: Use the supplied incomplete brief for a live reviewer-run discovery and scope role-play; record the actual constraint, owner response and resulting change in the one-page notes. (~60 min)

B6.04Coming soon

Scoping a first workflow

Outcome: You can cut a first job that is frequent, bounded, and judgeable, and write a brief the owner recognises.

  • Prefer a weekly burden with a clear "done" over a rare, political process.
  • Write the time to first useful result test before you start building.
  • Redesign before you automate. For each step, ask whether to remove it, merge it, run it in parallel, check it earlier, or keep it with a person. Then place it on the certainty × consequence grid.
  • Make an honest value estimate: the volume that applies × how much of it will really be used × how often it completes correctly × the value of each one. Subtract the costs teams forget: exceptions, review time, changing how people work, and the expected cost of a mistake. Show the arithmetic. Never borrow a vendor's ROI figure.

Practice note: Two short, bounded pilots beat one broad programme. Pick a job you can already describe, and measure time to first useful result — how quickly a real user sees a useful result — not completeness.

Studio B6.04: Scope Lane & Hoy AP as a one-week quiet trial. Write the outcome, the tools, the gates, the named approver, and the time to first useful result test. Place each step on the grid, show one redesign you would make first, and write a one-paragraph value estimate with the hidden costs. Leave out everything that belongs in a later phase. (~75 min)

B6.05Coming soon

Saying no

Outcome: You can decline a request that would break the promise — no interceptable gate, no owner, no way to judge "good", or a blast radius you cannot defend — and offer a smaller path where there is one.

  • "The model can probably do that" is not a scope.
  • A clear no, with a reason and an alternative, is part of the job, not a failure of it.

Studio B6.05: Answer three Lane & Hoy requests: auto-send under SGD 500 in week one; tenant-wide mail "just in case"; and a same-week payment run with no named backup. Say no, or recut, in writing. (~45 min)

B6.06Coming soon

Reusable methods as a first-class deliverable

Outcome: You can package what worked as a short, reusable briefing — a method, not only a working tenant.

  • If it only works in one room, you have a favour, not a product.
  • The briefing should be something the next FDE can pick up.
  • State its level: used once, reusable (de-identified, structured, passed an independent reuse check), or standard (held up in two or more engagements). A method moves up a level only when it works without the original customer's setup, has evidence such as an eval set and a baseline, and its reuse can be counted.

Studio B6.06: Turn the AP quiet-trial design into a two-page method another FDE could take to a different wholesaler. Mark the Lane & Hoy specifics clearly as examples, remove every personal and customer detail, and state the level you are claiming and why. (~60 min)

B6.07Coming soon

Human review, and try the workflow on fictional work first

Outcome: You can keep a person in the loop for quality, and you can run the method on your own work before you take it to a customer.

  • Human review is part of the method, not a temporary crutch.
  • An internal trial surfaces access problems, data-quality problems, and unclear briefs early.

Practice note: Run a quiet internal trial first, on your own work. Human review of the output is mandatory. Package what worked as a reusable briefing, then take two small external pilots rather than one large one. Access to data often takes longer than the build; plan for that.

Studio B6.07: Design a one-week internal trial of the AP method on a fictional training mailbox and a fictional supplier set, with mandatory human review and a written list of what you expect access and data quality to teach you. (~45 min)

B6.08Coming soon

The weekly check-in rhythm

Outcome: You can run a fifteen-minute weekly check-in the business owner will actually attend, and a shorter daily glance for blocks and pending approvals.

  • Start from exceptions, overdue gates, and odd spend — not from a tour of what went fine.
  • Write one decision, not a report.

Practice note: A standing weekly write-up that reconciles the week's work into one account is more useful than a chronicle of meetings. Organise it by goals and results. Keep a short reflection on one problem and a decision, then check the following week whether it closed. An agent can help draft from the record; the person who owns the week still edits and sends it.

Studio B6.08: From a week of Lane & Hoy log excerpts (two mismatches, one overdue approval, one silent stall, a quiet Thursday), write the fifteen-minute agenda, the decision you would take, and the note you would send Mei. (~45 min)

Volume 7

Capstone, sign-off, and shadowing

Coming soon

The assessed end of the programme. The learner deploys an agent for a mock Lane & Hoy brief, is reviewed against a deploy-ready rubric, and then completes supervised integration/incident work and shadowing, followed by a senior’s explicit decision before a first reviewed lead engagement.

B7.01Coming soon

Quiet pilots, then package

Outcome: You can take two small, time-boxed pilots rather than one large programme, and package after the first useful result.

  • Time to first useful result is the test.
  • A second pilot is how you find out whether the method travels.

Studio B7.01: Propose a two-pilot plan for Lane & Hoy: AP first, then a tightly scoped support-triage follow-on, with a packaging step between them. (~45 min)

B7.02Coming soon

Access is part of the critical path

Outcome: You can plan for access, processing authority, and data quality as if they were the build — because they often take longer.

  • A four-day build with a three-week access wait is still a three-week-plus project.
  • Tell the customer that, early, in calm language.

Practice note: Plan time for access and data-quality work, not only implementation. In one later case the build took days while access took weeks, and a data-quality issue held the result below the target.

Studio B7.02: Write the access plan for the capstone: who grants what, what you will do while you wait, and the sentence you will say to Mei when a grant is still outstanding on day four. (~45 min)

B7.03Coming soon

The Lane & Hoy capstone brief

Outcome: You can read a customer brief, ask the questions it leaves open, and refuse to start building until the outcome, gates, and approver are named.

  • The capstone changes from familiar AP to delivery exceptions, with an unseen constraint and owner reply controlled by the reviewer.
  • Write back before you code.

Studio B7.03: Read the capstone brief, list the open questions, and send a one-page reply that either confirms the scope or recuts it. Do not start the build in this module. (~60 min)

B7.04Coming soon

Capstone: discovery and scope

Outcome: You can run discovery against the Lane & Hoy packet, write the four-part handoff, and get a (mock) owner sign-off on the scope before you build.

  • One workflow, one team, one time to first useful result test.
  • Saying no, or recutting, is allowed and sometimes required.

Capstone phase 1: Produce a discovery note, a scoped brief, a role and scope map, and a written time to first useful result test, and obtain the reviewer-controlled mock owner decision after live discovery/scope role-play. The candidate cannot sign for the owner. (~half a day)

B7.05Coming soon

Capstone: build, evaluate, and deploy

Outcome: You can implement the scoped workflow in the starter repo, pass the eval set and the gate tests, and promote it to a quiet pilot configuration.

  • Sending and paying stay gated. Some candidates will keep the last mile off; that is a defensible choice if the brief allows it.
  • Unhappy paths are tested, not only the demo path.

Capstone phase 2: Build, eval, red-team, and promote the workflow. The cumulative suite must pass, and the reviewer injects an unfamiliar partial-failure, expiry or evidence fault. Diagnose it and justify any refusal or rescope; evidence decides the result. (~two to three days)

B7.06Coming soon

Capstone: handover and review

Outcome: You can leave a handover pack the owner and the next engineer can use, expire your temporary access, and sit a review of the whole path.

  • The first page should be recognisable to Mei.
  • Temporary admin access should already have expired before the review starts.

Capstone phase 3: Have another operator diagnose, freeze, revoke, reconcile and add a backup using only the handover pack. Submit their observed results, eval/red-team evidence and one de-identified asset with an honest level. Temporary access expires before review. Present at the monthly capstone review judged by FusionWork executives: a 1-hour slot with 30 minutes of presentation, 15 minutes of Q&A and 15 minutes of buffer. (~half a day for handover preparation/exercise, plus the presentation and any revision)

B7.07Coming soon

Deploy-ready sign-off

Outcome: You can read the rubric, judge your own capstone against it, and understand what a reviewer will and will not pass.

  • Identity, gates, and the log are must-pass. A strong demo does not offset a skipped control.
  • "Deploy-ready" means ready to shadow, not ready to be left alone at a customer.

The rubric and the checklist are in the lab specifications, and are summarised at the end of this volume. FusionWork executives judge the capstone and score the assessment against the rubric, using studio and practical evidence gathered with technical reviewers. Evidence collection, role-play and operator exercises happen separately from the monthly 1-hour presentation slot; the slot does not lower the assessment bar. The learner also self-scores first; the gap is useful.

Studio B7.07: Score your capstone against the rubric, write one paragraph on the weakest must-pass area, and list the work you would still do before a real shadowing week. (~45 min)

B7.08Coming soon

Shadowing before you lead

Outcome: You can explain how pairing on one real engagement works, what you may do, and what you must not do, before you lead your own.

  • Shadowing happens off the site, on a live engagement, with a named senior FDE.
  • The academy can only prepare you for it and ask you to write it up honestly afterwards.

The shadowing guide lives in the lab specifications. It is a brief for the learner and the senior, not a public case study of any customer.

Studio B7.08: Write your shadowing plan: what you want to observe, the limits you will keep, and the after-action format you will use. Do not name a real customer. (~30 min)