<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:video="http://www.google.com/schemas/sitemap-video/1.1">
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/workflow-versus-agent/</loc>
    <lastmod>2026-09-11T18:45:49Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/workflow-versus-agent/video/poster.jpg?v=67d5b14e94</video:thumbnail_loc>
      <video:title>A fixed workflow versus an agent loop</video:title>
      <video:description>A workflow runs a fixed sequence of model and tool steps; an agent loop lets the model choose each next step from what the last one returned. Workflows are cheaper and predictable when the steps are known; agents earn their cost when information is missing. Run one real refund email through a fixed workflow of four steps and through an agent loop that picks each next tool from what the last one returned. Recorded runs show the loop costing four times the tokens when the steps are known, earning its cost when information is missing, and running until its budget stops it when a tool keeps failing.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/workflow-versus-agent/video/film.mp4?v=054a59cb61</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/workflow-versus-agent/embed/</video:player_loc>
      <video:duration>107</video:duration>
      <video:publication_date>2026-09-11T18:45:49Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Agents</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/activations/</loc>
    <lastmod>2026-09-12T00:12:46Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/activations/video/poster.jpg?v=9134f88e45</video:thumbnail_loc>
      <video:title>Activation functions and normalisation</video:title>
      <video:description>An activation function is the non-linear step a network applies after each matrix multiply, so that stacked layers can represent more than one linear map. Normalisation and dropout sit beside it to keep the values well behaved. Press play and watch ReLU rise, get sanded into GELU, become the SwiGLU valve, then see the outputs normalised, dropped out and added to the residual stream. Every slider still works mid-film.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/activations/video/film.mp4?v=7f53ef758e</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/activations/embed/</video:player_loc>
      <video:duration>87</video:duration>
      <video:publication_date>2026-09-12T00:12:46Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Foundations</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/attention-variants/</loc>
    <lastmod>2026-09-11T18:09:45Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/attention-variants/video/poster.jpg?v=cab80c2e28</video:thumbnail_loc>
      <video:title>Attention variants: MHA, GQA, MQA, MLA and sliding windows</video:title>
      <video:description>Multi-head, grouped-query, multi-query, multi-head latent and sliding-window attention are different ways of sharing or shrinking the keys and values a model stores per token. The choice decides how much KV cache memory a long context costs. Press play and watch a KV-cache warehouse fill an H100: full attention needs 68.7 GB at Llama 3.1 8B’s full context, grouped-query attention cuts it to 17.2 GB, one shared head to a thirty-second, DeepSeek-V3’s latent attention compresses 71 times, and a sliding window caps it at 537 MB, all computed from the models’ published configs.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/attention-variants/video/film.mp4?v=349bf8bf9b</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/attention-variants/embed/</video:player_loc>
      <video:duration>156</video:duration>
      <video:publication_date>2026-09-11T18:09:45Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Context</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/backpropagation/</loc>
    <lastmod>2026-09-11T20:17:33Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/backpropagation/video/poster.jpg?v=ceea3b626f</video:thumbnail_loc>
      <video:title>Backpropagation and vanishing gradients</video:title>
      <video:description>Backpropagation is the algorithm that computes how much each weight contributed to the error, by applying the chain rule backwards through the network one layer at a time. Vanishing gradients happen when those per-layer factors multiply to almost nothing. Press play and watch backpropagation run the error back through one neuron by the chain rule, then through twelve layers, where the sigmoid lets it fade to 18 million times weaker and ReLU, careful initialisation and residual connections keep it alive.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/backpropagation/video/film.mp4?v=1db12ff036</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/backpropagation/embed/</video:player_loc>
      <video:duration>141</video:duration>
      <video:publication_date>2026-09-11T20:17:33Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Training</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/history-versus-memory/</loc>
    <lastmod>2026-09-12T00:17:23Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/history-versus-memory/video/poster.jpg?v=15845a9e58</video:thumbnail_loc>
      <video:title>Conversation history versus persistent memory</video:title>
      <video:description>A language model keeps nothing between calls. Conversation history is the transcript an application resends each turn; memory is whatever it stores outside the context window and retrieves back in when the window overflows. A model keeps nothing between calls, so an application resends the conversation and fills a context window. Follow one real conversation as the window overflows, truncation silently drops the turn that set a naming rule, and retrieved memory and pinned conventions bring it back, with every reply recorded.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/history-versus-memory/video/film.mp4?v=1f26fcb60d</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/history-versus-memory/embed/</video:player_loc>
      <video:duration>108</video:duration>
      <video:publication_date>2026-09-12T00:17:23Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Context</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/diffusion-models/</loc>
    <lastmod>2026-09-11T19:19:48Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/diffusion-models/video/poster.jpg?v=a2436b4604</video:thumbnail_loc>
      <video:title>Diffusion models: from noise to image</video:title>
      <video:description>A diffusion model generates an image by learning to reverse a noising process: training adds noise to real pictures, and sampling removes it step by step from pure static, steered by a prompt. Press play and watch pure static become a picture in fifty denoising steps: how training noises real pictures, why the cosine schedule beats the linear one, what the U-Net or DiT actually predicts, how a prompt steers sampling through classifier-free guidance, why too much guidance backfires, and why real systems diffuse a compressed latent, with every number computed from an exact toy model.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/diffusion-models/video/film.mp4?v=3d2c9fc619</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/diffusion-models/embed/</video:player_loc>
      <video:duration>149</video:duration>
      <video:publication_date>2026-09-11T19:19:48Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Architecture</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/parallelism/</loc>
    <lastmod>2026-09-11T20:18:53Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/parallelism/video/poster.jpg?v=be41e069a7</video:thumbnail_loc>
      <video:title>Distributed training: data, tensor and pipeline parallelism</video:title>
      <video:description>Distributed training splits a model that does not fit on one accelerator across many. Data parallelism copies the model and splits the batch, tensor parallelism splits individual layers, and pipeline parallelism assigns whole layers to different devices. A 7B model does not fit on one 80 GB card for training, and a 70B does not fit on eight. Slice the model four different ways across a rack and watch what each strategy costs in memory, traffic and idle time.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/parallelism/video/film.mp4?v=7f2b1c20aa</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/parallelism/embed/</video:player_loc>
      <video:duration>81</video:duration>
      <video:publication_date>2026-09-11T20:18:53Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Systems</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/draft-critique-revise/</loc>
    <lastmod>2026-09-11T19:34:45Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/draft-critique-revise/video/poster.jpg?v=b7d6ff6cd3</video:thumbnail_loc>
      <video:title>Draft, critique, revise, check</video:title>
      <video:description>Draft, critique, revise is a prompting pattern where one model writes, a second scores the draft against a rubric, and the first revises against that score, with code checking whatever can be counted. It improves output on average and can make individual revisions worse. One outage update goes round a revision loop: a writer model drafts, a critic model scores it against a five-point rubric and returns JSON, your code re-checks what it can count, and the writer revises one target at a time. Every text and verdict is a real model output, including the revision that made things worse.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/draft-critique-revise/video/film.mp4?v=e565d9234a</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/draft-critique-revise/embed/</video:player_loc>
      <video:duration>130</video:duration>
      <video:publication_date>2026-09-11T19:34:45Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Prompting</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/embedding-space/</loc>
    <lastmod>2026-09-11T20:25:45Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/embedding-space/video/poster.jpg?v=c2b50c13fc</video:thumbnail_loc>
      <video:title>Embedding space</video:title>
      <video:description>An embedding space is the high-dimensional space where a model places every token or sentence as a point, so that similar meanings land close together. Directions in the space carry meaning too, which is what makes vector arithmetic on words work. Words become points in a 3D space where nearness means similar meaning. Watch the clusters form, trace king to its nearest neighbours, see directions carry meaning, and find out what any flat picture of an embedding hides.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/embedding-space/video/film.mp4?v=558d3bf462</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/embedding-space/embed/</video:player_loc>
      <video:duration>101</video:duration>
      <video:publication_date>2026-09-11T20:25:45Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Representations</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/few-shot-prompting/</loc>
    <lastmod>2026-09-11T20:22:57Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/few-shot-prompting/video/poster.jpg?v=0f35508a51</video:thumbnail_loc>
      <video:title>Few-shot prompting: examples define the pattern</video:title>
      <video:description>Few-shot prompting is the practice of putting worked examples in the prompt so the model infers the pattern it should follow. Good examples resolve ambiguity; redundant or contradictory ones only cost tokens or mislead. Eight support tickets, one router, six prompts: no examples, useful examples, repetitive ones, one contradiction, one more example, and the house rules written down. Every landing is a real model answer recorded ten times, so you can see which examples resolve ambiguity and which only cost tokens.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/few-shot-prompting/video/film.mp4?v=ea09381998</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/few-shot-prompting/embed/</video:player_loc>
      <video:duration>87</video:duration>
      <video:publication_date>2026-09-11T20:22:57Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Prompting</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/image-editing-masks/</loc>
    <lastmod>2026-09-11T19:22:27Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/image-editing-masks/video/poster.jpg?v=0363a32be7</video:thumbnail_loc>
      <video:title>Image editing with masks and references</video:title>
      <video:description>A mask tells an image model which pixels it may change and a reference image tells it what to put there. How faithfully a model honours the mask varies by model, and the only way to know is to diff the result against the original. Send one real photo, a mask, a reference mug and an instruction through OpenAI image models, then diff every result against the original. Under gpt-image-1.5 a tight mask still let 7 to 9 percent of the rest of the photo change. The same edits on gpt-image-2.5 changed under a tenth of a percent, with or without a mask, but a loose mask came back as a solid black block.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/image-editing-masks/video/film.mp4?v=ce4307eb65</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/image-editing-masks/embed/</video:player_loc>
      <video:duration>97</video:duration>
      <video:publication_date>2026-09-11T19:22:27Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Prompting</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/lora/</loc>
    <lastmod>2026-09-11T23:12:03Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/lora/video/poster.jpg?v=6ec5af5f42</video:thumbnail_loc>
      <video:title>LoRA: learn a correction, keep the base</video:title>
      <video:description>LoRA, low-rank adaptation, fine-tunes a model by freezing its weights and training two small matrices whose product is added to each weight as a correction. It trains a fraction of the parameters and the correction can be merged back in. Follow a frozen weight matrix and two trainable factors through a forward pass, one real training step, a rank limit, an exact parameter budget and a merge.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/lora/video/film.mp4?v=f182b86e90</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/lora/embed/</video:player_loc>
      <video:duration>118</video:duration>
      <video:publication_date>2026-09-11T23:12:03Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Training</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/gpu-matmul/</loc>
    <lastmod>2026-09-11T20:09:12Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/gpu-matmul/video/poster.jpg?v=db85312238</video:thumbnail_loc>
      <video:title>Matrix multiplication on a GPU</video:title>
      <video:description>Matrix multiplication is the operation that dominates both training and inference in a language model. A GPU tiles the work across thousands of cores, and tensor cores and systolic arrays exist to do that one operation faster than anything else. A GEMM is exactly 2MNK operations whatever runs it. Watch a GPU tile one, then compare three ways of building the hardware for it, CUDA cores, tensor cores and a TPU systolic array, and see why the fast ones are so hard to feed.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/gpu-matmul/video/film.mp4?v=a72dda6465</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/gpu-matmul/embed/</video:player_loc>
      <video:duration>104</video:duration>
      <video:publication_date>2026-09-11T20:09:12Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Systems</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/multi-shot-continuity/</loc>
    <lastmod>2026-09-11T20:06:42Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/multi-shot-continuity/video/poster.jpg?v=b59c4c41a9</video:thumbnail_loc>
      <video:title>Multi-shot prompting and visual continuity</video:title>
      <video:description>Multi-shot prompting asks an image model for a sequence of related pictures. Because the model carries nothing from one call to the next, continuity has to be supplied in the prompt: a shared description, a reference frame and an explicit state per shot. Generate four shots of one barista with gpt-image-1.5 four ways and let a strict judge check every cut. Prompts written one at a time matched 16 of 42 checks; a shared continuity sheet, the approved first frame as a reference and a state line per shot took it to 54 of 54, because the model carries nothing from one shot to the next.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/multi-shot-continuity/video/film.mp4?v=551d86875c</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/multi-shot-continuity/embed/</video:player_loc>
      <video:duration>77</video:duration>
      <video:publication_date>2026-09-11T20:06:42Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Prompting</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/parallel-work-synthesis/</loc>
    <lastmod>2026-09-11T20:16:19Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/parallel-work-synthesis/video/poster.jpg?v=faacb46c6f</video:thumbnail_loc>
      <video:title>Parallel work and the synthesis bottleneck</video:title>
      <video:description>Splitting a task across parallel model workers cuts wall-clock time, but their findings still have to be merged by a lead model. That synthesis step becomes the bottleneck, and without a written merge rule, conflicts between workers quietly disappear. Split one research question across four parallel workers and merge their findings with a lead model, in real recorded runs. Parallel workers finish in a quarter of the time, but the merge becomes the slowest step, overlapping questions buy nothing, one slow branch holds everything up, and without a written merge rule a conflict between two sources quietly disappears.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/parallel-work-synthesis/video/film.mp4?v=d38035a0d5</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/parallel-work-synthesis/embed/</video:player_loc>
      <video:duration>109</video:duration>
      <video:publication_date>2026-09-11T20:16:19Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Agents</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/prefill-decode/</loc>
    <lastmod>2026-09-11T20:21:15Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/prefill-decode/video/poster.jpg?v=d2c07c7a0f</video:thumbnail_loc>
      <video:title>Prefill vs decode: time to first token and tokens per second</video:title>
      <video:description>LLM inference has two phases. Prefill processes the whole prompt in one parallel pass and sets the time to first token; decode then produces one token at a time, rereading the model's weights for each, which is why tokens per second is bounded by memory bandwidth. Press play and watch one GPU serve Llama 3.1 8B: prefill floods the whole prompt through at once and is limited by arithmetic, while decode drips one token at a time, rereads all 16 GB of weights for each, and is limited by memory bandwidth, with real timings measured on a live endpoint.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/prefill-decode/video/film.mp4?v=92404b6457</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/prefill-decode/embed/</video:player_loc>
      <video:duration>154</video:duration>
      <video:publication_date>2026-09-11T20:21:15Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Inference</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/prompt-caching-prefix/</loc>
    <lastmod>2026-09-11T12:58:18Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/prompt-caching-prefix/video/poster.jpg?v=d5b9ac704d</video:thumbnail_loc>
      <video:title>Prompt caching: reuse the stable prefix</video:title>
      <video:description>Prompt caching lets an API reuse the computed state of a prompt prefix across calls, so a long system prompt is processed once and read back cheaply. The cache matches from the first token, which is why anything that changes at the top of the prompt discards all of it. A support bot resends the same 5,897-token prefix on every call. Watch real Claude Sonnet 5 calls read it back from a prompt cache for a tenth of the price, see a question-first prompt reuse nothing, and see one timestamp at the top of the system prompt throw the whole cache away.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/prompt-caching-prefix/video/film.mp4?v=de4637dfc8</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/prompt-caching-prefix/embed/</video:player_loc>
      <video:duration>104</video:duration>
      <video:publication_date>2026-09-11T12:58:18Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Inference</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/prompt-optimisation-overfits/</loc>
    <lastmod>2026-09-11T12:08:03Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/prompt-optimisation-overfits/video/poster.jpg?v=faff0204f8</video:thumbnail_loc>
      <video:title>Prompt optimisation can overfit</video:title>
      <video:description>Automatic prompt optimisation keeps whichever edit raises a score on a set of examples. When that set is small, the score becomes a training score and the optimised prompt can do worse on cases it never saw. A prompt optimiser keeps whichever edit raises the score on a handful of examples, which quietly turns that score into a training score. Watch a real loop take eight support tickets from 40 to 100 per cent, then lift a curtain on twenty-four tickets it never saw, where a simpler prompt from two steps in does better.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/prompt-optimisation-overfits/video/film.mp4?v=ba515d55e3</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/prompt-optimisation-overfits/embed/</video:player_loc>
      <video:duration>83</video:duration>
      <video:publication_date>2026-09-11T12:08:03Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Prompting</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/prompting-rag-fine-tuning/</loc>
    <lastmod>2026-09-11T14:30:39Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/prompting-rag-fine-tuning/video/poster.jpg?v=85320dea3d</video:thumbnail_loc>
      <video:title>Prompting, RAG and fine-tuning: what changes where?</video:title>
      <video:description>Prompting changes the instructions a model sees, retrieval-augmented generation changes the evidence in its context, and fine-tuning changes its weights. Each fixes a different kind of failure, and none of them fixes the other two. Prompting changes the instructions, RAG changes the evidence in the context, and fine-tuning changes the weights. One real support request runs through all three lanes, each fix repairs only its own fault, and the lane that learns from past replies also learns their out-of-date refund rule.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/prompting-rag-fine-tuning/video/film.mp4?v=41578192f4</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/prompting-rag-fine-tuning/embed/</video:player_loc>
      <video:duration>126</video:duration>
      <video:publication_date>2026-09-11T14:30:39Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Training</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/rag-question-to-answer/</loc>
    <lastmod>2026-09-11T14:13:50Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/rag-question-to-answer/video/poster.jpg?v=e04538d0af</video:thumbnail_loc>
      <video:title>RAG: from question to evidence to answer</video:title>
      <video:description>Retrieval-augmented generation answers a question by first retrieving relevant passages, usually by embedding similarity, then placing them in the prompt so the model answers from evidence rather than memory. Retrieval and generation fail in different ways. Follow one question through retrieval augmented generation: every handbook passage scored by real embedding similarity, the top three stacked into the prompt, and a recorded answer checked claim by claim. Then delete the right page, or add a stale one, and see retrieval and generation fail at different stages.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/rag-question-to-answer/video/film.mp4?v=8284997df4</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/rag-question-to-answer/embed/</video:player_loc>
      <video:duration>88</video:duration>
      <video:publication_date>2026-09-11T14:13:50Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Context</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/rlhf-grpo/</loc>
    <lastmod>2026-09-11T13:04:03Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/rlhf-grpo/video/poster.jpg?v=5001534092</video:thumbnail_loc>
      <video:title>RLHF to GRPO: reward models and the KL leash</video:title>
      <video:description>RLHF, reinforcement learning from human feedback, trains a model to prefer answers a reward model scores highly, with a KL penalty holding it near the original. GRPO, group relative policy optimisation, replaces the value model by scoring each answer against a group of samples to the same question. Watch one real GRPO step on a small model: eight answers to one maths question, a judge model standing in for the reward model, advantages computed against the group instead of a value model, and the reward hacking that followed within five steps, even with the KL penalty on.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/rlhf-grpo/video/film.mp4?v=0b57e9ee43</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/rlhf-grpo/embed/</video:player_loc>
      <video:duration>156</video:duration>
      <video:publication_date>2026-09-11T13:04:03Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Training</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/softmax/</loc>
    <lastmod>2026-09-11T10:05:31Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/softmax/video/poster.jpg?v=3613408e2b</video:thumbnail_loc>
      <video:title>Softmax, temperature and cross-entropy</video:title>
      <video:description>Softmax turns a vector of raw scores into probabilities by exponentiating each one and dividing by the sum. Temperature scales the scores first, so a low temperature sharpens the distribution and a high one flattens it. The softmax function turns raw logits into probabilities in two moves: exponentiate, then divide by the sum. Watch a machine do it with the real numbers printed at every step, then heat it with temperature and read the loss off a gauge.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/softmax/video/film.mp4?v=74e3645558</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/softmax/embed/</video:player_loc>
      <video:duration>98</video:duration>
      <video:publication_date>2026-09-11T10:05:31Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Foundations</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/state-space-models/</loc>
    <lastmod>2026-09-11T23:11:24Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/state-space-models/video/poster.jpg?v=d2794aa04c</video:thumbnail_loc>
      <video:title>State space models vs attention: S4, Mamba and hybrids</video:title>
      <video:description>A state space model processes a sequence by updating a fixed-size state at each step rather than attending over every previous token. Mamba makes that update selective, so it can keep or forget per token, at the cost of the exact recall attention gets for free. Press play and watch attention’s cache grow by 8 KiB with every token while a Mamba layer keeps one 128 KiB state, then follow the recurrence, the step size Δ, Mamba’s selectivity, the parallel scan and the exact recall a fixed state gives up, all computed from small, labelled toys.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/state-space-models/video/film.mp4?v=a16a520303</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/state-space-models/embed/</video:player_loc>
      <video:duration>167</video:duration>
      <video:publication_date>2026-09-11T23:11:24Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Architecture</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/superposition/</loc>
    <lastmod>2026-09-11T23:18:31Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/superposition/video/poster.jpg?v=40cc0fe200</video:thumbnail_loc>
      <video:title>Superposition and sparse decoding</video:title>
      <video:description>Superposition is how a network represents more features than it has dimensions, by packing feature directions into the same coordinates at the cost of interference between them. Sparse decoders try to pull those features back apart. Pack five feature directions into two coordinates, measure the resulting cross-talk, and run a sparse decoder that reveals both what it can recover and what compression has erased.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/superposition/video/film.mp4?v=4b83769d9c</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/superposition/embed/</video:player_loc>
      <video:duration>99</video:duration>
      <video:publication_date>2026-09-11T23:18:31Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Interpretability</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/anatomy-of-a-prompt/</loc>
    <lastmod>2026-09-11T20:19:46Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/anatomy-of-a-prompt/video/poster.jpg?v=bed685f0ef</video:thumbnail_loc>
      <video:title>The anatomy of a good prompt</video:title>
      <video:description>A prompt is the text a model conditions on before it answers. A good one states the task, names the audience, supplies context, sets constraints, shows an example and fixes the output format. A prompt has six pieces: task, audience, context, constraints, an example and an output format. Watch one real request assembled plate by plate, with the model’s recorded reply to every version, and see which piece changes the answer most.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/anatomy-of-a-prompt/video/film.mp4?v=16fc227412</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/anatomy-of-a-prompt/embed/</video:player_loc>
      <video:duration>72</video:duration>
      <video:publication_date>2026-09-11T20:19:46Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Prompting</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/event-loop/</loc>
    <lastmod>2026-09-12T00:18:11Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/event-loop/video/poster.jpg?v=bc498502f4</video:thumbnail_loc>
      <video:title>The event loop: why a 10 ms timer waits 80 ms</video:title>
      <video:description>The event loop is the scheduler that runs JavaScript one task at a time, draining the microtask queue after each task before it looks at timers. A timer's delay is a minimum wait, not a guarantee, because a running task cannot be interrupted. Trace an executable TypeScript example through a running task, a nested microtask checkpoint and a waiting timer, then compare promise continuations with real task yields in two browser engines.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/event-loop/video/film.mp4?v=09937853b8</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/event-loop/embed/</video:player_loc>
      <video:duration>89</video:duration>
      <video:publication_date>2026-09-12T00:18:11Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Coding</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/transformer-block/</loc>
    <lastmod>2026-09-11T11:00:53Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/transformer-block/video/poster.jpg?v=4b7a2b4ab6</video:thumbnail_loc>
      <video:title>The transformer block, exploded</video:title>
      <video:description>A transformer block is the repeated unit of a language model: attention, then a feed-forward MLP, each adding its output back onto a residual stream. Stacking dozens of them, with an embedding table at each end, is the whole architecture. Pull one transformer block apart like a watch movement and follow a token through it: embedding, attention, the residual stream, the MLP, and out to a distribution over the next word. Every part is counted, so you can see where the parameters actually live.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/transformer-block/video/film.mp4?v=e2f5765d81</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/transformer-block/embed/</video:player_loc>
      <video:duration>87</video:duration>
      <video:publication_date>2026-09-11T11:00:53Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Architecture</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/tool-calling-round-trip/</loc>
    <lastmod>2026-09-11T20:46:23Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/tool-calling-round-trip/video/poster.jpg?v=0e2f2f310d</video:thumbnail_loc>
      <video:title>Tool calling is a round trip</video:title>
      <video:description>Tool calling is the round trip where a model writes a structured request for a function, the application runs it, and the result goes back into the model's context before it answers. The model never executes anything itself. Follow one customer question through a real tool call: the model writes a request and runs nothing, your code looks the order up, and only when the result goes back does the model answer. Four recorded exchanges show the round trip, a lost result, an error, and a refused cancellation.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/tool-calling-round-trip/video/film.mp4?v=a114ae9566</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/tool-calling-round-trip/embed/</video:player_loc>
      <video:duration>101</video:duration>
      <video:publication_date>2026-09-11T20:46:23Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Agents</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/vector-search/</loc>
    <lastmod>2026-09-11T13:07:01Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/vector-search/video/poster.jpg?v=d082668f2c</video:thumbnail_loc>
      <video:title>Vector search: HNSW, cosine similarity and BM25</video:title>
      <video:description>Vector search finds the stored items whose embeddings are closest to a query's, usually by cosine similarity through an approximate index such as HNSW. Combined with a lexical search like BM25 it catches the questions each method misses alone. Follow one query down an HNSW tower as it hops from the roof to its ten nearest neighbours with 63 distance computations instead of 500, see what ef buys in 32 dimensions, then watch real embeddings and BM25 each miss a question the other gets right, and what reciprocal rank fusion does with the two.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/vector-search/video/film.mp4?v=43f7d5e516</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/vector-search/embed/</video:player_loc>
      <video:duration>165</video:duration>
      <video:publication_date>2026-09-11T13:07:01Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Representations</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/what-are-embeddings/</loc>
    <lastmod>2026-09-11T10:42:50Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/what-are-embeddings/video/poster.jpg?v=94b308cbbd</video:thumbnail_loc>
      <video:title>What are embeddings?</video:title>
      <video:description>An embedding is the list of numbers a model uses to represent a token, word or sentence. Similar meanings get similar numbers, which is what lets a model, or a search index, compare things by meaning. An embedding is the list of numbers a language model uses in place of a word. Watch a token id open a drawer in the embedding table, see similar words share similar numbers and fall into groups in 3D, measure the angle between two words, and do sums with meaning.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/what-are-embeddings/video/film.mp4?v=8b1cb5d177</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/what-are-embeddings/embed/</video:player_loc>
      <video:duration>126</video:duration>
      <video:publication_date>2026-09-11T10:42:50Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Representations</video:category>
    </video:video>
  </url>
  <url>
    <loc>https://understandingdata.com/ai-engineering-visualised/what-are-tokens/</loc>
    <lastmod>2026-09-11T11:41:24Z</lastmod>
    <video:video>
      <video:thumbnail_loc>https://assets.understandingdata.com/viz/what-are-tokens/video/poster.jpg?v=3c4be36305</video:thumbnail_loc>
      <video:title>What are tokens?</video:title>
      <video:description>A token is the unit of text a language model actually reads: a word, part of a word or a punctuation mark, each mapped to an id number by a tokeniser. Costs, context limits and rate limits are all counted in tokens. A language model never reads your words. A tokeniser cuts the text into pieces called tokens and swaps each one for an id number. Watch a machine do it to real sentences, with the real GPT-2 and GPT-4o splits and ids printed on every tile.</video:description>
      <video:content_loc>https://assets.understandingdata.com/viz/what-are-tokens/video/film.mp4?v=7a7a520994</video:content_loc>
      <video:player_loc>https://understandingdata.com/ai-engineering-visualised/what-are-tokens/embed/</video:player_loc>
      <video:duration>94</video:duration>
      <video:publication_date>2026-09-11T11:41:24Z</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:requires_subscription>no</video:requires_subscription>
      <video:live>no</video:live>
      <video:uploader info="https://understandingdata.com/about/">James Phoenix</video:uploader>
      <video:category>Foundations</video:category>
    </video:video>
  </url>
</urlset>
