https://thegustafson.com Holding the LLM Stack in Your Head — a dependency-ordered walk through the full LLM stack, from linear algebra to agent protocols. A living document, continuously revised. en-us https://thegustafson.com/blog/the-missing-middle https://thegustafson.com/blog/the-missing-middle A personal journey through the full LLM stack — how I built the mental models, how the series actually gets written, and where to jump in. https://thegustafson.com/blog/vectors-and-spaces https://thegustafson.com/blog/vectors-and-spaces Arc 1: Mathematical & Computational Prerequisites Vectors as lists of activations, matrix multiplication as a linear map, and why every neural network operation bottoms out in matmuls. https://thegustafson.com/blog/norms-dots-similarity https://thegustafson.com/blog/norms-dots-similarity Arc 1: Mathematical & Computational Prerequisites How cosine similarity, L2 distance, and projections work, and why they show up everywhere from attention scores to embedding retrieval. https://thegustafson.com/blog/probability-distributions https://thegustafson.com/blog/probability-distributions Arc 1: Mathematical & Computational Prerequisites Softmax, categorical distributions, Bayes' rule, and the chain rule of probability — the four tools that make language modeling a well-defined math problem. https://thegustafson.com/blog/cross-entropy-and-loss https://thegustafson.com/blog/cross-entropy-and-loss Arc 1: Mathematical & Computational Prerequisites Why cross-entropy is the standard LM loss, what it actually measures about two distributions, and how it connects to perplexity. https://thegustafson.com/blog/gradients-and-learning https://thegustafson.com/blog/gradients-and-learning Arc 1: Mathematical & Computational Prerequisites What a gradient is, why it points uphill, how backpropagation computes one efficiently via the chain rule, and what SGD does with it. https://thegustafson.com/blog/optimizers https://thegustafson.com/blog/optimizers Arc 1: Mathematical & Computational Prerequisites Why vanilla SGD is too slow, how Adam adapts per-parameter, and how warmup and cosine decay shape training dynamics. https://thegustafson.com/blog/gpus-and-floating-point https://thegustafson.com/blog/gpus-and-floating-point Arc 1: Mathematical & Computational Prerequisites IEEE 754, the difference between fp32/fp16/bfloat16, why mixed-precision training works, and the basics of GPU parallelism. https://thegustafson.com/blog/prehistory-of-nlp https://thegustafson.com/blog/prehistory-of-nlp Arc 1: Mathematical & Computational Prerequisites The arc from rule-based systems through statistical MT and log-linear models to neural approaches, giving you historical context for everything that follows. https://thegustafson.com/blog/next-token-prediction https://thegustafson.com/blog/next-token-prediction Arc 2: Language Modeling Before Transformers Why 'predict the next word' is a surprisingly powerful training objective, and how it connects to the chain rule of probability. https://thegustafson.com/blog/ngrams-and-sparsity https://thegustafson.com/blog/ngrams-and-sparsity Arc 2: Language Modeling Before Transformers Counting-based language models, Markov assumptions, smoothing techniques, and why sparsity made n-grams hit a hard ceiling. https://thegustafson.com/blog/word2vec https://thegustafson.com/blog/word2vec Arc 2: Language Modeling Before Transformers How skip-gram and CBOW learn dense word vectors, why 'king - man + woman = queen' works, and what distributional semantics actually means. https://thegustafson.com/blog/glove-fasttext https://thegustafson.com/blog/glove-fasttext Arc 2: Language Modeling Before Transformers How GloVe combines count-based and predictive methods, how FastText handles subwords, and the trade-offs across embedding approaches. https://thegustafson.com/blog/rnns https://thegustafson.com/blog/rnns Arc 2: Language Modeling Before Transformers The RNN equations, how hidden states carry information forward, why vanilla RNNs suffer from vanishing gradients, and what that means in practice. https://thegustafson.com/blog/lstms-grus https://thegustafson.com/blog/lstms-grus Arc 2: Language Modeling Before Transformers How gates solve the vanishing gradient problem, the difference between LSTM and GRU cells, and why gated architectures dominated NLP for five years. https://thegustafson.com/blog/seq2seq-and-bahdanau https://thegustafson.com/blog/seq2seq-and-bahdanau Arc 2: Language Modeling Before Transformers Encoder-decoder architectures, how additive attention let models align source and target tokens, and why sequential processing fundamentally bottlenecked scale. https://thegustafson.com/blog/unicode-and-bytes https://thegustafson.com/blog/unicode-and-bytes Arc 3: Tokenization & the Input Pipeline UTF-8 encoding, code points vs. grapheme clusters, and why 'one character' is a surprisingly ambiguous concept for a model. https://thegustafson.com/blog/bpe-from-scratch https://thegustafson.com/blog/bpe-from-scratch Arc 3: Tokenization & the Input Pipeline The BPE merge algorithm step by step, implemented from scratch, showing how a raw byte stream becomes a vocabulary. https://thegustafson.com/blog/wordpiece-unigram-sentencepiece https://thegustafson.com/blog/wordpiece-unigram-sentencepiece Arc 3: Tokenization & the Input Pipeline How WordPiece (BERT) and Unigram (T5) differ from BPE, why SentencePiece operates on raw text, and when each approach wins. https://thegustafson.com/blog/vocabulary-design https://thegustafson.com/blog/vocabulary-design Arc 3: Tokenization & the Input Pipeline How vocabulary size affects model capacity and sequence length, what token fertility measures, and the practical trade-offs behind 32k vs. 128k vs. 200k vocabularies. https://thegustafson.com/blog/embedding-table https://thegustafson.com/blog/embedding-table Arc 3: Tokenization & the Input Pipeline How token IDs become vectors via a lookup table, why the embedding matrix is a learned linear map, and how embedding and unembedding layers relate. https://thegustafson.com/blog/special-tokens-chat-templates https://thegustafson.com/blog/special-tokens-chat-templates Arc 3: Tokenization & the Input Pipeline BOS/EOS/PAD tokens, how chat-template formatting encodes multi-turn structure, system prompts, and tool-call schemas into a flat token stream. https://thegustafson.com/blog/packing-and-masking https://thegustafson.com/blog/packing-and-masking Arc 3: Tokenization & the Input Pipeline Sequence packing for training efficiency, how attention masks prevent cross-contamination, and why tokenizer choices constrain everything downstream. https://thegustafson.com/blog/attention-from-scratch https://thegustafson.com/blog/attention-from-scratch Arc 4: Transformers from First Principles Queries, keys, and values as learned linear projections, how scaled dot-product computes soft token-to-token lookups, and exactly why we divide by sqrt(d_k). https://thegustafson.com/blog/multi-head-attention https://thegustafson.com/blog/multi-head-attention Arc 4: Transformers from First Principles Why multiple attention heads let the model attend to different relationship types in parallel, how heads partition the embedding dimension, and what the output projection does. https://thegustafson.com/blog/causal-masking https://thegustafson.com/blog/causal-masking Arc 4: Transformers from First Principles Why decoder models must not attend to future tokens, how the triangular mask enforces this, and how masking shapes both training and generation. https://thegustafson.com/blog/positional-encodings-and-rope https://thegustafson.com/blog/positional-encodings-and-rope Arc 4: Transformers from First Principles Why attention is position-agnostic by default, how each encoding scheme injects order, why RoPE became dominant, and how ALiBi achieves length extrapolation. https://thegustafson.com/blog/ffn-as-memory https://thegustafson.com/blog/ffn-as-memory Arc 4: Transformers from First Principles The two-layer MLP that follows attention, why it can be interpreted as a learned key-value store over concepts, and what the intermediate dimension controls. https://thegustafson.com/blog/layer-norms https://thegustafson.com/blog/layer-norms Arc 4: Transformers from First Principles Why normalization is essential for deep residual networks, how pre-norm stabilizes training, and why RMSNorm replaced LayerNorm in modern architectures. https://thegustafson.com/blog/decoder-vs-encoder-decoder https://thegustafson.com/blog/decoder-vs-encoder-decoder Arc 4: Transformers from First Principles The structural differences between GPT-style and T5-style models, why decoder-only won for generative LLMs, and where encoder-decoder still shines. https://thegustafson.com/blog/reading-attention-is-all-you-need https://thegustafson.com/blog/reading-attention-is-all-you-need Arc 4: Transformers from First Principles The original 2017 paper section by section, connecting each design choice to what you already know, and noting which ideas survived and which were replaced. https://thegustafson.com/blog/moe-layers https://thegustafson.com/blog/moe-layers Arc 4: Transformers from First Principles How MoE replaces the dense FFN with sparse expert routing, the load-balancing problem, and how expert-choice routing solves it. https://thegustafson.com/blog/training-vs-inference https://thegustafson.com/blog/training-vs-inference Arc 5: Decoding & the Real Inference Algorithm Why the model you trained on full sequences behaves completely differently when it generates one token at a time, and what that means for everything that follows. https://thegustafson.com/blog/prefill-vs-decode https://thegustafson.com/blog/prefill-vs-decode Arc 5: Decoding & the Real Inference Algorithm How the prompt is processed in parallel (prefill) but generation is strictly sequential (decode), and why this split dominates every performance conversation. https://thegustafson.com/blog/the-one-new-row https://thegustafson.com/blog/the-one-new-row Arc 5: Decoding & the Real Inference Algorithm Walking through the exact matrix operations at each decode step to see why generation is memory-bound, not compute-bound. https://thegustafson.com/blog/kv-cache-from-first-principles https://thegustafson.com/blog/kv-cache-from-first-principles Arc 5: Decoding & the Real Inference Algorithm Deriving the key-value cache by noticing which attention computations are redundant, then watching memory grow linearly with sequence length. https://thegustafson.com/blog/sampling-strategies https://thegustafson.com/blog/sampling-strategies Arc 5: Decoding & the Real Inference Algorithm How each strategy reshapes the probability distribution over the vocabulary, when to combine them, and what 'good randomness' actually looks like. https://thegustafson.com/blog/speculative-decoding https://thegustafson.com/blog/speculative-decoding Arc 5: Decoding & the Real Inference Algorithm Using a small draft model to guess multiple tokens at once and a large model to verify them in parallel, turning sequential generation into a bet on acceptance rates. https://thegustafson.com/blog/continuous-batching https://thegustafson.com/blog/continuous-batching Arc 5: Decoding & the Real Inference Algorithm Why naive batching wastes GPU cycles on padding, and how iteration-level scheduling lets new requests join a running batch the moment a slot opens. https://thegustafson.com/blog/prefix-caching https://thegustafson.com/blog/prefix-caching Arc 5: Decoding & the Real Inference Algorithm Sharing KV cache across requests that start with the same system prompt, and the cache-eviction policies that make it practical. https://thegustafson.com/blog/structured-generation https://thegustafson.com/blog/structured-generation Arc 5: Decoding & the Real Inference Algorithm How grammar-guided decoding and JSON-mode work by masking logits at each step, and the tradeoff between constraint strength and generation speed. https://thegustafson.com/blog/what-an-inference-engine-does https://thegustafson.com/blog/what-an-inference-engine-does Arc 6: Inference Engines & Serving Systems The concrete responsibilities — graph optimization, memory allocation, scheduling, kernel dispatch — that sit between your model weights and an HTTP response. https://thegustafson.com/blog/kernel-fusion https://thegustafson.com/blog/kernel-fusion Arc 6: Inference Engines & Serving Systems Why fusing multiple operations into a single GPU kernel reduces memory round-trips, and how FlashAttention is the poster child for this idea. https://thegustafson.com/blog/paged-attention https://thegustafson.com/blog/paged-attention Arc 6: Inference Engines & Serving Systems Treating KV cache like virtual memory pages so you stop wasting 60-80% of GPU RAM on fragmentation. https://thegustafson.com/blog/memory-management https://thegustafson.com/blog/memory-management Arc 6: Inference Engines & Serving Systems A unified picture of where bytes go — weights, activations, KV cache, CUDA context — and how to reason about what fits on your GPU. https://thegustafson.com/blog/quantization https://thegustafson.com/blog/quantization Arc 6: Inference Engines & Serving Systems Shrinking weight precision to serve larger models on smaller hardware, with an honest look at what quality you lose and when. https://thegustafson.com/blog/parallelism-strategies https://thegustafson.com/blog/parallelism-strategies Arc 6: Inference Engines & Serving Systems Three ways to split a model across multiple GPUs, each with different latency and throughput profiles. https://thegustafson.com/blog/throughput-vs-latency https://thegustafson.com/blog/throughput-vs-latency Arc 6: Inference Engines & Serving Systems Why optimizing for tokens-per-second and optimizing for time-to-first-token are fundamentally in tension, and how batching policy mediates. https://thegustafson.com/blog/comparing-engines https://thegustafson.com/blog/comparing-engines Arc 6: Inference Engines & Serving Systems A framework for choosing an inference stack based on your actual constraints — hardware, model size, latency budget, and deployment environment. https://thegustafson.com/blog/benchmarking-inference https://thegustafson.com/blog/benchmarking-inference Arc 6: Inference Engines & Serving Systems How to run meaningful load tests, what metrics to capture, and why published benchmark numbers rarely transfer to your workload. https://thegustafson.com/blog/pretraining-data https://thegustafson.com/blog/pretraining-data Arc 7: Training & Post-Training How the composition and quality of the training corpus shapes capabilities more than architecture changes do. https://thegustafson.com/blog/distributed-training https://thegustafson.com/blog/distributed-training Arc 7: Training & Post-Training The three dominant frameworks for spreading a training run across hundreds of GPUs, and the communication costs each one pays. https://thegustafson.com/blog/sft https://thegustafson.com/blog/sft Arc 7: Training & Post-Training Taking a pretrained base model and teaching it to follow instructions by training on (prompt, response) pairs, plus the formatting details that matter more than you'd think. https://thegustafson.com/blog/rlhf https://thegustafson.com/blog/rlhf Arc 7: Training & Post-Training How human preferences get compressed into a reward model, then used to steer generation via reinforcement learning, step by step. https://thegustafson.com/blog/dpo-and-variants https://thegustafson.com/blog/dpo-and-variants Arc 7: Training & Post-Training Why Direct Preference Optimization collapses the RLHF pipeline into a single supervised loss, and how IPO, KTO, and ORPO each tweak the formula. https://thegustafson.com/blog/constitutional-ai https://thegustafson.com/blog/constitutional-ai Arc 7: Training & Post-Training Replacing human labelers with model-generated critiques guided by explicit principles, and what that buys you at scale. https://thegustafson.com/blog/tool-use-finetuning https://thegustafson.com/blog/tool-use-finetuning Arc 7: Training & Post-Training How models learn to emit structured tool calls, the data formats that work, and why function-calling reliability is a training problem, not a prompting problem. https://thegustafson.com/blog/long-context-training https://thegustafson.com/blog/long-context-training Arc 7: Training & Post-Training RoPE scaling, progressive context extension, and the data strategies needed to make a model actually use its full context window. https://thegustafson.com/blog/synthetic-data-distillation https://thegustafson.com/blog/synthetic-data-distillation Arc 7: Training & Post-Training Using a stronger model to generate training data for a weaker one, when this works surprisingly well, and when it collapses. https://thegustafson.com/blog/lora-and-peft https://thegustafson.com/blog/lora-and-peft Arc 7: Training & Post-Training Freezing most weights and training low-rank adapters instead, with a clear picture of when PEFT matches full fine-tuning and when it falls short. https://thegustafson.com/blog/loss-vs-benchmarks https://thegustafson.com/blog/loss-vs-benchmarks Arc 8: Evaluation & Scientific Discipline Why validation loss is a smooth, reliable signal and benchmarks are noisy and gameable, but closer to what users actually care about. https://thegustafson.com/blog/eval-harnesses https://thegustafson.com/blog/eval-harnesses Arc 8: Evaluation & Scientific Discipline How standardized evaluation frameworks work under the hood — prompt formatting, few-shot setup, metric aggregation — and why details matter enormously. https://thegustafson.com/blog/contamination https://thegustafson.com/blog/contamination Arc 8: Evaluation & Scientific Discipline How benchmark answers end up in training data, the detection methods that exist, and why this problem is getting worse, not better. https://thegustafson.com/blog/evaluating-reasoning https://thegustafson.com/blog/evaluating-reasoning Arc 8: Evaluation & Scientific Discipline Why multiple-choice accuracy on MMLU tells you almost nothing about reasoning, and what newer evals like GPQA and FrontierMath attempt to measure instead. https://thegustafson.com/blog/tool-agent-evals https://thegustafson.com/blog/tool-agent-evals Arc 8: Evaluation & Scientific Discipline The unique challenges of evaluating multi-step tool use — partial credit, trajectory scoring, environment determinism — and why end-to-end pass rates hide most of the signal. https://thegustafson.com/blog/human-preference-eval https://thegustafson.com/blog/human-preference-eval Arc 8: Evaluation & Scientific Discipline How Chatbot Arena's Elo system works, what inter-annotator agreement looks like in practice, and the biases that style introduces over substance. https://thegustafson.com/blog/calibration-and-abstention https://thegustafson.com/blog/calibration-and-abstention Arc 8: Evaluation & Scientific Discipline Whether a model's stated confidence matches its actual accuracy, and why teaching models to say 'I don't know' is an unsolved evaluation problem. https://thegustafson.com/blog/embeddings-and-vector-search https://thegustafson.com/blog/embeddings-and-vector-search Arc 9: Retrieval, Memory & Context Engineering How text becomes geometry, from count-based vectors through contrastive learning to modern embedding models. https://thegustafson.com/blog/vector-search-and-ann https://thegustafson.com/blog/vector-search-and-ann Arc 9: Retrieval, Memory & Context Engineering How HNSW, IVF, and product quantization make billion-scale similarity search practical in databases like Pinecone, Qdrant, and pgvector. https://thegustafson.com/blog/dense-sparse-hybrid https://thegustafson.com/blog/dense-sparse-hybrid Arc 9: Retrieval, Memory & Context Engineering Comparing BM25, learned-sparse models like SPLADE, dense embeddings, and the hybrid fusion strategies that outperform any single approach. https://thegustafson.com/blog/chunking-strategies https://thegustafson.com/blog/chunking-strategies Arc 9: Retrieval, Memory & Context Engineering Fixed-size, semantic, recursive, and parent-document chunking, and how chunk design dominates retrieval quality more than your embedding model does. https://thegustafson.com/blog/rerankers https://thegustafson.com/blog/rerankers Arc 9: Retrieval, Memory & Context Engineering Why a cheap first-stage retriever plus an expensive cross-encoder reranker beats a single-stage system, and how ColBERT bridges the gap. https://thegustafson.com/blog/rag-end-to-end https://thegustafson.com/blog/rag-end-to-end Arc 9: Retrieval, Memory & Context Engineering Tracing a query from ingestion through retrieval, reranking, prompt assembly, and generation — covering naive RAG, multi-hop, and agentic RAG patterns. https://thegustafson.com/blog/graphrag https://thegustafson.com/blog/graphrag Arc 9: Retrieval, Memory & Context Engineering How entity-relationship graphs enable multi-hop reasoning that flat vector search cannot, from Microsoft's GraphRAG to community-based summarization. https://thegustafson.com/blog/context-windows https://thegustafson.com/blog/context-windows Arc 9: Retrieval, Memory & Context Engineering Why a 1M-token window does not mean 1M tokens of useful recall, covering lost-in-the-middle effects, context rot, and working-memory bottlenecks. https://thegustafson.com/blog/context-engineering https://thegustafson.com/blog/context-engineering Arc 9: Retrieval, Memory & Context Engineering Treating context as a scarce resource: sliding-window summarization, tool-result clearing, scratchpads, and sub-agent context isolation. https://thegustafson.com/blog/history-of-agents https://thegustafson.com/blog/history-of-agents Arc 10: Tools, Protocols & Agent Loops The lineage from chain-of-thought prompting and ReAct through Toolformer, function calling, and today's production agent systems. https://thegustafson.com/blog/function-calling https://thegustafson.com/blog/function-calling Arc 10: Tools, Protocols & Agent Loops How providers constrain decoder output to valid JSON tool calls using grammars, guided decoding, and schema-conditioned sampling. https://thegustafson.com/blog/the-agent-loop https://thegustafson.com/blog/the-agent-loop Arc 10: Tools, Protocols & Agent Loops Dissecting the core execute-observe-decide cycle that every agent framework implements, including error handling and retry logic. https://thegustafson.com/blog/transcript-formats https://thegustafson.com/blog/transcript-formats Arc 10: Tools, Protocols & Agent Loops Comparing Anthropic's content-block array, OpenAI's tool_calls messages, and Gemini's function-call parts to understand what the model actually sees. https://thegustafson.com/blog/mcp https://thegustafson.com/blog/mcp Arc 10: Tools, Protocols & Agent Loops What the Model Context Protocol solves, how servers expose tools/resources/prompts, and why it became the dominant standard for tool integration. https://thegustafson.com/blog/remote-mcp-and-auth https://thegustafson.com/blog/remote-mcp-and-auth Arc 10: Tools, Protocols & Agent Loops Moving MCP beyond local stdio: streamable HTTP transport, OAuth 2.1 with PKCE, and the enterprise authentication landscape. https://thegustafson.com/blog/planning-and-reasoning https://thegustafson.com/blog/planning-and-reasoning Arc 10: Tools, Protocols & Agent Loops How extended thinking, chain-of-thought budgets, and explicit planning steps improve agent task-success rates, and where they still fail. https://thegustafson.com/blog/computer-use https://thegustafson.com/blog/computer-use Arc 10: Tools, Protocols & Agent Loops How screenshot-driven computer use and browser agents work, from Anthropic's approach to CUA, and their current safety boundaries. https://thegustafson.com/blog/multi-agent https://thegustafson.com/blog/multi-agent Arc 10: Tools, Protocols & Agent Loops Orchestration patterns (supervisor, swarm, pipeline), Google's A2A protocol, and when multi-agent actually beats single-agent. https://thegustafson.com/blog/openai-api https://thegustafson.com/blog/openai-api Arc 11: Provider Ecosystems in Practice The evolution through Completions, Chat Completions, Assistants, and the agent-native Responses API with built-in tools and conversations. https://thegustafson.com/blog/anthropic-api https://thegustafson.com/blog/anthropic-api Arc 11: Provider Ecosystems in Practice The Messages API's content-block design, extended thinking with interleaved reasoning, prompt caching, and context-editing tools. https://thegustafson.com/blog/google-api https://thegustafson.com/blog/google-api Arc 11: Provider Ecosystems in Practice Gemini's multimodal-native function calling, grounding with Google Search, the Agent Development Kit, and how thought signatures differ from Anthropic's approach. https://thegustafson.com/blog/open-weight-models https://thegustafson.com/blog/open-weight-models Arc 11: Provider Ecosystems in Practice The practical landscape of weights-available models: licensing, fine-tuning rights, multilingual strengths, and where open models match or trail frontier APIs. https://thegustafson.com/blog/huggingface-ecosystem https://thegustafson.com/blog/huggingface-ecosystem Arc 11: Provider Ecosystems in Practice How the Hub, Transformers library, PEFT adapters, and Inference Endpoints form the connective tissue of open-weight model deployment. https://thegustafson.com/blog/cloud-model-marketplaces https://thegustafson.com/blog/cloud-model-marketplaces Arc 11: Provider Ecosystems in Practice How AWS Bedrock and Azure AI let enterprises consume multiple providers behind a single API, with guardrails, logging, and compliance controls. https://thegustafson.com/blog/lock-in-and-portability https://thegustafson.com/blog/lock-in-and-portability Arc 11: Provider Ecosystems in Practice The real switching costs between providers, what LiteLLM and similar shims can and cannot abstract, and how to architect for optionality. https://thegustafson.com/blog/scaling-laws https://thegustafson.com/blog/scaling-laws Arc 12: Governance, Economics & Trajectory From Kaplan to Chinchilla to Llama 3: what scaling laws actually tell us about returns on compute, data, and parameters. https://thegustafson.com/blog/inference-economics https://thegustafson.com/blog/inference-economics Arc 12: Governance, Economics & Trajectory Why inference dominates enterprise AI spend, how prompt caching and quantization cut costs, and why agentic workloads multiply token budgets dramatically. https://thegustafson.com/blog/open-vs-closed https://thegustafson.com/blog/open-vs-closed Arc 12: Governance, Economics & Trajectory The strategic tension between open-weight models and closed APIs, and what 'open' actually means in practice. https://thegustafson.com/blog/safety-and-alignment https://thegustafson.com/blog/safety-and-alignment Arc 12: Governance, Economics & Trajectory RLHF, constitutional AI, red-teaming, model cards, and responsible scaling policies — what the field has shipped and what remains unsolved. https://thegustafson.com/blog/ai-regulation https://thegustafson.com/blog/ai-regulation Arc 12: Governance, Economics & Trajectory The phased rollout from prohibited practices through GPAI obligations, plus the US executive order landscape and what practitioners need to know. https://thegustafson.com/blog/standards-wars https://thegustafson.com/blog/standards-wars Arc 12: Governance, Economics & Trajectory How Anthropic's MCP, Google's A2A, and OpenAPI compete and complement each other as the protocol stack for agentic AI. https://thegustafson.com/blog/history-2013-2026 https://thegustafson.com/blog/history-2013-2026 Arc 12: Governance, Economics & Trajectory From word2vec through the transformer, GPT scaling, ChatGPT, open-weight releases, and the agent era — the key inflection points that built today's stack. https://thegustafson.com/blog/what-comes-next https://thegustafson.com/blog/what-comes-next Arc 12: Governance, Economics & Trajectory Test-time compute scaling, multimodal-native architectures, world models, and the questions the field genuinely cannot yet answer.