Over the past few years, most of my work and learning in AI has been closer to the application layer—understanding models, building AI applications, and exploring how businesses can use them.

I knew the foundational ideas behind models, weights, prompts, and tokens, but I had not explored inference infrastructure and GPU execution in sufficient depth. I wanted to understand what really happens after an application sends a prompt to a model.

How is the model loaded and prepared for inference? What happens during prefill and decode? How are multiple GPUs used? What is a GPU kernel? How do warps, schedulers, compute units, and memory work together to produce the next token?

These concepts are often explained separately. You might find one resource about model weights, another about inference serving, and a highly technical tutorial about GPU internals. It is much harder to find a single learning journey that connects all these layers—from a trained model to the answer displayed in an application.

That gap became the motivation for creating Model Academy.

Two complementary perspectives

My background is primarily in networking and, more recently, AI applications. Systems concepts are familiar to me, but I had not previously gone deeply into modern AI infrastructure or the internal execution model of GPUs.

Ritesh Dhoot has spent considerably more time working with AI infrastructure and understands this part of the stack in much greater depth. I brought the perspective of an application builder trying to understand what happens beneath the interfaces we use every day.

That combination worked particularly well.

As we discussed each concept, we repeatedly asked two questions:

1. Is this technically accurate?
2. Can someone without a deep GPU or infrastructure background understand it?

The second question was just as important as the first. If I found a concept difficult to connect to the larger story, it was a useful signal that the explanation needed to be simplified, visualized, or placed in better context.

One connected journey

Model Academy follows the complete path from models to answers.

It begins with how models are built, what their weights contain, and what a model release actually provides. It then follows a request through an inference system: request preparation, model loading, batching, prefill, decode, KV cache, and multi-GPU execution.

From there, the journey moves inside the GPU to explain kernels, thread blocks, warps, scheduling, compute, and memory movement. It concludes by replaying one prompt from the initial request to the final streamed answer.

The academy is intended for engineers, architects, technology leaders, and curious learners who want a practical mental model of the complete system. The goal is not to turn every reader into a GPU programmer. It is to help people understand how the layers fit together and why different architectural decisions matter.

Learning through interaction

We strongly believe that complex systems are easier to understand when you can see them operating.

For that reason, Model Academy is not only a collection of written chapters. We have tried to use animations and interactive exercises throughout the learning journey.

Instead of merely reading that temperature changes a token distribution, you can change it and observe the result. Instead of reading a list of inference stages, you can follow a prompt through request preparation, model execution, and token generation. You can also zoom inside a GPU and explore how kernels, blocks, warps, schedulers, compute units, and memory work together.

The academy provides a Beginner mode that explains the complete journey in approachable language. Expert mode progressively exposes the mechanisms underneath without requiring a separate curriculum.

The first part of a larger learning series

This academy covers the journey from models and weights through inference systems and into GPU execution. But we see it as the first part of a broader learning series.

Over time, we would like to explore more of the systems operating “under the hood” of AI: model architectures, training infrastructure, inference optimization, distributed systems, networking, accelerators, and other topics that connect AI applications to the platforms beneath them.

For now, we hope Model Academy makes an intimidating subject more approachable, visual, and connected.

Explore the academy at ModelAcademy.tech. The project is also available as an open-source repository on GitHub.

We welcome your feedback and hope the academy helps you understand—and confidently explain—how AI models produce answers.

Model Academy is created and maintained by Sreenivas Makam and Ritesh Dhoot.