All Courses
78 courses across 12 categories
Automating Security Finding Triage
Build an agent workflow that turns automated security findings into the right action: which severity blocks a merge, how to order a leaked-secret response, and when dependency fixes can be automated safely.
Autonomous Coding
AI pair programmer that writes, tests, and deploys code.
Bounded Rollouts and Guarded Writes
Two quiet failures share a shape: a change that looks fine until the conditions vary. A canary rollout without a fixed rule tells you nothing, and a write that does not check the version it read erases another writer's work. This course covers fixing the rollback rule before the numbers arrive, widening a rollout in steps, guarding a write with the version it read, and rebasing on a rejected write.
Budgets and Limits for Agent Work
An agent system is governed by numbers: an error budget that decides when change slows, a quota that keeps one tenant from filling a shared pool, and a request key that stops a retry from doubling an effect. This course covers turning a reliability target into a budget, enforcing a hard quota at admission, suppressing a repeat request, and setting a limit before the work rather than after.
Changing Config and Shape Safely
A live agent system is changed in three ways that are easy to get wrong: a config edit that needs a restart, a feature flag that never gets retired, and a shared shape that is altered in one step instead of two. This course covers reloading config while the agent keeps running, retiring a flag once it stops deciding anything, moving a shared shape in two deployments with a backfill between them, and preferring a change that has a way back.
Changing Secrets and Prompts Without a Gap
The two things most often edited in place in an agent system are the credential it holds and the prompt it sends, and both can break a run the moment they change. This course covers rotating a secret while old and new callers both work, versioning a prompt so a result can be tied to its text, freezing change in a named window, and making a change you can take back.
Consistent Reads and Reproducible Runs
Two kinds of agent problem that both come from a run reading a world that keeps moving. A decision built from records read at different moments can match no single state of the system, and a failure that will not repeat cannot be studied. This course covers reading one consistent snapshot, backfilling a window a stopped consumer missed, replaying a failing run from its transcript, and carrying a run across models without losing the thread at the handover.
Deadlines and Cancellation in Nested Agent Calls
A parent agent run has one deadline, but the tools and subagents it calls each tend to bring their own default timeout. This course explains why a child must never outlive its parent, how to derive a nested timeout from the remaining budget using a monotonic clock, why cancellation must be modelled as a distinct outcome from failure, and how to return useful partial results when the clock runs out midway through a batch. Each lesson includes a small worked example and the failure mode it prevents.
Detecting Silent Failure and Gating Changes
Two habits that keep an automated pipeline honest: proving a run actually did useful work rather than merely exiting cleanly, and gating a prompt or model change on a frozen eval set instead of a demo. Covers gray failures, progress invariants, post-run assertions, and a fixed-threshold eval gate with a warm fallback.
Durable Intent and Recovery for Agent Runs
An agent run that changes the world needs a record of what it means to do before it does it, and a way to replay old work without starving live work. This course covers recording the intent before the effect, throttling a backfill so it does not starve live work, requiring a second approver for high risk actions, and recovering a run by reading its record rather than its memory.
Fair Queues and Deletions That Stick
Two failures that look unrelated share a cause: a rule that is applied once and never revisited. A strict priority queue starves its lowest class, and a delete without a marker lets an old copy return through a replay. This course covers aging and reserved capacity for fair queues, and tombstones that refuse stale writes, expire on a schedule, and report every refusal so the source can be fixed.
Guarding Secrets, Memory and Claims in Agent Runs
An agent handles credentials, keeps notes across runs, and writes claims that a reader will act on, and each of those is a place where something can be lost. This course covers revoking a leaked credential in a hurry, keeping the system prompt from leaking through side channels, resolving memories that contradict each other, and marking unverified claims before reporting.
Joining and Moving Parallel Agent Work
A fan-out and a worker pool share one failure that is easy to miss, which is work that is quietly lost while every surface looks healthy. A join can complete on a partial set, and a rebalance can leave a job owned by nobody or by two workers at once. This course covers waiting for every branch before joining, treating a failed branch as a result, moving jobs between workers without losing one, and changing a shared record shape without breaking an old reader.
Leading and Sharing a Worker Pool
A pool of agent workers has two failure modes that look unrelated. Leadership can be held by nobody, or by two workers at once, and one heavy run can take the concurrency and call budget that every other run depends on. This course covers holding leadership as a lease with a fencing token, promoting a warm standby on the lease rather than a timer, capping a single run within a fair share of the pool, and finding the heavy neighbour by attributing cost to each run.
Leases and Fencing Tokens for Shared Resources
Two workers, one shared resource, and a worker that does not know it is late. This course covers time-boxed leases that expire without cooperation, monotonic fencing tokens that let the resource reject a stale writer, the clock-skew trap in naive expiry checks, correct behaviour when renewal fails, and why a scheduled run that crashes while holding a plain lock is worse than a run that never started.
Moving Live Work Without a Gap
Two ways to change a live system with less risk than a plain stop and start. A new version can run beside the old one so the change is one move and the return is one move, and a small set of workers can be kept warm so a burst never waits for a cold start. This course covers bringing a second version up beside the running one, holding a warm pool, hedging a slow call without doubling every call, and putting a bound on the age of a stored answer.
Moving Sessions and Tools Without a Gap
A live agent session moves between regions and depends on tools whose reply shape can change without warning, and both are easy to get wrong. This course covers moving a session to another region without a gap, pinning the tool version a workflow was tested against, running the work that fits the remaining budget, and changing one thing at a time when the session is live.
Moving State and Reserving Capacity
Agent state moves and competing work share fixed resources, and both are easy to get wrong when the system is live. This course covers moving a session between models without losing its place, sizing a connection pool before it runs dry, reserving capacity for work that cannot wait, and leaving headroom so a fix is not needed on the busiest minute.
PR/Code Review
AI-powered code review bot for your team.
Pulling Work and Retiring a Tenant
Two kinds of agent housekeeping that look unrelated and share a shape: neither is about making a change, both are about not leaving a mess. A fixed assignment leaves workers idle beside a full queue, and a tenant deletion that trusts one store leaves data behind. This course covers one shared queue with pull based dispatch, stealing from the busiest list, preparing and committing a group of tool calls together, and retiring a tenant by enumerating its whole footprint first.
Rehearse a Change and Retire an Old Tool
Two ways a change reaches production with less risk than a plain cut over. A new version can answer copies of real requests before it serves anyone, and an old tool call can be retired over a window instead of removed in one step. This course covers mirroring live requests, holding back the effects of a copy, checking a tool reply against the shape the caller depends on, and watching the callers of a deprecated tool until the list is empty.
Rehearsing Failure and Expiring Old State
A system is only as sound as the failure it has rehearsed and the state it is willing to let go. This course covers injecting one fault at a time to watch the recovery path, writing a blameless postmortem that ends in tracked changes, setting a time to live on records so old state leaves on a clock the system controls, and closing the loop between a fault and a fix.
Research Reports
Auto-generate research reports on any topic.
Resuming and Restoring Agent State
An agent run that is dropped mid flight, or a store that is found to be wrong, both raise the same question: what state can be trusted and how is it put back. This course covers validating a reply before it is used, resuming a session from its last confirmed point without replaying work, restoring a snapshot to a named point in time, and recovering from where the run stopped.
Retrieval and Boundaries for Agent Runs
Four habits for agents that find things and act on them: ordering retrieved candidates by the real question, choosing a chunk size that lets the answer survive, pinning a run to the region its data may live in, and placing a moderation gate between reading untrusted content and acting on it.
Watching and Agreeing on State
A live agent system is hard to read when logs are too large to search and waits are blamed on load, and it is hard to trust when a write is called done too early. This course covers sampling logs without losing the errors, telling a scheduling wait apart from load, confirming a write against a majority before calling it done, and measuring the wait before choosing a fix.
YouTube/Podcast Factory
Repurpose long-form content into multiple formats automatically.