Interactive academy
How AI Models Produce Answers
From Weights to Tokens: An Interactive Journey Through Models, Inference, and GPUs
Follow an AI model from how it is created and packaged, through inference, into the GPU, until the final answer is generated.
The learning promise
See the entire path, then zoom in without losing the thread.
The same model, request, and generated answer connect every part. Each chapter adds detail while preserving that end-to-end story.
Audience
Who this is for
Product leaders, architects, software and infrastructure engineers, and curious learners who understand AI conceptually but do not need to begin as GPU specialists.
Our motivation
Why we built this
AI inference is often explained through isolated concepts—model weights, tokens, GPUs, KV caches, batching, and kernels. Learning each concept individually does not always make it clear how they work together as one system.
We created this interactive academy to bridge that gap. It follows the complete journey—from how a model is built and packaged, through deployment and inference, to the generation of output tokens. Our goal is to help engineers, architects, technology leaders, and curious learners understand not only what happens inside an AI inference platform, but also why its architectural decisions matter.
We often discuss technology by returning to its foundational concepts because we believe genuine understanding begins with clarity at the foundation. This academy is our attempt to simplify the journey from model weights to generated answers and share what we have learned.
We hope it turns a complex topic into something you can explore, understand, and confidently explain. We welcome your feedback and hope this learning journey benefits everyone exploring AI models, inference, and GPUs.
— Ritesh Dhoot and Sreenivas Makam
Key outcomes
What you will understand
By the finale, you should be able to explain one AI response at three levels: the model, the inference system, and the GPU.
- What a model contains and how training produces its weights.
- How prompting, RAG, fine-tuning, and pretraining change what a model can do.
- How a model artifact is packaged, loaded, and made ready for inference.
- What happens during prefill, KV-cache creation, and token-by-token decode.
- How single-GPU inference works and why some models coordinate multiple GPUs.
- How kernels, blocks, warps, schedulers, and GPU memory execute the work.
It uses plain language, causal diagrams, and the essential checks needed to understand the whole journey.
It keeps the same chapters and animation state while revealing terminology, numbers, implementation choices, and trade-offs.
Four-part journey
Follow the sequence or enter where you are curious.
The recommended order builds one mental model. Every section can also be opened directly.
Help improve the academy
What became clearer—and what did not?
Tell us which section you reviewed, what worked, and what still needs a better explanation. Responses are collected in Google Forms; the academy does not store your feedback or email address.