Learn

The Agent Loop: think, call, observe, repeat. Write the loop yourself in thirty lines, watch it spin forever, then add a stopping condition and a step budget.

Planning and Task Decomposition: have the agent plan a task that will not fall to one step, write the plan out as its own artefact, and execute it step by step. Build the replan trigger for when the plan meets reality, and see when planning end to end is just wasted tokens.

Multi-Agent Orchestration and Sub-Agents: compare supervisor and worker, handoff, and parallel fan-out on the same task. Tell apart when isolating context in a sub-agent pays for itself and when it is only latency and invoice.

Queues, Events and Durable Execution. Take the agent out of the request and response cycle: work queues, event triggers, retryable steps, and stopping the same job from running twice. Restart the server mid-run and show the work carries on where it left off.

Long-Horizon Agents. Agents that run for hours and across sessions: durable state, checkpoints, resume after interruption, progress reporting. Kill the process on purpose and prove the work survived.

Computer and Browser-Using Agents: reach a system that has no API through its screen. Finding elements, waiting, verifying, undoing, and making a wrong click cheap instead of expensive.

Calling a Model from Code: send the first request, stream a response, write your own retries and error handling, hit a rate limit. Reconcile the invoice line against the tokens you counted yourself.

Transformers, Off the Shelf: open the architecture everything else in this branch runs on. Attention as a weighted lookup you compute by hand on eight tokens, then the same thing at scale, then a pretrained model whose config and parameter count you read yourself.

Progressive Disclosure of Instructions: not every instruction belongs in every request. Split your instructions into units the agent loads only when it needs them, give each one a name and a one-line summary, and let the agent decide what to open.

Context Compaction and Handoff: long tasks fill the window. Compare summarising, pruning, external notes and handing off to a sub-agent on the same task; add a check that catches the critical detail compaction loses.

Prefix Caching and Context Stability: keeping the head of your context stable can halve both the invoice and time-to-first-token. Design a cache-friendly context order, measure the hit rate, and catch the small change that quietly breaks it.

Knowledge Ops: Freshness, Provenance, Citation. Track as a system which document an answer came from, when that document last changed, and when it went stale. Treat an uncited answer as never shipped.

The Data Pipeline for AI: ingestion, cleaning, PII masking, lineage tracking and retention. Being able to say where every row the model saw came from.

Release Units and Packaging: model, prompt, tool definition and policy are one release unit. Let them change separately and nobody can say which combination is live. Tag all four together, build a pipeline that cannot ship without passing evals, and use the rollback path once for real.

Collecting Signal from Users: a thumbs-up is not enough. Gather the implicit signals such as edits, abandonment and asking the same thing again, feed them into the eval set, and build a weekly improvement loop.

Streaming Interface Engineering: sSE and WebSocket, token-by-token render, partial output, cancellation, resume after a dropped connection. Slow the network down on purpose and prove the interface does not freeze and the half-answer is not lost.

Agent UI: Steps, Tools, Interruption. The user should see what the agent is doing and be able to step in. Step lists, tool call display, live steering and stopping; test how much detail builds confidence and how much is just noise.

Generated Interface. Have the model return interface rather than prose: components from a schema, results that become tables, answers that produce forms. Draw the security boundary for running model output on screen, then push on that boundary with your own injection test.

Fine-Tuning: SFT and LoRA. Fine-tuning is usually unnecessary, and when it is necessary there is no substitute. Try prompting and few-shot first; when that runs out, train with LoRA and compare both on the same eval set.

Preference Tuning and Distillation: shaping behaviour with preference data; training a small model on a large one's output. Show with numbers when the cheap fast model is already good enough.

Policy Gates and the Audit Trail: make every capability pass through one gate. Classify risk, put human approval on the high end, keep an end-to-end audit trail. Pick a rule pack from the policy catalog and extend it with your own.

Compliance and Accountability in Practice: model cards, data statements, use limits, weight and dataset licence compatibility, record retention and incident reporting. Set audit-readiness up as engineering work rather than paperwork.

GPU Capacity and Cold Starts: model load time, warm pools, autoscaling, spot interruption and quota. Make a service whose first request waits thirty seconds acceptable; see the bill for an idle GPU.

MLOps and LLMOps: What Carries Over, What Breaks. Versioning, registries, monitoring and CI transfer intact. A single accuracy number, a stable input distribution and deterministic output do not. Build the same feature from both viewpoints and list which classic MLOps habit turns into a trap here.

Prompt Registry and Traffic Splitting: prompts and context templates are release artefacts. They enter a registry, take a version tag, and see a percentage of traffic. Compare two versions live on quality and cost, and pull the loser with one click.

The Continuous Evaluation Pipeline. The eval is itself a system that needs maintenance: flaky tests, a golden set going stale, the eval's own token bill. Separate what blocks a release from what only warns; put regression gates on cost and latency too.

Guardrail and Filter Operations: gOV 201 builds the gate; this course operates it. Measure the false positive rate, tune the threshold, update the block list and price the latency the filter adds. See on your own users how an over-tight guardrail makes a product unusable.

The Control Tower: cost, latency, quality and error rate per feature, per model and per prompt version, on one panel. Set budget alarms, produce a capacity plan, and answer "why did we get expensive last week" in ten seconds.

Provider Migration and Model Retirement: the model you depend on is shutting down and you have six weeks. Build the abstraction layer ahead of time, write the eval provider-agnostically, compare with shadow traffic, and finish the migration without the user noticing.

Model Context Protocol Basics: try ready-made servers to see how MCP standardises tools, resources and prompts. Pick an MCP server from the catalog, then run the same agent again with the server swapped out.

Writing Your Own MCP Server. Write a server against a real system: tool naming, error message design, how much data one call should return. Measure how a badly written tool makes a capable model look stupid.

MCP at Scale: Registry, Identity, Permission. With a hundred tools available, which does the agent see? Server registration, scope management, OAuth flows, and winning back the selection accuracy that drops as the tool count climbs.

Agent Memory: what should it remember and what should it forget? Separate the episodic log, the summarised profile and the fact store. Manufacture the case where memory learns something wrong, then fix it.

Experiment Tracking and Reproducibility. Record every run: data version, hyperparameters, code commit, seed, environment. Reproduce your best result from three months ago today, and retire "it worked in the notebook" with a system instead of a promise.

Model Registry and the Promotion Path: where do models live, which one is in production, who approved it? Pick a registry from the registry catalog, put promotion from staging to production under a rule, promote two models for real, and roll back to the previous version with one command.

Classic Model and LLM Together. Most real systems are hybrids: a gradient boosting model gives the score, an LLM writes the explanation. Manage two lifecycles inside one product, where one gets retrained and the other gets re-prompted, and record which one actually made the decision.

Training and Feature Pipelines: make the chain from data to feature to training to evaluation to release scheduled and re-runnable. Manufacture the silent bug where a feature is computed differently in serving than in training, then catch it.

Drift Detection and Retraining: input drift, label drift, performance decay, and which of them deserves an alarm. Write the retraining rule, define what happens when it fires, and show with one example how automatic retraining can make the system worse.

Batch and Online Inference: run the same model as a nightly batch job and as a low-latency service. Test that both paths give the same answer to the same input; when they do not, find where the difference comes from.

Image and Document Understanding: invoices, forms, screenshots, scanned tables. Extract fields while preserving page layout, catch the invented field, and route below-threshold confidence to a human rather than into the database.

Multimodal Retrieval: search images with text and text with images. Build a shared embedding space, index it beside your text chunks, and answer one question from both. Find the query where the image index confidently returns the wrong picture, and explain why the score was high.

Real-Time Voice Agents: interruption, latency budget, turn-taking and half-duplex failures. Build a phone-quality voice agent by measuring milliseconds.

Video and Long-Form Media: an hour of video does not fit in a context window. Segment it, pick keyframes, align the transcript to the picture, and answer a question whose evidence is at minute fifty-two. Measure what you lost at every sampling decision.

Image and Video Generation Pipelines. Set the generative model up as a pipeline, not a one-off toy: prompt template, consistency check, variant selection, human approval, provenance stamp.

Cross-Modal Agents: an agent that sees the screen, clicks, and explains the result. Bind visual observation to tool calls; measure the error that accumulates at modality boundaries and put a cut-off in.

Running an Open-Weight Model Locally: download it, run it, put your own API in front of it. Compare two open-weight models on latency, quality and memory, and read both licences first, because one of them decides whether you can ship what you built.

Quantisation and the Memory Budget: what are you losing going down to 4 bits? Measure the loss per task, decide where it does not matter, and pick the best model that fits the hardware you actually have.

Inference Engineering: kV cache, continuous batching, speculative decoding, prefix cache, and constrained decoding that makes a schema a property of the sampler rather than a request in the prompt. Get twice the throughput out of the same hardware by measuring rather than guessing.

Small Models and the Edge: what can models between 1B and 8B actually do? Hand routing, classification, field extraction and tool selection to a small model; run it on a phone or in the field with no network.

Agent Tracing and Observability: make every step, every tool call, every token visible. Pick a backend from the telemetry catalog, then solve a broken run handed to you using nothing but the traces.

The MCP-Native Agent Product: your own MCP server, your own agent, your own interface, your own eval set and your own cost budget. One project from nothing to a real user, and at the end, a numeric answer to why this design.

The Agent That Ships Code. An engineering agent that runs from issue to merged PR: repo context, running tests, self-verification, human review and a path back out.

The In-House AI Platform. The shared layer ten people will use safely: model registry and routing, tool registry, policy gate, cost accounting, and a new team able to connect in a day.

Incident Response: you are handed a broken production system. Start from the traces, form a hypothesis, find the cause without writing a line of code; then fix it and leave a regression test behind.

One Agent, Four Surfaces: run one agent on chat, an embedded widget, a command line and voice. Solve streaming, interruption, partial results and error states separately on each, then separate what is surface-specific from what is shared.

Small Model as a Service: take one narrow job a frontier model is doing today. Fine-tune a small open-weight model for it, prove on a held-out set that it is good enough, and route back to the frontier model when it is not confident.

Shipping an AI Feature: shadow mode, staged rollout, kill switch, live monitoring and a retirement plan. Turn the first real user from an event into a routine.

Prompt Systems and Versioning. A prompt is a code artefact: versioned, diffed, tested, reverted. Assemble patterns as parts from the prompt pattern catalog and manage the template explosion before it manages you.

Reasoning Models and Test-Time Compute: thinking became a setting. Compare long thinking, sampling plus voting, and self-verification on the curve of cost against accuracy, and show the tasks where none of it helps.

Failure Engineering and Model Migration: retries, fallback models, circuit breakers, timeouts and partial success. When the provider goes down or the model version changes, catch with regression what quietly broke.

Intent Routing: not every request belongs in the same pipeline. Split requests with a cheap classifier into chat, search, action and refuse, and measure the cost of routing wrong. Decide yourself what happens when the router is unsure.

Clarifying an Ambiguous Request: what does "fix this report" mean? Detect the missing information, put the ask-or-assume decision under a rule, and stop asking three things in one question. Measure that asking unnecessarily also has a cost.

Request Triage: Speed and Cost Classes. Giving every request the same budget is both expensive and slow. Build a fast-path and deep-path split, show the estimated wait, and decide what gets dropped under load before the load arrives.

Multi-Model Routing and the Fallback Fleet. Build a router that picks the right model per task: cheap model first, large model when it struggles, backup when the provider drops. See the price of routing without measuring the quality you give up.

Prompt Injection and Untrusted Content: hijack your own agent with a single sentence buried in a web page it reads. Learn to separate data from instruction, to cut tool permissions, and why writing a better prompt does not fix this.

Structured Output: make the model fill a schema instead of writing prose. JSON schema, enums and required fields turn output into something your program can use; catch the answer that breaks the schema and repair it without breaking the flow.

Code Execution as a Tool. The most common thing an agent is handed is a Python process. Give it one: capture stdout and tracebacks, cap wall clock and memory, decide what survives between calls, and hand the error back in a shape the model can act on.

Designing AI Interfaces: streaming responses, waiting states, showing uncertainty, undo, editable output. Use the interface to manage when the user trusts the model and when they should not.

Human-in-the-Loop Flows: which action deserves approval? Design approval gates by risk level, measure approval fatigue, and make the case for leaving reversible actions ungated.

Automation or Agent?: most problems do not want an agent. Build the same job three times as a fixed workflow, a routed flow and a free-running agent, compare reliability and cost, then pick the most boring one.