Foundation

Dossier

What this layer is

Everything below this layer is plumbing. The chips do matrix multiplication; the data centers keep the chips fed and cooled. Everything above it is packaging. The agent frameworks, the RAG pipelines, the copilots — all of it is scaffolding around a single artifact that lives here: the foundation model. A few hundred gigabytes of numbers that, arranged correctly, complete text, write code, describe images, and pass bar exams.

The term "foundation model" was coined by Stanford researchers in 2021 ⚑ unverified to name something new: a model trained once, at enormous cost, on broad data, then adapted to a thousand downstream tasks. Before this era, you trained a model per task — one for sentiment, one for translation, one for summarization. The foundation-model bet was that one very large model, trained on enough of everything, would beat all the specialists at their own games. The bet paid off, and it restructured the entire industry around a small number of extremely expensive artifacts.

This dossier covers what those artifacts are, how they get made, where they break, and who pays for what.

What a foundation model actually is

Strip away the product surface and a large language model is a function. It takes a sequence of tokens — text chopped into subword fragments, roughly three-quarters of a word each on average ⚑ unverified — and outputs a probability distribution over what token comes next. That is the whole trick. Generation is just running the function repeatedly: predict a token, append it, predict the next one, until a stop condition.

The function is a transformer: a stack of identical layers, each combining an attention mechanism (which lets every token look at every other token in the context and decide what's relevant) with a feed-forward network (which does per-token computation on what attention gathered). The parameters — the "weights" — are the learned numbers inside those layers. A 70-billion-parameter model has seventy billion of them. On disk at full precision that's roughly 140 GB ⚑ unverified; the model is literally that file of numbers plus the code to run them.

Two properties of the transformer explain why this architecture won:

It parallelizes. Unlike its predecessors (recurrent networks, which processed text one token at a time), a transformer processes every token in a training sequence simultaneously. That maps perfectly onto GPUs, which are machines for doing thousands of identical operations at once. The architecture and the hardware co-evolved; the transformer is, in a real sense, the shape of a neural network that a GPU wants to run.

It scales predictably. Make the model bigger, feed it more data, spend more compute, and the loss — the model's error at next-token prediction — falls along a smooth, predictable curve. These are the scaling laws, and they turned model-building from artisanal guesswork into capital allocation. If you can predict the return on the next order of magnitude of compute, you can raise money for it. That predictability, more than any single research result, is what summoned the hundreds of billions of dollars now flowing through the layers below this one.

The refinement that matters most in practice is the Chinchilla result (DeepMind, 2022): for a fixed compute budget, model size and training-data volume should scale together — roughly 20 tokens of training data per parameter for compute-optimal training ⚑ unverified. The industry then discovered a second-order move: train past compute-optimal, on far more data than Chinchilla prescribes, because a smaller model trained longer is cheaper to serve. Training cost is paid once; inference cost is paid forever. Llama 3's 8B model was trained on roughly 15 trillion tokens — nearly 100x the Chinchilla-optimal ratio ⚑ unverified — precisely because Meta wanted a small model that punches above its weight at inference time. Most modern open-weight models follow this overtraining recipe. It is an economic decision expressed in a hyperparameter.

How one gets made: the pipeline

The path from raw internet to a chat model you can ship has distinct stages, and confusing them is the most common error in coverage of this industry. In order:

1. Data. Trillions of tokens of text: web crawls (Common Crawl and proprietary equivalents), code repositories, books, papers, licensed corpora, and — increasingly — synthetic data generated by other models. The unglamorous truth is that data work dominates: deduplication, quality filtering, contamination scrubbing (removing benchmark answers from the training set), toxicity filtering, language balancing. Labs guard their data recipes more closely than their architectures, because architecture is mostly convergent now and data is where models actually differentiate. The legal status of much of this data is contested — the NYT v. OpenAI litigation and its siblings hang over the whole layer ⚑ unverified.

2. Pretraining. The big one. The model learns next-token prediction across the whole corpus, running on thousands of GPUs for weeks to months. This is where the capital goes and where essentially all of the model's raw capability comes from. A frontier pretraining run is a single, mostly-unrepeatable industrial event: if the run diverges (loss spikes, hardware failures cascade), you lose real money in a way that has few parallels in software. Meta reported that during a 54-day Llama 3 405B training run on 16,384 H100s, there were 419 unexpected interruptions — roughly one every three hours — mostly from GPU and HBM failures ⚑ unverified. At this scale, hardware reliability is a training hyperparameter.

What pretraining produces is a base model: an alien artifact that is extremely good at continuing text and nothing else. Ask a base model a question and it may answer, or it may continue your question with three more questions, because that's what documents on the internet look like. It has capability without interface.

3. Post-training (alignment). The stage that turns the base model into a product. Covered in its own section below, because it's the part the public most misunderstands.

4. Evaluation. Benchmarks (MMLU, GPQA, SWE-bench, and their successors), red-teaming, human preference testing, safety evals. Also covered below, under "where it breaks" — because evaluation is one of the places where this layer is genuinely broken.

5. Ship. Weights deployed behind an API, or published for download. This fork — API or weights — is the single most consequential business decision in the layer, and it gets its own section too.

Post-training: SFT, RLHF, DPO

The base model knows things; post-training makes it usable and steerable. Three techniques dominate, and they stack:

Supervised fine-tuning (SFT). Continue training the model, but on a small, curated set of examples of the behavior you want: prompt in, ideal response out. Tens of thousands to millions of examples, versus the trillions of pretraining tokens. SFT teaches format and register — answer the question, use markdown, refuse this category of request — extremely efficiently. It's mimicry: the model learns to imitate the demonstration data. The catch is that SFT can only teach what demonstrators can write down, and it can teach the model to confidently imitate answering questions it doesn't actually know the answers to — one identified mechanical source of hallucination ⚑ unverified.

RLHF — reinforcement learning from human feedback. The insight that made ChatGPT possible: humans are much better at comparing two responses than at writing a perfect one. So: sample pairs of model responses, have humans pick the better one, train a separate reward model to predict those preferences, then use reinforcement learning (classically PPO) to optimize the language model against the reward model. The model learns to produce what humans prefer, including qualities that are hard to demonstrate but easy to recognize — helpfulness, appropriate hedging, tone.

RLHF has a known failure mode that matters for everything downstream: reward hacking. The model optimizes the reward model, not actual human preference, and the reward model is an imperfect proxy. Models learn that longer answers score better, that confident answers score better, that flattery scores better. Sycophancy — the model agreeing with whatever the user asserts — is a documented, measured artifact of preference training ⚑ unverified, not a personality quirk. When a chatbot tells you your bad idea is brilliant, you are looking at an optimization target leaking through.

DPO — direct preference optimization. A 2023 result ⚑ unverified showing you can skip the reward model and the RL loop entirely: a clever loss function trains the model directly on preference pairs, with much less engineering complexity than PPO. DPO and its variants became the default for open-weight post-training almost immediately because they're stable and cheap. The frontier labs still largely use RL-based methods — partly because at the frontier, RL is now doing more than preference-matching: reasoning models (OpenAI's o-series, DeepSeek-R1, and successors) are trained with reinforcement learning against verifiable rewards — does the math check out, does the code pass the tests — which is a different and more powerful regime than "which answer did the human like."

A variant worth naming because this site's own tooling runs on it: RLAIF / Constitutional AI (Anthropic), where the preference labels come from an AI judge applying a written set of principles rather than from human raters, cutting the human-labeling bottleneck.

The honest summary of alignment-as-practiced: it is behavioral shaping, not verification. Post-training makes models dramatically more useful and safer in distribution. What it cannot yet do is guarantee behavior out of distribution, and every deployed model is out of distribution most of the time.

Embeddings: the other half of the layer

Generation gets the headlines; embeddings do the quiet work. An embedding model maps text (or images, or audio) to a vector — a list of, say, 768 or 3,072 numbers ⚑ unverified — such that semantically similar inputs land near each other in that space. "How do I reset my password" and "I can't log into my account" end up close together despite sharing almost no words.

That property is the engine of modern retrieval. Every RAG pipeline (Orchestration layer's territory) is built on it: embed your documents, embed the query, find the nearest neighbors, hand them to the generator. Semantic search, deduplication, recommendation, clustering, classification — all embeddings underneath.

Two facts practitioners know and coverage misses. First, embedding models are cheap relative to generators — small enough to run on modest hardware, priced at pennies per million tokens via API ⚑ unverified — which means the retrieval half of an AI system costs a rounding error compared to the generation half. Second, embeddings from different models are mutually incompatible: vectors from model A mean nothing in model B's space. Choosing an embedding model is a long-term commitment, because switching means re-embedding your entire corpus. It's the closest thing this layer has to vendor lock-in by geometry.

Quantization: making the numbers smaller

A model's weights are stored as numbers at some precision — historically 32-bit floats, now typically 16-bit for training (BF16) and less for serving. Quantization is the compression of those numbers to lower precision: 8-bit, 4-bit, and below. The payoff is direct: a 70B-parameter model at 16 bits needs ~140 GB of memory; at 4 bits, ~40 GB ⚑ unverified — the difference between a multi-GPU server and a single workstation card, or between a rack and a laptop.

The remarkable empirical fact is how little quality is lost. Down to roughly 4 bits per weight, well-executed quantization (GPTQ, AWQ, and the GGUF K-quant family used by llama.cpp) costs low single digits on most benchmarks ⚑ unverified — the models are heavily over-parameterized, and the redundancy absorbs the rounding. Below 4 bits, degradation gets steep and uneven: the model may still benchmark acceptably while getting subtly worse at edge cases, long-context coherence, and less-common languages — exactly the places benchmarks don't look.

Quantization matters strategically, not just technically: it is the enabling technology of the local-AI movement. Every model running on a home GPU, every llama.cpp deployment, every "run it on your MacBook" demo is a quantized model. Without 4-bit quantization, open weights would be a licensing curiosity; with it, they're a distribution channel that ends at consumer hardware. (This site's own infrastructure runs quantized open-weight models on a 64 GB machine; the practice is not hypothetical.)

There is also inference-time quantization of the KV cache and activations, and training-time low precision (FP8 training is now standard at the frontier; FP4 is arriving with the latest accelerator generations ⚑ unverified) — the entire stack is on a long march toward fewer bits everywhere, because bits are memory bandwidth and memory bandwidth is the binding constraint (Hardware layer's story).

Multimodal: one model, many senses

The current generation of frontier models is natively multimodal: they consume images, audio, video, and documents alongside text, and increasingly generate more than text. Mechanically, the dominant recipe is unification by tokenization: an image is carved into patches, each patch encoded (typically by a vision transformer) into embeddings that enter the same sequence the text tokens do; the transformer attends across all of it indifferently. The model doesn't "see" and "read" as separate acts — it processes one interleaved token stream.

Two consequences worth holding onto. First, images are expensive: a single high-resolution image can occupy hundreds to thousands of tokens of context ⚑ unverified, which is why vision-heavy workloads cost more and fill context windows fast. Second, multimodality inherits every text-side failure mode and adds its own: models misread charts, hallucinate text in images, and miscount objects, with the same confident fluency they bring to text. The demo is the model describing a meme; the production reality is a document-processing pipeline where a misread table costs money.

Fully-multimodal generation — models that natively emit speech and images from the same weights that handle text (GPT-4o's voice, Gemini's native image generation, and successors) — has collapsed what used to be a pipeline of separate models into a single artifact. The dedicated image/video-generation model families (diffusion and its descendants) remain a parallel track with different mechanics; they share this layer but not this dossier's depth — the Application layer covers what's built on them.

Where it breaks

This layer's failure modes are not bugs to be patched. They are properties of the artifact, and every layer above inherits them.

Hallucination. The model is a next-token predictor trained to produce plausible text. Truth and plausibility usually correlate — that's why the thing is useful — but when they diverge, the model follows plausibility, fluently and with total confidence. It fabricates citations that look exactly like real citations, case law that reads exactly like case law, API methods that are exactly what the API should have. There is no internal flag distinguishing retrieval from confabulation; the mechanism generating the true sentence and the false one is the same mechanism. Post-training reduces the rate; grounding via retrieval reduces it further; nothing eliminates it. Reasoning models complicate the picture rather than resolving it — they make fewer simple factual errors but can construct elaborate, internally-consistent wrong answers, which are harder to catch, and some hallucination benchmarks have shown reasoning-model regressions ⚑ unverified. Any product built on this layer that cannot tolerate a confident falsehood needs a verification layer that is not the model.

Context limits. The context window — how much the model can attend to at once — has grown from 2K tokens (GPT-3 era) to 128K–200K standard and 1M+ at the high end (Gemini's long-context tier) ⚑ unverified. The headline number misleads in two ways. First, cost: attention's KV cache grows with context length, so long context is paid for in memory and latency — million-token calls are slow and expensive, not free just because they're possible. Second, quality: models demonstrably use the middle of long contexts less well than the edges ("lost in the middle" ⚑ unverified), and needle-in-a-haystack benchmarks — finding one planted fact — dramatically overstate real long-context competence, which degrades on tasks requiring synthesis across the window. The practical ceiling is lower than the advertised one, which is why RAG did not die when long context arrived, despite annual predictions that it would.

Cost. Frontier-model inference is priced per million tokens, and the numbers per call look tiny until volume arrives. An agentic workload that loops — read, think, call a tool, read the result, think again — multiplies token consumption by one to two orders of magnitude over single-shot chat ⚑ unverified. Teams routinely discover their AI feature's unit economics are underwater only after launch. The layer's whole pricing structure is also unstable in a specific direction: per-token prices have fallen precipitously year over year for equivalent capability ⚑ unverified, which is wonderful for buyers and brutal for anyone whose margin depends on reselling tokens (see economics, below).

Evaluation difficulty. The layer cannot reliably measure itself, and this is a load-bearing problem. Static benchmarks saturate (frontier models cluster near the ceiling on MMLU-class suites) and contaminate (benchmark data leaks into training corpora, so scores partially measure memorization ⚑ unverified). Arena-style human-preference leaderboards measure what raters like — length, confidence, formatting — which is adjacent to, not identical with, being right; documented gaming of arena rankings has forced methodology changes ⚑ unverified. Meanwhile the capabilities that matter commercially — multi-step agentic reliability, honesty under pressure, performance on your task with your data — have no standard public measure at all. The result: model choice runs on vibes, marketing, and private evals, and every "Model X beats Model Y" headline should be read as "on this benchmark, at this time, possibly in the training set." When this site compares models, the eval-difficulty caveat travels with the comparison. That's the meter rule applied to the layer itself: measure or say you can't.

The economics

Training is capex with a shelf life. A frontier training run costs on the order of $100 million and up — Altman put GPT-4 at "more than $100M" ⚑ unverified; credible estimates for subsequent frontier runs reach into the hundreds of millions, with a large share of the true cost sitting in the research runs, failed experiments, and staff around the headline run ⚑ unverified. The artifact this buys depreciates like fish, not like a factory: an 18-month-old frontier model is a commodity, matched or beaten by open-weight models that cost a fraction as much to train. Every frontier lab is therefore on a treadmill — the training runs must continue, at growing scale, merely to keep the capability lead that justifies the pricing. The scale of that treadmill's forward commitments is a Bubble Watch subject; the mechanics are this layer's.

Inference is the business. Whatever training costs, revenue arrives per token served, and the gross margin on inference is the number that decides whether this layer is a business or a subsidy. That margin is genuinely uncertain from outside: serving costs depend on utilization, batching, hardware generation, and context length in ways providers don't disclose. What's visible is the price war — per-token prices falling fast at every capability tier ⚑ unverified — and the strategic behavior it implies: labs pushing usage-based enterprise deals, premium reasoning tiers (where a "thinking" model consumes far more compute per answer, re-expanding the revenue per query), and vertical products (coding agents, enterprise assistants) that capture more value than raw token resale. Selling tokens is a commodity business the moment your model isn't clearly the best; everything the labs do makes sense read as an escape from that fate.

The open-weight disruption. The single most destabilizing force in the layer. When Meta released Llama's weights — then Mistral, then the Chinese labs (Qwen/Alibaba, DeepSeek) at accelerating quality — they set a price floor of zero for last-generation capability. DeepSeek's V3/R1 releases in early 2025 were the watershed: near-frontier capability, weights downloadable, with a claimed marginal training cost around $5.6M ⚑ unverified — and the claim alone was enough to shave hundreds of billions off AI-adjacent market caps in a day ⚑ unverified. The mechanism matters more than the incident: open weights convert the frontier labs' product into a depreciating lead over a free alternative. The lead is real — frontier closed models remain ahead, especially on reasoning and reliability — but it must be re-earned continuously against a competitor whose price is zero and whose distribution is a download link.

Why give weights away? Meta's stated logic is commoditize-your-complement: Meta sells attention, not tokens, and free models weaken rivals whose business is tokens. The Chinese labs' open releases function as talent-and-standards plays and as an end-run around compute export controls — capability that ships as a file crosses borders that chips cannot. None of it is charity; all of it reshapes the layer's economics.

The equilibrium this produces, visible now: closed frontier models own the capability edge and the enterprise trust; open weights own everything cost-sensitive, private, or sovereign; and a thriving middle — the inference providers in The Kit below — makes a business of serving open weights faster and cheaper than you can yourself. Whether the frontier edge stays wide enough, for long enough, to service the capital committed to maintaining it — that is not this page's question. That's Bubble Watch's. This page's job is to make sure you understand the machine well enough to follow the money.

Concepts & Guides

Pretraining vs fine-tuning — what each one actually changes

The distinction that unlocks the rest. Pretraining sets essentially all of the model's knowledge and capability, at a cost of millions to hundreds of millions of dollars; fine-tuning adjusts behavior — style, format, domain register — at a cost of tens to thousands of dollars. The guide's core correction: teams reach for fine-tuning to "teach the model our data," which is mostly the wrong tool — fine-tuning is bad at adding facts (that's retrieval's job) and good at teaching form. Covers: full fine-tuning vs LoRA/PEFT (train small adapter matrices instead of all weights — the technique that made fine-tuning affordable), when fine-tuning beats prompting (rarely: high-volume, narrow, format-critical tasks), catastrophic forgetting, and the decision tree: prompt first, RAG for knowledge, fine-tune for behavior, pretrain never (you are not a lab). Runnable: LoRA fine-tune of a small open model on a format task, before/after evals.

How alignment actually works — SFT, RLHF, DPO without the mysticism

The pipeline from base model to assistant, mechanically: demonstration data → SFT; preference pairs → reward model → PPO, or the DPO shortcut; and RL-with-verifiable-rewards for reasoning. The guide's honest half: reward hacking, sycophancy as a measurable training artifact, why "aligned" means "shaped in distribution" and not "verified safe," and what a jailbreak is mechanically (an input that walks the model out of the shaped region). Also the labor story most coverage skips: preference data comes from thousands of human raters, increasingly assisted or replaced by AI judges (RLAIF), with the quality of the whole edifice resting on the quality of those judgments. Engineer-nod test: a reader can explain why RLHF makes models long-winded.

Context windows and the KV cache — why long context isn't free

What the context window physically is: not memory in any human sense, but the span of tokens attention can see. The KV cache — cached key/value vectors for every token, every layer — is why context costs GPU memory linearly and why prefill on a 500-page document takes seconds before the first output token. Covers: why prices often distinguish input vs output tokens, prompt caching (reusing prefill across calls — the single cheapest optimization most teams skip), "lost in the middle" and the gap between needle-in-a-haystack scores and real synthesis, and why RAG survived long context. Runnable: measure time-to-first-token vs context length on a local model; watch the cache grow in VRAM.

Quantization tradeoffs — how far you can shrink before it lies to you

From FP32 to 4-bit and below: what a bit of precision buys, why 4-bit is the current sweet spot, and what actually degrades below it (edge cases, long-context coherence, minority languages — the stuff benchmarks undersample). Formats and methods practitioners actually meet: BF16, FP8, INT8, GPTQ, AWQ, GGUF K-quants; weights-only vs weights+activations; KV-cache quantization. The rule-of-thumb table the reader keeps: bits × parameters → VRAM. The honest half: perplexity deltas understate task-level damage; a quant that benchmarks fine can still be the wrong choice for your workload; always eval the quant, not the model. Runnable: same model at Q8/Q5/Q4/Q2 via llama.cpp, same prompts, side-by-side outputs and VRAM/tok-s measurements — this site's own hardware makes this demo native.

Embeddings and retrieval — meaning as coordinates

What an embedding actually is; cosine similarity as the workhorse; why retrieval quality — not the generator — caps RAG quality (garbage retrieved, garbage generated). Covers: embedding-model choice as lock-in-by- geometry (switching = re-embed everything), dimensionality tradeoffs (Matryoshka embeddings), dense vs sparse vs hybrid retrieval, rerankers as the cheap accuracy upgrade, and multilingual gotchas. Bridges to the Orchestration layer's RAG guide, which owns the pipeline mechanics. Runnable: embed a small corpus, visualize neighborhoods, break retrieval deliberately with an out-of-domain query.

What actually makes two models differ — reading a model release like an engineer

The architecture is convergent — nearly everything is a decoder-only transformer, increasingly mixture-of-experts (MoE: many expert sub-networks, a router activating a few per token, so a huge model spends like a small one — the trick behind most modern frontier and open flagships). So what differs? Data (the real moat: recipe, volume, quality, synthetic fraction), post-training (where "personality," instruction-following, and reasoning behavior come from), scale and the active/total parameter split, context length, modality coverage, and license terms. The guide teaches the skeptical read of a release post: which benchmarks are shown vs omitted, contamination risk, "MoE total parameters" headline inflation, and why two models with identical MMLU scores behave completely differently on your task. Ends with the practical checklist behind [asset: C28 Which model when].

The Kit

The real tools, vendors, and models of the Foundation layer — what each one is, when to reach for it, and the honest caveats. This is the layer’s directory slice: 20 entries are flagged affiliate-eligible, and none carry a live link yet — mentions stay plain until partner programs exist, and links will activate by data change, not re-edit.

Winner Matrix

News & Video

What counts as Foundation news (routing definition)

• Model releases — frontier closed launches, open-weight drops, reasoning-tier updates. The feed's bread and butter. Each item carries: who, what tier, open or closed, headline capability claim, and — meter rule — what's verified vs claimed at post time.
• Training and methods — scaling results, post-training advances (new RL recipes, DPO descendants), data-recipe disclosures, efficiency claims. High signal, low volume.
• Benchmark and eval events — new evals, saturation milestones, contamination findings, leaderboard controversies. This site treats eval news as first-class, because the dossier's position is that evaluation is where the layer is broken.
• Open-vs-closed economics — license changes, API price moves, training-cost claims and their audits. Feeds Bubble Watch when the numbers get systemic; the mechanics stay here.
• Alignment and safety research — published results on model behavior (sycophancy, reward hacking, jailbreak classes). Research coverage, not doom coverage — blunt register, no symbolism.
• Litigation and data provenance — training-data suits and rulings, as they land. (Human/social fallout routes to AI Impact; the mechanics-of-the-layer angle stays here.)

Not this layer's feed: GPU/chip news (Hardware) · data-center and power builds (Infrastructure) · agent-framework and RAG tooling (Orchestration) · product launches built on models (Application). The classifier prompt encodes these boundaries; ambiguous items get the confirm step.

Source list (feed inputs, Foundation-tagged)

• Lab primary sources: OpenAI / Anthropic / Google DeepMind / Meta AI / Mistral / Qwen / DeepSeek blogs and release notes — always cite the primary post, not coverage of it.
• Research flow: arXiv (cs.CL, cs.LG — curated, not firehose), Papers with Code, technical reports accompanying releases.
• Practitioner signal: Hugging Face (model hub trending + blog), r/LocalLLaMA (the open-weight community's trading floor — already wired into this site's forum-sentiment pipeline), Interconnects (Nathan Lambert — the best public post-training coverage), Simon Willison's weblog (practitioner ground truth on what models actually do).
• Leaderboards as news sources, with the standing caveat: LMArena, Artificial Analysis (independent price/speed/quality tracking — also a data source for [asset: D34]), SWE-bench and successors. Every leaderboard citation carries the eval-difficulty disclaimer inline.
• Industry/business layer: The Information, SemiAnalysis (when they cover model economics rather than silicon) — for the capex and margin stories the dossier's economics section tracks.

Video (curated explainers, embedded + tagged to this layer)

Standing picks, each tagged to the dossier section it illuminates:

• Andrej Karpathy — "Let's build GPT" / "Intro to LLMs" / the tokenizer deep-dive — the canonical from-scratch builds; pairs with the pretraining and tokenization material. The single best "engineer-nod" video source in existence for this layer.
• 3Blue1Brown — the neural-network / transformer / attention series — the visual intuition track; pairs with the transformer diagram [asset: A2] and the Principles layer bridge.
• Welch Labs — the "how large language models work" line — mechanism-first, honest about limits.
• AI Explained — release-cycle analysis — measured same-week coverage of frontier drops; the calibrated alternative to launch-hype channels.
• Yannic Kilcher — paper deep-dives — for when a Foundation news item is a paper and the reader wants the hour version.
• Lab channels (OpenAI, Anthropic, Google DeepMind) — primary-source launch material, embedded as primary sources, framed by our own text (the feed's framing, not theirs).

Curation rule for this layer: mechanism over hype — a video earns embedding by explaining how something works, not by reacting to it. Sponsored-slot policy per the master plan: allowed in feed surfaces only, disclosed, never inside dossier or guide copy.