Models · inference · agents · evaluation
Understand the systems behind modern AI applications
From transformer internals to agent loops, retrieval, prompting and real-time inference. Follow a guided path from first principles to the behavior that matters in production.
Choose a path
01 / Pick where to begin
Choose a learning path
19 guides across 3 paths01 / Tokens · architecture · reasoning
Model foundations
0 of 5 runs completeHow does a large language model turn text into a response?
The full transformer architecture from tokenization through embeddings, self-attention, multi-head attention, transformer blocks and autoregressive generation.
How does DeepSeek-V4 fit a million-token context on the same hardware?
The architecture rewrites behind DeepSeek-V4: CSA plus HCA hybrid attention, doubly-stochastic hyper-connections, the Muon optimizer, MegaMoE wave-pipelined EP, and the stability tricks that kept a 1.6T-parameter MoE alive during training.
How do DeepSeek-V4 architecture and training work together?
A source-backed tour of DeepSeek-V4 residual mixing, compressed attention, sparse expert training, stability systems and specialist distillation.
How do Kimi K3 architecture, data, and training fit together?
A source-backed deep dive into Kimi K3 sparse routing, long-context attention, depth retrieval, data-disclosure boundaries, low-precision training and serving.
How does pretraining change what reinforcement learning can achieve?
A paper-backed tour of how pretraining loss and token exposure predict RL returns, how compute allocation shifts, and what RL changes inside easy and hard reasoning policies.
02 / Retrieval · agents · prompting
Application systems
0 of 9 runs completeHow does LangChain grow one model call into a real LLM app?
How one model call grows into prompts, memory, chains, evals and agents across the full LangChain course arc.
How do OpenAI prompts become reliable production artifacts?
Why prompt order matters, how examples shape behavior, what structured outputs actually guarantee and the eval loop that hardens it all.
What turns one model call into a reliable LLM application?
A software engineering tour of context budgets, instruction authority, sampling, reasoning, streaming, schemas, tools, routing, retries and token cost.
How does a self-learning agent turn conversations into lasting capability?
How a fresh agent turns conversations into memory, skills and searchable episodes so the next session is smarter than the last.
How does Claude Code route prompts, tools, hooks, and plugins?
How prompts, tools, hooks and plugins actually flow through Claude Code from the CLI entry point to the edges where MCP takes over.
How does Clanker Cloud turn one prompt into grounded cloud evidence?
How one prompt gets cleaned up, routed to the right backend, hydrated with credentials and fanned out into parallel evidence gathering.
What is OpenClaw actually doing in local control mode?
What one local gateway actually does: normalizing channels, mapping sessions, running the agent loop and coordinating paired devices.
Why does an AI agent loop feel more structured than it looks?
Why an agent loop feels more structured than it looks: planning, tool calls, memory and guardrails working as one deliberate cycle.
How do you wire Java, Claude and OpenSearch into a working agent?
A practical code walkthrough: Maven dependencies, system prompt, tool schemas, the agent for-loop, switch-case handler and a live end-to-end trace.
03 / Inference · evaluation · safety
Production quality
0 of 5 runs completeHow do tokens stream from an LLM to your screen in real time?
What actually happens between stream:true and the first token on screen, including the SSE framing and backpressure nobody talks about.
How do you test an AI system that can answer differently on every run?
A practical evaluation system for probabilistic software, from golden datasets and regression tests through retrieval, grounding, tools, judges, humans, production signals and repeated model or prompt comparisons.
How did an AI security evaluation escape its sandbox and reach production?
A source-backed reconstruction of how an OpenAI cyber evaluation escaped its test environment, reached Hugging Face production and changed containment practice.
Why do LLM tokens come out one tiny step at a time?
Why tokens come out one at a time: the full path from prompt assembly through prefill, KV cache reuse and the autoregressive decode loop.
How would you design the GPU platform behind a ChatGPT-scale service?
A public-mechanism design exercise spanning streaming contracts, workload tails, GPU memory, parallelism, KV admission, continuous batching, failure handling, autoscaling and useful-token cost.
About this collection
An LLM application sits on top of several different systems. Tokens move through an architecture that produces probabilities, inference servers turn those probabilities into a streamed response and application code surrounds the model with context, tools, retries and evaluation. Treating all of that as one black box makes failures difficult to reason about. This collection separates the layers and shows how information moves across each boundary.
Begin with the large language model guide for the core path from tokenization to generation. From there you can inspect real-time streaming, retrieval-augmented generation, agent execution loops, prompt authority, model evaluation and the architecture choices behind specific frontier models. The visual guides distinguish confirmed mechanisms from uncertain or product-specific details. They are designed for engineers building AI features, reviewing an unfamiliar stack or trying to locate whether a problem belongs to the model, the runtime or the surrounding application.