The curriculum

Overview

We bring together experienced engineers from different industries and work through the modern deep learning and agentic engineering stack. You come in one afternoon a week, for 58 workshops. With breaks, that takes about 15 months. The programme runs in three terms, with breaks at Christmas, in the spring and at the end of the summer, and the week numbers count teaching weeks only. If you want to move faster, you can finish after 12 months.

The work is meant to be used. Four of the seven modules are projects, and if your employer has a problem that fits, you work on that. In the last module you build an AI system for your employer and put it into service.

The first thing you write is a coding agent, from scratch. We give you a server, and you turn it into a Kubernetes cluster and serve the models you train from it for the rest of the programme. You build retrieval with hybrid search, reranking, and an agent that searches for itself. Later you build a transformer from the ground up in PyTorch. In Frontier ML each afternoon goes to one paper, read in the room and reproduced at small scale.

We provide a server, GPU access, and OpenAI, Claude and OpenRouter credits for the workshops. Practitioners lead them, and speakers come in from organisations such as Google DeepMind.

Things are moving very fast, and we are doing our best to keep up. Where we see opportunities, we’ll improve things, so you should treat this curriculum as indicative rather than definitive.

Tools and libraries

PythonNumPyscikit-learnXGBoostPyTorchHugging FaceClaude CodeMCPMLflowFastAPIPostgresDockerKubernetes

Agent harnesses

An agent is a language model using tools in a loop. The harness is everything in that loop except the model, from the context it is given to the checks that run on what it produces.

In the first workshop you write a coding agent from scratch, a small working version of Claude Code. In the second you look at harness engineering, and at the controls that improve what Claude Code produces. One short session goes to the Model Context Protocol. The rest of the module is a group project, and it ends with presentations.

What you will build

• A coding agent written from scratch, a small working version of Claude Code
• An improved version of the coding harness and workflow you already use
• A harness of your own, whether built from scratch, wrapped round the Claude Agent SDK, or written as conventions for coding agents at your employer
• Part of Terminal-Bench run against your harness, in Docker

Tools and libraries

PythonClaude CodeMCPDocker

Production ML

You start with raw data and end with a model answering live requests. The aim is to do a machine learning engineer’s job once, end to end.

You curate the data, then fit a linear regression baseline, gradient-boosted trees and a small neural network, score all three on the same held-out split, and log every run to MLflow.

You serve the model behind FastAPI on your own Kubernetes cluster, then change it while it is running, with a second version on 10% of the traffic and a third as a shadow on a copy of every request. In the last workshop you look at data drift, and at whether to retrain the model or retire it.

What you will build

• A linear regression baseline, gradient-boosted trees and a small neural network, scored on the same held-out split
• An MLflow run log, with one model promoted to the registry
• The model served behind FastAPI on your own Kubernetes cluster
• A second version on 10% of the traffic, and a third running as a shadow
• Drift detection on the live data, and a decision to retrain or retire

Tools and libraries

Pythonscikit-learnXGBoostPyTorchMLflowFastAPIDockerKubernetes

Retrieval and context engineering

Context engineering is the job of getting the right data in front of the model. Retrieval is how you do that when the corpus is too large to load.

You start with RAG as it was built in 2023. Documents are chunked, embedded and stored in pgvector. A query is embedded, the nearest chunks come back, and they go into the prompt. You build it first on a hosted embedding API, then on a local model, then strip it down to cosine search in NumPy. You write the test questions before any of that, part by hand and part generated, check the generated ones against human judgement, and score every change on precision, recall and mean reciprocal rank.

Then you move on to what the field does now. A BM25 index sits beside the dense one and the two are fused by reciprocal rank fusion. A cross-encoder reranks the shortlist before it reaches the model, and you measure what that costs in latency. After that the model takes over retrieval. An agent with search tools decides what to fetch, judges what came back and fetches again, and you score it against loading the whole corpus into the window. The last taught afternoon is LLM operations. You route requests between a cheap model and a reasoning model, cache what repeats, version the prompts, track what every call costs and add a fallback for when a provider fails.

The module ends with a group project, a retrieval system over a set of documents, ideally your employer’s.

What you will build

• A dense retriever built three ways, from hosted embeddings in pgvector to a local embedding model to cosine search in plain NumPy
• A BM25 index over the same documents, fused with the dense results by reciprocal rank fusion
• A cross-encoder reranker over the shortlist, and a measurement of the latency it adds
• A labelled query set written before the system, part hand-written and part synthetic, and a harness that reports precision, recall and MRR after every change
• An agent that searches the corpus itself, scored against loading everything into the window
• A routing layer between a cheap model and a reasoning model, with caching, prompt versioning, cost tracking and a fallback
• A retrieval system over a set of documents, ideally your employer’s, built as a team

Tools and libraries

PythonNumPyHugging FacePostgres

Transformers from first principles

You build a transformer from the ground up in PyTorch. The aim is to understand the substrate at the heart of the current AI boom.

You read the foundational papers alongside the code, starting with ‘Attention Is All You Need’, and the engineering decisions in your model come from them. Attention comes first, worked out by hand on one sentence before it goes into code, then the rest of the block, then training on a small dataset. Towards the end of the module you train a model on a GPU with mixed precision and fine-tune a small open model with LoRA.

By the end of the module you have a clear idea of what deep learning researchers do day to day.

What you will build

• Scaled dot-product attention, worked by hand on one sentence and then written in NumPy
• Multi-head self-attention and positional encodings in PyTorch
• A decoder-only transformer with causal masking, residual connections and layer normalisation, trained on a small dataset with cross-entropy loss
• Training moved to a GPU with mixed precision, and the throughput before and after
• A small open model fine-tuned with LoRA

Tools and libraries

PythonNumPyPyTorchHugging Face

Frontier ML

This module has no fixed syllabus. We choose the papers eight weeks before it starts, from whatever the field is arguing about at the time.

Each afternoon goes to one paper. You read it in the room, argue over it at the whiteboard in groups of four, then reproduce part of it at small scale and take the implementation as far as the afternoon allows.

If the module ran today

• Preference optimisation
• Reinforcement learning from verifiable rewards
• Diffusion models for images
• Diffusion models for text
• The cost of inference
• World models

Tools and libraries

PythonPyTorchHugging Face

Research sprint

Your team picks a paper and a problem, ideally one set by an employer. You reproduce the paper’s result at small scale, then apply it to the problem.

The one rule is to serve early. By the second week the team has a model in service, on a cluster one of you already runs, and at the end you know what it cost.

What you will build

• A reproduction of a published result at small scale
• A model in service by the second week

Tools and libraries

PyTorchHugging FaceDockerKubernetes

Employer project

You build an AI system for your employer, to a brief they set, and put it into service. Your assessment and grade are based on that work.

The cohort reviews your work twice, first on the architecture and the data, then on the evaluation and the risks. You document the system, hand it over, and present it first to the cohort and then to your employer.

What you will build

• A brief agreed with your employer, naming the problem, the data and who it is for
• An AI system built on that brief and put into service
• Monitoring on the live system
• Documentation and a handover to your employer
• A written report and a presentation, which form the first part of your assessment

Tools and libraries

PyTorchMLflowDockerKubernetes