Modern AI, Under the Hood – Maitreya

🧮 Foundations

Tensors, optimization, classical ML, and training loops - the building blocks behind modern AI systems.

🤖 Agentic AI

Agents and evals - building things that act, and measuring whether they act well.

🏗️ Architectures

Attention, transformers, and the model architectures everything else is built from.

⚙️ LLM Systems

Inference, serving, post-training, evaluation, and scaling — how modern LLMs are built, optimized, and deployed.

🎨 Generative

Diffusion, GANs, and the models built to generate rather than just predict.

Fewer Steps: Follow the Curve, Straighten It, or Skip It

Four responses to the same fast-sampling problem, derived rather than listed. Including the result that surprises people: a mathematically better solver can be twice as bad as a crude one when you only have two network calls to spend.

Aug 1, 2026

What Acceleration Actually Costs

A paper reports 50 steps to 4 and calls it a 12× speedup. Your service may not see 12×. This post is about the gap: the things you pay for besides network calls, the accelerations that cancel each other out, and the failure modes that only appear once the step count is low.

Aug 1, 2026

Why Image Generation Takes Fifty Steps

A diffusion model runs the same network dozens of times to make one picture. This post asks why it cannot run it once — and answers with an experiment where the network is provably perfect and the sampler still fails completely.

Aug 1, 2026

The Noise Schedule Decides Where Your Timesteps Land

Both previous posts took the linear schedule from the DDPM paper without comment. It decides how a fixed budget of timesteps is distributed across signal-to-noise ratios — and the linear and cosine schedules distribute it very differently, which is one reason cosine was introduced and often behaves differently from the original linear schedule.

Jul 31, 2026

Classifier-Free Guidance Is Extrapolation, Not Interpolation

CFG computes what the model predicts with your prompt and without it, then pushes past the conditional prediction rather than blending toward it. That’s why turning the knob up keeps working — until it very visibly doesn’t, with no error and no warning.

Jul 30, 2026

Diffusion from Scratch: One Model, Two Samplers

A diffusion model is trained to predict the noise that was added to an image, not the image. That parameterisation gives a fixed-scale training target — and once the network is trained, DDPM and DDIM use that same denoiser to trace different reverse trajectories through the same noise levels.

Jul 29, 2026

Continuous Batching: The GPU Was Underfilled, Not Underpowered

A decode step costs almost the same for one sequence as for thirty-two, so serving one user wastes most of the machine. Fixing that isn’t a kernel problem — it’s a scheduling one, and the naive fix makes every request wait for the slowest.

Jul 28, 2026

FlashAttention: The Matrix You Never Have to Write Down

Attention builds one number for every pair of words, uses it once, and throws it away. At long context lengths that throwaway table is larger than the model’s activations. This post explains why it gets built, why the softmax seems to require it, and the one identity that turns out to make it unnecessary.

Jul 21, 2026

The Agent Loop: Forty Lines and Four Ways It Breaks

Strip away the frameworks and a minimal tool-using agent is a loop that lets a language model request actions. Build that loop from scratch, then break it deliberately — because many of the recurring engineering problems become visible as failure modes of these forty lines.

Jul 20, 2026

Attention from Scratch: A Soft Dictionary Lookup

Why is there a square root in the most-copied equation in deep learning? Derive it rather than accept it, and the rest of attention — multiple heads, cross-attention, masking — falls out of one idea: a lookup where every key matches a little.

Jul 20, 2026

How the GPU Actually Runs Your Tensor Code

Two expressions can compute the same result and differ enormously in cost — sometimes the slower one is the one doing less arithmetic. How synchronization, launch overhead, memory traffic, compute intensity, allocation, and dynamic shapes compete to be your bottleneck, and how to measure which one actually dominates.

Jul 20, 2026

Ten Tensor Problems Where Shape Is Not Enough

A closing self-check on the tensor fundamentals: ten small problems where an answer can be semantically wrong despite a plausible shape — or mathematically right but unusable because of layout, numerics, device placement, or synchronization cost.

Jul 20, 2026

Numerical Stability: The Window, and the Precision You Lose Inside It

Floating-point arithmetic is not real arithmetic — it can only represent numbers inside a finite window, and outside it, exp overflows to infinity and tiny probabilities collapse to exactly zero. Many of the most common stability techniques share one move: rewrite the computation so dangerous intermediates stay representable. Cancellation then adds a second problem — preserving significant digits even when every intermediate is comfortably in range. Here are both, and the six places they matter — including the one that returns negative squared distances, turns them into NaN, and corrupts distance magnitudes without raising anything.

Jul 19, 2026

Selecting and Placing: gather, scatter, and the Indexing Model

gather is the operation everyone re-derives from the docs every single time. Here is the one sentence that makes it stop being mysterious, the intuition that it’s a one-hot matmul without the matrix, and the mutation rule that separates a copy from a view — where writing to the wrong one silently does nothing.

Jul 19, 2026

Broadcasting, Reductions, and Einstein Summation: The Algebra of Axes

PyTorch broadcasting will line up two tensors of different shapes and compute something — and when the shapes mean different things, that something is a silently wrong answer with a valid gradient. Here is the rule, a worked derivation of exactly what wrong objective you get, and the notation that makes axis intent reviewable.

Jul 16, 2026

Maitreya Suin

A Tensor Is a Flat Buffer and a Promise

How PyTorch maps a logical index like x[b, h, s, d] to an address in flat memory — and why views, reshapes, and packed layouts can hand you the right shape with the wrong values. The one idea that turns tensor gymnastics from memorized incantations into arithmetic you can derive.

Jul 14, 2026

Maitreya Suin

The KV Cache: Build It, Break It, Measure It

Autoregressive decoding recomputes what it already knows. We build a KV cache from scratch on GPT-2, prove it’s exact, break it three ways on purpose, and measure the price you pay for it.

Jul 13, 2026

Maitreya Suin