Trace a Model's Lifecycle

You have studied each component of the current AI paradigm in isolation: the transformer architecture, pretraining objectives, scaling laws, emergent capabilities, alignment training, and inference. In practice, these components do not exist independently. Every frontier model is the result of dozens of deliberate choices made in sequence, each one constraining the next. A decision about data composition affects what capabilities emerge. A decision about model size affects alignment training cost. A decision about inference architecture affects who can afford to use the model. This lesson is structured around a central activity: you will trace a hypothetical-but-realistic frontier language model from its earliest stages of data collection through production deployment. At each stage, you will identify what decisions were made, why, what was gained, and what trade-offs were accepted. By the end, you will have built a complete mental model of a model's lifecycle.

The Seven Stages of a Model's Life

A frontier language model passes through the following stages before it is used by anyone outside the lab that built it. Stage 1: Data collection and curation. The training corpus must be assembled. For a modern frontier model this means acquiring web crawls (Common Crawl snapshots), licensing or scraping book corpora, pulling code from public repositories, and collecting multilingual content. Raw data must be cleaned: HTML markup stripped, duplicate documents removed, low-quality text filtered by heuristic and classifier-based quality scores, and potentially harmful content identified and removed. Data mixture ratios are decided here: what fraction of tokens comes from web text versus books versus code versus scientific papers. These decisions are among the most consequential in the entire lifecycle because they determine what the model learns and cannot unlearn. Stage 2: Architecture and hyperparameter decisions. The team decides on model size (number of parameters), the ratio of model width to depth (embedding dimension versus number of layers), the number of attention heads, the context window for training, and the activation function used in feedforward layers. These decisions are informed by scaling law predictions but also by practical constraints: what fits on available hardware, what has been shown to be stable to train, and what inference cost the intended deployment can support. A model designed for edge deployment has different constraints than one served from a data center. Stage 3: Pretraining. The model is trained on the assembled corpus using next-token prediction with the Adam optimizer, a learning rate schedule (warmup followed by cosine decay), and gradient clipping to prevent instability. Training a frontier model today may involve tens of thousands of GPUs or TPUs running for weeks to months. Mid-training, the team monitors training loss curves, watching for instabilities (spikes in loss that indicate numerical problems) and evaluating on downstream benchmarks periodically to track capability development. Compute costs at this stage range from tens to hundreds of millions of dollars for frontier scale. Stage 4: Post-pretraining evaluation. Before alignment training begins, the pretrained model is evaluated to understand its raw capability profile. What domains is it strong in? Where does it fail? What emergent capabilities are present? This evaluation informs which behaviors need to be reinforced in alignment training and which harmful patterns need to be suppressed.

Stage 5: Alignment training. The post-pretraining model undergoes supervised fine-tuning on a curated dataset of high-quality prompt-response pairs, followed by reinforcement learning from human feedback. Human annotators write comparison judgments across thousands to tens of thousands of prompt pairs. A reward model is trained on these judgments. The language model is then optimized using proximal policy optimization to maximize reward model scores. This stage may be iterated multiple times, with each iteration refining the balance between helpfulness, honesty, and harmlessness. Stage 6: Safety evaluation and red-teaming. Before deployment, the aligned model undergoes systematic red-teaming: a team of human testers attempts to elicit harmful, dishonest, or dangerous behavior from the model using a wide range of adversarial prompts. Capability evaluations probe for dangerous emergent abilities such as assistance with weapons of mass destruction or autonomous deception. The results of red-teaming inform further alignment training iterations or the addition of system-level guardrails. Only models that pass a defined safety threshold are approved for deployment. Stage 7: Deployment and monitoring. The model is deployed via an API or integrated product. Inference infrastructure must handle variable load, manage KV caches efficiently, and route requests to available hardware. After deployment, the team monitors for unexpected behaviors, collects user feedback that can inform future fine-tuning, and tracks whether the model's behavior drifts over time or under distribution shift. Periodic safety monitoring continues throughout the model's production life.