# NSA, DSA, CSA, And HCA Lineage Status: paper-backed comparison; first structured pass on 2026-07-19 This chapter answers a narrower question than the definition notes: > Which ideas in DeepSeek-V4 are inherited from DSA, which merely resemble > NSA, and what changes when the selectable memory unit becomes compressed? The short answer is: ```text NSA -> strong structural analogy coarse compressed + selected fine-grained + recent local information DSA -> direct sparse-selection lineage lightning indexer + top-k + shared-index MQA execution V4 -> changes the persistent memory unit before applying those ideas CSA selects compressed entries; HCA densely reads heavier compression ``` The primary sources are the [Native Sparse Attention paper](https://arxiv.org/html/2502.11089), the [DeepSeek-V3.2 report](https://huggingface.co/deepseek-ai/DeepSeek-V3.2/resolve/main/assets/paper.pdf), and the [DeepSeek-V4 report](https://arxiv.org/html/2606.19348v1). Detailed MLA mechanics are in the [MLA primer](./00-mla-primer.md), and the exact V4 compressor, cache, causality, and cost equations are in the [CSA/HCA definition](./01-csa-hca-definition.md). This chapter links to those results rather than repeating their full derivations. ## 1. Comparison Axes The mechanisms are easiest to separate along five independent axes: 1. **Persistent memory unit:** what must remain available after a token leaves the local window? 2. **Sparse unit:** does top-k select individual original tokens, contiguous original-token blocks, or learned compressed entries? 3. **Selection signal:** is routing derived from an existing attention branch or produced by a separate indexer? 4. **Information-path composition:** are coarse, selected, and local outputs combined by separate softmaxes and gates, or placed in one candidate set? 5. **Training contract:** is sparsity native from pretraining, introduced by dense-to-sparse continuation, or absent from that layer type? The resulting high-level map is: | Mechanism | Persistent long-range memory | Sparse unit | Selection signal | Output composition | | --- | --- | --- | --- | --- | | NSA | original fine K/V plus compressed K/V | contiguous blocks of original fine K/V | compressed-branch attention probabilities | three independent attentions, then learned gated sum | | DSA over MLA | every original token's MLA entry plus indexer key | original-token MLA entry | separate lightning indexer | one sparse main attention | | CSA | one main and one indexer entry per four original tokens | learned compressed entry | compressed lightning indexer | selected compressed and local entries share one attention | | HCA | one main entry per 128 original tokens | none; compressed history is read densely | none | dense compressed and local entries share one attention | This table already rules out two tempting but incorrect equivalences: - CSA is not NSA with a different compression ratio. - DSA is not a KV-cache eviction algorithm. ## 2. NSA: Three Parallel Information Paths NSA replaces one full-attention result with a gated sum of three independent attention branches. For query $q_t$, write $$ o_t =g_t^{cmp}o_t^{cmp} +g_t^{slc}o_t^{slc} +g_t^{win}o_t^{win}, $$ where each $g_t^c$ is produced by an MLP and sigmoid, and each branch computes its own attention over branch-specific keys and values. The three branches serve different roles: ```text compressed branch coarse global scan over learned block summaries selected branch exact fine-grained attention over selected old original-token blocks sliding branch exact fine-grained attention over recent original tokens ``` The paper deliberately gives the branches independent K/V projections. Local patterns otherwise learn quickly and can dominate optimization, allowing the model to ignore its coarse and selected long-range paths. ### 2.1 Compressed branch NSA maps each length-$l$ block, advancing by stride $d$, into a learned compressed key and value. The paper's experiment uses $$ l=32, \qquad d=16. $$ The overlapping layout therefore creates roughly $L/16$ compressed entries, not $L/32$. These entries participate directly in the compressed attention branch and provide a coarse global view. ### 2.2 Selected branch NSA partitions the original fine-grained K/V sequence into contiguous blocks of size $$ l'=64. $$ It does not introduce a separate neural indexer. Instead, it reuses the attention probabilities already computed against compressed keys and maps them to importance scores for the fine-grained selection blocks. Scores are summed across the query heads that share one GQA/MQA KV group so those heads select the same blocks and reuse the same KV fetches. The reported configuration selects $$ n=16 $$ blocks, including one always-active initial block and two local blocks. The selected branch consequently attends to up to $$ nl'=16\times64=1024 $$ original-token K/V entries. The important semantic point is that a compressed entry is a **routing and coarse-attention object** here. After routing, selected attention returns to the original fine K/V stored for those blocks. ### 2.3 Sliding branch and gated aggregation The experimental window is $$ w=512. $$ NSA evaluates compressed, selected, and sliding attention independently. Each branch therefore has its own logits, normalization denominator, values, and output. The learned gates combine three completed outputs; the candidates do not enter one shared softmax. This differs from CSA/HCA, where local and compressed entries are concatenated into one candidate set and compete in one core-attention normalization. ## 3. What “Natively Trainable” Means In NSA NSA is trained as the sparse architecture rather than applied after training to a full-attention checkpoint. In the paper's main experiment, the NSA and full-attention models are each pretrained to convergence on 270B tokens at 8K, then continued and supervised-fine-tuned at 32K. Its selection path avoids a separate indexer loss: ```text compressed attention logits -> compressed attention probabilities -> block-importance transformation -> top-n fine blocks -> selected fine-grained attention ``` Top-n itself is discrete, but the scores used for routing are not produced by an otherwise unused predictor: they belong to the compressed branch, which already receives language-model gradients through $o_t^{cmp}$. This is why NSA can avoid DSA's teacher-attention KL objective and indexer-only warm-up. This does **not** mean gradients differentiate through the top-n indices. It means that the score-producing representation has a direct differentiable role even without treating the discrete selection decision as differentiable. The paper also makes hardware alignment part of trainability: - select contiguous 64-token blocks rather than scattered individual tokens; - share selected block indices across heads in one GQA group; - load all group queries and reuse each selected KV block in SRAM; - implement forward and backward sparse kernels rather than falling back to a dense training operator. Thus “native” refers jointly to model optimization and executable sparse forward/backward, not only to using sparsity in the forward equation. ## 4. NSA Saves Reads And Compute, Not The Fine-KV Storage Order At decode, the paper models the history read for one query as $$ R_{NSA}(L) \approx \frac{L}{d}+nl'+w. $$ For its published parameters, $$ R_{NSA}(L) \approx \frac{L}{16}+1536 $$ in equivalent K/V entries. At $L=65{,}536$, this is $$ 4096+1024+512=5632, $$ matching the paper's decode traffic table. However, future queries may select any old fine-grained block. A faithful online implementation must therefore retain: $$ M_{NSA}(L) =O(L)\ \text{fine K/V} +O(L/16)\ \text{compressed K/V} +O(w)\ \text{local state}, $$ up to whether buffers can alias and how independent branch projections are stored. NSA reduces main-path history reads and active attention arithmetic, but it does not by itself make all old fine K/V disposable. This is the decisive storage difference from CSA/HCA. ## 5. DSA: A Learned Index In Front Of MLA DSA keeps MLA's one-entry-per-original-token main memory and adds a lightweight indexer. For query token $t$ and source token $s$, the V3.2 report defines $$ I_{t,s} =\sum_{j=1}^{H^I} w^I_{t,j}\, \operatorname{ReLU} \left((q^I_{t,j})^T k^I_s\right). $$ The query-side vectors and weights depend on the current hidden state, while $k_s^I$ is a separately cached indexer key for every historical token. The top-k index scores choose which MLA cache entries enter core attention. The split is therefore literal: ```text lightning indexer cheaply score every original token position top-k emit original-token indices main MLA attention in MQA mode gather and attend to only those token-indexed latent entries ``` DeepSeek-V3.2 uses $k=2048$. To make sparse KV fetches reusable, the selected set is shared across all main query heads and MLA executes in its MQA algebraic form. This is a kernel contract, not a claim that MLA and MQA have identical parameters. DSA consequently has three different cost statements: $$ M_{DSA}(L)=O(L) $$ for persistent main and indexer state, $$ R_{DSA}(L)=O(L)\ \text{small-index scan}+O(k)\ \text{main reads}, $$ and, across all prefill/training queries, $$ C_{DSA}(L)=O(L^2)\ \text{small indexer}+O(Lk)\ \text{main attention}. $$ The indexer preserves quadratic asymptotic work when its dimension and $k$ are treated as constants, but replaces the much wider dense main-attention term with a narrow scan plus top-k main attention. ### 5.1 DSA does not solve the resident-cache dimension MLA compresses the feature width stored for each token, but DSA neither removes old tokens nor shares their memory across layers. It also adds one indexer key for every token in every attention layer. The persistent-state shape is more explicitly written as $$ M_{DSA\text{-}MLA} =O\left( LN_{layer} \left(d_{latent}+d_{rope}+d_{index}\right) \right). $$ DeepSeek-V3.2 publishes $$ N_{layer}=61, \qquad d_{latent}=512, \qquad d_{rope}=64, \qquad d_{index}=128. $$ Its reference implementation states that the latent MLA cache uses FP8 in deployment and stores the 128-dimensional indexer key in FP8. If the RoPE key is estimated in BF16, the payload before block-scale and allocator metadata is approximately $$ 512\ \mathrm{B} +64\times2\ \mathrm{B} +128\ \mathrm{B} =768\ \mathrm{B/layer/token}. $$ Across 61 layers this is about 45.75 KiB per token, or 5.72 GiB for one 128K sequence. This is an illustrative aggregate model-state estimate: tensor parallel placement, scale formats, paging, padding, and engine-specific cache layouts change the physical per-device allocation. The reference demo also simulates the deployed FP8 latent precision rather than serving as an exact allocator model. For scale, a hypothetical 61-layer BF16 GQA model with eight KV heads and 128-dimensional K/V heads stores $$ 2\times8\times128\times2 =4096\ \mathrm{B/layer/token}, $$ or about 30.5 GiB for one 128K sequence. DSA-MLA is still much smaller than that GQA example, but it can exceed a pure BF16 MQA cache because the 512-wide latent, RoPE state, and index key together are wider than one K/V head pair. The comparison is dimensional rather than a claim of equal model quality or equal cache dtype. The resulting trade-off is: ```text relative to MHA or ordinary GQA MLA gives a large per-token feature-width saving relative to YOCO, CSA/HCA, or bounded-window hybrids DSA still pays full context x full depth residency DSA itself saves expensive main-cache reads and attention compute but adds an index cache and does not save main-cache storage ``` Sources: the [DeepSeek-V3.2 configuration](https://huggingface.co/deepseek-ai/DeepSeek-V3.2/blob/main/config.json) and its [reference inference implementation](https://huggingface.co/deepseek-ai/DeepSeek-V3.2/blob/main/inference/model.py). ## 6. DSA's Two-Stage Training Contract DeepSeek-V3.2 introduces DSA by continued training from a dense 128K DeepSeek-V3.1-Terminus checkpoint. ### 6.1 Dense indexer warm-up For 1000 steps, the model keeps dense main attention and freezes all existing model parameters. Only the lightning indexer is trained. For query $t$, the report sums main-attention weights across heads and L1-normalizes them along the source sequence to obtain teacher distribution $p_{t,:}$. The indexer minimizes $$ \mathcal L_I =\sum_t D_{KL}\left( p_{t,:} \;\|\; \operatorname{Softmax}(I_{t,:}) \right). $$ This warm-up covers 2.1B tokens. ### 6.2 Sparse adaptation DSA then enables top-2048 sparse main attention and trains the main model and indexer for 15,000 steps, covering 943.7B tokens. The indexer remains aligned to main attention, now over the selected set $S_t$: $$ \mathcal L_I =\sum_t D_{KL}\left( p_{t,S_t} \;\|\; \operatorname{Softmax}(I_{t,S_t}) \right). $$ The report explicitly detaches the indexer input. The indexer receives only $\mathcal L_I$; the main model receives only the language-modeling loss. This separation prevents the auxiliary routing objective from directly reshaping the backbone hidden state through the indexer input path. ### 6.3 What supports making every MLA layer sparse Standard softmax attention is not mathematically sparse: every unmasked position normally receives a positive weight. The relevant empirical property is **effective sparsity** or attention-mass concentration: a small, query-dependent subset can dominate the weighted sum. Earlier work such as [SparQ Attention](https://arxiv.org/abs/2312.04985) explicitly analyzes this score concentration, while [Quest](https://proceedings.mlr.press/v235/tang24l.html) emphasizes that the critical subset changes with the query. The V3.2 report does not provide a broad sparse-attention literature review and does not cite those two papers. Its direct NSA citation in the DSA section is used for the kernel requirement that selected KV be shared across several queries. DeepSeek instead operationalizes the effective-sparsity hypothesis: ```text dense MLA attention -> aggregate its distribution across heads -> train a lightweight indexer to imitate that teacher -> enable top-2048 in every attention layer -> adapt the full model for 943.7B tokens -> compare the resulting model with the dense predecessor ``` Several properties make full-stack sparsity less restrictive than one fixed 2048-token window: - all historical MLA and index entries remain resident and globally addressable; - every layer has its own indexer and hidden state, so different layers and query positions can select different sets; - selected higher-layer states are contextual representations, not isolated raw tokens; - the residual stream retains information already retrieved by lower layers; - the model is extensively trained under the sparse constraint rather than being sparsified only at serving time. There is also a system reason not to retain an occasional dense MLA layer. At 128K and $k=2048$, $$ \frac{L}{k}=64. $$ Ignoring indexer and kernel constants, one dense layer performs roughly as many main-attention token interactions as 64 sparse layers. Since V3.2 has 61 attention layers, even one retained dense layer could approximately double the full stack's main-attention work. This arithmetic is an inference from the published dimensions, not an explicit argument in the report. The published justification remains empirical rather than complete. V3.2 reports broad and long-context parity after sparse adaptation, but does not publish: - cumulative dense-attention mass retained by top-2048 by layer and head; - a sweep over 512, 1024, 2048, and 4096 selected tokens; - a direct all-DSA versus hybrid dense/DSA layer ablation; - indexer-miss analysis for rare evidence and specialist heads. Thus the evidence supports “full DSA is workable after large-scale adaptation,” not a theorem that global information is preserved without loss. This training contract is fundamentally different from NSA: | Question | NSA | DSA | | --- | --- | --- | | Separate score network? | no; reuse compressed-attention probabilities | yes; lightning indexer | | Separate routing loss? | no | KL to aggregated main attention | | Dense teacher phase? | no in the main experiment | yes, indexer-only warm-up | | Main model introduction | sparse architecture trained from the start | dense checkpoint adapted to sparse attention | | Selected object | contiguous original-token blocks | individual original-token MLA entries | ## 7. Direct DSA To CSA Inheritance The V4 report explicitly says that CSA compresses its KV cache and then applies DSA. This is direct lineage, not an interpretation based only on visual similarity. The inherited operational skeleton is: ```text small index representation -> multi-head weighted ReLU scoring -> one score per candidate memory entry -> top-k -> selected shared-index MQA core attention ``` V4 also retains the dense-to-sparse training shape: DeepSeek-V4-Flash first uses dense attention for 1T tokens, introduces sparsity at the 64K training stage, briefly warms up the CSA lightning indexer, and then trains sparsely for most of the remaining run. V4-Pro uses a longer dense stage but the same two-stage sparsity introduction strategy. The V4 paper does **not** publish enough detail to assert that the following DSA choices are unchanged: - the exact teacher distribution; - full-range versus selected-range KL; - whether the indexer input is detached; - warm-up step/token count and learning rate; - relative weighting of indexer and language-model losses. It is reasonable to use DSA as the hypothesis generator for these questions, but not to copy its precise training recipe into V4 as fact. ## 8. What CSA Changes Relative To DSA CSA moves compression **before** both the indexer and main attention: ```text DSA L original-token MLA entries -> index L entries -> attend top-k original-token entries CSA L original hidden states -> about L/4 learned compressed entries -> index about L/4 compressed entries -> attend top-k compressed entries + 128 local entries ``` This changes more than a constant in the same operator: | Property | DSA over MLA | CSA | | --- | --- | --- | | Persistent main unit | per-token MLA latent plus RoPE state | one 512-d shared-KV memory entry per four tokens | | Indexer unit | per original token | per compressed entry | | Selected unit | original-token latent | learned compressed entry | | Return to old fine KV | yes | no | | Local path | selected main memory includes token detail | explicit 128-token SWA candidates | | Value representation | MLA latent transformed through absorbed projections | selected entry directly serves as shared K=V | | Main normalization | sparse main entries | compressed and local candidates share one softmax | | Flash / Pro top-k | 2048 in V3.2 | 512 / 1024 | CSA therefore shortens the index scan, main persistent cache, and compressor output sequence together. Once a compression group is complete and leaves the local window, its original main entry need not remain selectable. For decode, the idealized entry counts become $$ M_{CSA}(L)=O(L/4)+O(w), $$ $$ R_{CSA}(L)=O(L/4)\ \text{index scan}+O(k+w)\ \text{main reads}. $$ This is why CSA improves the cache **store**, index **read**, and main attention **compute**, whereas DSA primarily improves main reads and compute. ## 9. HCA Is The Dense Complement, Not Another DSA Variant HCA uses the same learned sequence-compression family and shared-KV core attention, but removes the lightning indexer and top-k. It compresses by 128 and reads the resulting global memory densely: $$ M_{HCA}(L)=O(L/128)+O(w), $$ $$ R_{HCA}(L)=O(L/128+w). $$ At one million original tokens, the compressed global sequence is only about 8192 entries, so a regular dense compressed-attention kernel can be preferable to paying index scan, top-k, and irregular gather overhead. The CSA/HCA pair separates two operating points: ```text CSA moderate compression preserves more global detail sparse selection bounds expensive 512-d main attention HCA heavy compression makes the global sequence short enough to scan densely no selector, gather, or selector-training contract ``` Interleaving these layers lets V4 retain both content-selected moderately compressed memory and cheap always-visible coarse global memory. ## 10. NSA To V4: Strong Analogy, Different Operator NSA and V4 share a design principle: > Long-context attention needs both coarse global coverage and local or > selectively recovered detail. But they instantiate it differently. ### 10.1 NSA combines scales inside every layer ```text compressed coarse attention + selected original-token attention + sliding original-token attention -> learned gated sum of three branch outputs ``` ### 10.2 V4 combines scales inside and across layers ```text CSA layer selected moderately compressed entries + local entries -> one shared softmax HCA layer dense heavily compressed entries + local entries -> one shared softmax Transformer stack interleave CSA and HCA roles across depth ``` The sharpest differences are: - NSA uses compressed attention scores to route back to old original-token K/V; CSA selects the compressed entries themselves. - NSA retains independent K/V and normalization for three branches; V4 uses one shared K=V candidate type and one local-plus-global normalization inside each CSA/HCA layer. - NSA keeps fine global history selectable, so persistent storage remains $O(L)$; V4 discards old fine main history after compression, reducing the sequence dimension of persistent storage. - NSA's compression and selected paths coexist in one layer; V4 distributes moderate-sparse and heavy-dense global roles across alternating layers. - NSA avoids a separate learned selector; CSA directly inherits DSA's lightning-indexer family. Calling CSA “NSA plus DSA” is therefore useful only as intuition. It is not a faithful operator identity. ## 11. Store, Read, And Compute Summary Let $L$ be original context length, $k$ a selected-entry count, and $w$ a local window. Ignoring feature dimensions and constant state: | Mechanism | Persistent history | Decode history read | All-query main/index work | | --- | --- | --- | --- | | NSA | $O(L)$ fine + $O(L/16)$ compressed | $O(L/16+1024+512)$ | $O(L^2/16)+O(L(1024+512))$ | | DSA | $O(L)$ MLA + $O(L)$ index | $O(L)$ index + $O(k)$ main | $O(L^2)$ narrow index + $O(Lk)$ main | | CSA | $O(L/4)$ main/index + $O(w)$ | $O(L/4)$ index + $O(k+w)$ main | $O(L^2/4)$ narrow index + $O(L(k+w))$ main | | HCA | $O(L/128)+O(w)$ | $O(L/128+w)$ | $O(L^2/128)+O(Lw)$ | These fixed-ratio mechanisms remain quadratic in long-sequence training if compression ratios are treated as constants. Their practical gains come from large coefficient reductions, smaller/wider operand separation, bounded selected main attention, and hardware-aligned execution. Decode storage and traffic show more important qualitative differences than the shared big-$O(L^2)$ label reveals. Feature dimensions also matter: - DSA's $O(L)$ index scan is only useful because it is much narrower than MLA main attention. - CSA scans only $L/4$ index entries, but its selected main entries are wide 512-dimensional shared K=V objects. - HCA avoids the selector but may still become compute-bound when batch or MTP verification width reuses its compressed history enough. - NSA's selected 64-token blocks improve contiguous loads and Tensor Core utilization but fetch more fine tokens per routing decision. ## 12. Training-Signal Lineage The training comparison is compact enough to summarize as a flow: ```text NSA language-model loss -> compressed attention branch -> its probabilities also induce fine-block routing no separately supervised indexer DSA dense main attention -> head-aggregated teacher distribution -> KL trains detached lightning-indexer path -> top-k sparse main attention language-model loss trains main model CSA report confirms dense phase -> short indexer warm-up -> sparse phase exact DSA-style teacher/loss/detach details are not published HCA no discrete selector or selector auxiliary loss compressor and dense compressed attention learn from model loss ``` This distinction will matter in the training-systems chapter. DSA/CSA require an indexer lifecycle and potentially distinct optimizer/loss plumbing. NSA requires three-branch activations and sparse block backward. HCA removes selection backward but still differentiates through long overlapping compression windows. ## 13. Kernel Lineage And Hardware Consequences NSA establishes several hardware rules that remain relevant to later designs: - selection must respect KV sharing across GQA/MQA query heads; - contiguous selected blocks are easier to fetch and multiply than arbitrary per-head token unions; - sparse forward alone is insufficient for native long-context training; - decode optimization targets bytes, while prefill/training optimization targets wide Tensor Core work and backward. DSA changes the selected granularity to individual MLA entries, but preserves one shared index set so a gathered latent can be reused by many query heads. CSA inherits that shared-index MQA pattern after shortening the indexed sequence. V4 additionally needs kernels for compression-state updates, heterogeneous cache pages, concatenated local/global candidates, partial and inverse RoPE, and deterministic sparse backward. The lineage is therefore not only mathematical: ```text NSA hardware lesson share routing across KV-sharing heads and organize sparse work for reuse DSA concrete mechanism lightning indexer + shared token indices + sparse MQA over MLA CSA adaptation lightning indexer + shared compressed-entry indices + wide shared-KV MQA ``` ## 14. Common Misreadings - **“NSA deletes old fine KV after compression.”** No. Its selected branch can recover old original-token blocks, so those fine K/V remain part of the long-range memory contract. - **“DSA compresses KV cache along sequence.”** No. MLA compresses each token's feature representation; DSA still preserves one selectable main entry per original token. - **“NSA and DSA use the same selector.”** No. NSA derives selection from its compressed-attention branch; DSA learns a separate lightning indexer. - **“CSA top-k returns to original token KV.”** No. It attends to learned compressed entries directly. - **“HCA is sparse attention.”** Its sequence is compressed, but attention over the completed compressed global entries is dense. - **“All branches in NSA or V4 share one softmax.”** NSA uses independent branch attentions followed by gates; CSA/HCA concatenate local and compressed candidates into one core attention. - **“V4 published the complete CSA indexer loss.”** It published the two-stage schedule and direct DSA relationship, but not enough detail to establish the exact DSA KL/detach recipe. - **“Lower asymptotic-looking token count guarantees latency.”** Top-k, gathers, compressor updates, kernel launch shape, batch, and MTP width can move the bottleneck. ## 15. Established Conclusions And Open Questions ### Established - NSA is a three-branch architecture with compressed, selected-original, and local attention, followed by learned gated aggregation. - NSA's compressed attention probabilities provide its block-selection importance signal; it does not use DSA's lightning indexer. - DSA stores and indexes one MLA entry per original token and trains its separate indexer with a dense warm-up followed by sparse adaptation. - CSA directly inherits DSA-style indexing but applies it to a sequence already compressed by four. - HCA is a dense-attention operating point over 128x compressed memory. - NSA and DSA save main-attention reads and compute without removing the $O(L)$ fine/token-indexed persistent history required by future retrieval. - CSA/HCA change the long-term persistent memory unit, so they reduce storage, reads, and main attention together. ### Open for implementation/training study - Does the internal V4 training stack use the exact DSA KL target and detached indexer input, or a revised objective for compressed candidates? - During CSA dense warm-up, is “dense” attention over all completed compressed entries plus local state, and how is its teacher distribution aggregated? - How are top-k ties, packed-sample boundaries, and deterministic selected-KV gradient accumulation handled in the training code? - Which NSA lessons remain useful for CSA block granularity despite CSA's compressed-entry rather than original-block selection? - At what context, batch, and MTP width does HCA's regular dense compressed kernel beat CSA's smaller selected set after index and gather overhead? These questions route naturally into `03-training-systems.md` and `04-inference-systems.md`; they should not be silently resolved from the architectural analogy alone.