Methodology

Every record is extracted from a single technical report and validated against a machine-readable schema (data/schema.json, mirror of schema.md). Every field carries a provenance tag: stated (explicit in the report), derived (computed — computation recorded), inferred (judgement — evidence recorded), unknown (report silent — rendered as not disclosed), or n/a (mechanism makes the field inapplicable). Numbers are never imported from other reports, memory, or the web into a record.

Records

Skill version: v0.4.0. Atlas generated 2026-08-11.

Download combined data (atlas.json)

Extraction schema

Extraction Schema

The single authority on what a record contains. data/schema.json (created in Prompt B) is the machine-readable mirror of this file and must stay in sync with it — regenerate whenever this changes, and log the change in changelog.md.

Record form

One file per architecture: data/architectures/<slug>.json. slug = lowercase kebab-case, <org>-<model> (e.g. meta-llama-3.1).

Every leaf field is an object:

{"value": <value|null>, "provenance": "stated|derived|inferred|unknown|n/a", "ref": "§2.1 / Table 3", "note": "computation (derived) or evidence (inferred)"}

• unknown → value: null. Renders as not disclosed — never as a blank and never as zero.
• n/a → value: null, provenance: "n/a", with ref. Distinct from unknown: the field does not apply to this mechanism. (Numeric-typed leaves accept null, so n/a is always expressible.)
• ref required for stated and n/a; note required for derived and inferred.
• Arrays and objects carry the same tagging on every leaf; container-level tags are not allowed.
• Precision requirement: two independent analyses of the same report must produce identical values. When in doubt, the tag is unknown.

1. Record meta (pipeline bookkeeping, not report content)

2. Identity

3. Scale (reference variant = the report's flagship)

Per-variant configs go in scale.variants[]; the top-level scale fields always describe the reference variant — the variant the report leads with as its flagship (title/abstract framing decides; e.g. phi-3-mini leads "Phi-3: ... Locally on Your Phone", so mini is the reference even though medium is larger). If the report leads with no single variant, the reference is the largest disclosed. If the report covers one size only, variants is [].

4. Core block design

5. Context

6. Tokenizer

7. Training

8. Post-training

9. Modality

10. Inference efficiency

11. Evaluation

12. Author-claimed contributions

13. Taxonomy (one value per axis; each with provenance)

14. Prose (authored narrative, per record)

Authored analysis for the model page — not report facts. Every leaf is tagged inferred with note "authored by atlas analyst", and the prose text itself honours non-negotiable 2 (keeps stated / inferred distinctions explicit inside the narrative). Authored at ingestion time; influence_out is the one field written retroactively (when a descendant arrives).

Taxonomy

Taxonomy

Classification is multi-axis: a model gets exactly one value per axis, never one bucket. For every axis: possible values, decision rule, anchor example. If a report genuinely fits no value, that is a signal to evolve the taxonomy (changelog procedure + backfill), not to force a fit.

Format contract (machine-parsed): build.py parses this file — the axis key comes from the ## Axis N — name heading, the values/rules/anchors from the first table in each section. Keep this structure; extend tables, don't restyle them.

Axis 1 — compute_structure

What the parameter footprint looks like per token.

Rule: count routed-FFN vs dense-FFN layers across the whole model; majority with ≥80% share wins, otherwise hybrid. The per-layer record lives in block.block_type / block.attention_layer_pattern.

Axis 2 — sequence_mixing

How the model mixes information across sequence positions.

Rule: same ≥80% majority rule over layers; deliberate alternation that falls below the threshold is hybrid (record the pattern in block.attention_layer_pattern).

Axis 3 — modality

Axis 4 — openness

What the organisation actually releases, per the report.

Note: undisclosed exists so report silence never forces a guess. World knowledge does not override a silent report (non-negotiable 3).

Axis 5 — scale_class

By total parameters of the reference variant (largest disclosed).

Axis 6 — design_intent

What the report frames the model for. Inferred from the report's own framing (abstract, intro, evaluation emphasis) — never from marketing outside the report.

Rule: if several intents appear, take the one the report leads with; note the others in contributions.assessment or prose. If the report leads with none of these, evolve the axis.

Comparison methodology

Methodology — comparison and normalisation conventions

Rules that keep cross-model comparisons honest.

1. MoE vs dense — always both totals

Never compare total parameters of an MoE model against a dense model without also showing active parameters. Always present both (scale.total_params and scale.active_params_per_token); comparison views show the pair side by side.

2. Unit normalisation

Normalise before comparing:

• Token counts in T (trillions).
• Parameter counts in B (billions).
• Context lengths in tokens.
• Dates as ISO-8601 (YYYY-MM-DD).

Report values are stored as printed (verbatim digits); derived values are rounded to one decimal place. The stored value is never rounded; rounding happens only in rendered views.

3. Compare designs, not marketing

A comparison row must be a schema field, so every cell has provenance. Prose comparison is allowed only after the full schema is extracted (non-negotiable 1). Cells show provenance on hover; unknown renders as "not disclosed" — never as blank, never as zero.

4. Absence of disclosure is information

When a report omits a field that peers disclose, the comparison shows "not disclosed" and the omission is noted in prose ("the report does not disclose its data mixture"). Silence is a finding, not a gap to fill.

5. Benchmarks are never compared head-to-head across reports

Different harnesses, prompts, and contamination levels make cross-report numbers incomparable. The atlas records which benchmarks each report chose to emphasise and that report's own numbers only. At most, note the choice pattern (e.g. "this report leads with reasoning benchmarks, unlike X"). Same-report, same-harness comparisons (e.g. variant sizes within one report) are fine.

6. Lineage

Record which prior architectures a design borrows from — with the specific borrowed mechanism named (e.g. "MLA from DeepSeek-V2") — only when the report states it or the mechanism is unambiguous (mechanism + origin both identifiable). Lineage in → the new record's prose. Influence out → update older records' "influence" sections when a descendant arrives.

7. Reference variant

One record per family. Scale fields describe the largest disclosed variant; per-variant configs live in scale.variants[]. Comparisons use the reference variant unless a variant-level comparison is explicitly requested. If a report covers a single size, variants is empty.

8. Backfill discipline

When the schema or taxonomy evolves, every existing record is re-read from its stored source and the new field filled (unknown where silent) in the same change — no field may exist for some models only because of ingestion order. The changelog entry for the change lists every backfilled record.

9. Secondary sources

Secondary sources (other reports, model cards, config files, web) are labelled as such in prose and never fill schema fields (non-negotiable 3). They may be cited in contributions.assessment or prose as context, explicitly marked.

10. Closest relatives

"Closest relatives in the atlas" is computed mechanically from shared schema values: count matching non-unknown, non-n/a values across the fixed comparable field set — block.block_type, block.attention_variant, block.position_encoding.method, block.normalization.type, block.activation, modality.type, taxonomy.openness, taxonomy.scale_class, taxonomy.sequence_mixing. Tie-break by absolute difference in context.trained_length, then by scale.total_params. The field set and rule are recorded here so the computation is reproducible and versioned with the skill.

11. Numbers

All numbers on a model page come from that model's record. The report's own digits are stored as printed; derived values show their computation in the provenance note.

Glossary

Glossary — terminology map

Reports name the same mechanism differently. Add a new alias here BEFORE filling the schema. Format: alias → canonical schema term (path), note if needed. Canonical terms are defined in schema.md.

Attention

• MQA, multi-query attention, shared KV heads → block.attention_variant: MQA (one KV head shared by all query heads)
• GQA, grouped-query attention, grouped KV heads → block.attention_variant: GQA (a few KV heads shared per query group)
• MLA, multi-head latent attention, low-rank KV compression, latent KV cache → block.attention_variant: MLA (KV compressed into a low-rank latent; attention_heads_kv is n/a)
• sliding window attention, SWA, local attention → block.attention_variant: sliding-window
• blocksparse attention, block-sparse attention → block.attention_layer_pattern (efficient-attention pattern: per-head sparsity patterns over the KV cache; phi-3-small alternates blocksparse and dense attention layers)
• flash attention → not a variant; an implementation detail (prose only)
• KV cache compression, KV sharing → efficiency.kv_cache
• KDA, Kimi Delta Attention, delta-rule attention, delta rule recurrence → block.attention_variant: linear/state-space (recurrent delta-rule linear attention; chunkwise-parallel; in hybrid patterns record the mix in attention_layer_pattern)
• Gated MLA, gated multi-head latent attention → block.attention_variant: MLA (MLA with an input-dependent full-rank output gate)
• Attention Residuals, AttnRes, attention over layers, layer-wise attention → block.depth_mixing: attention-residuals (per-layer learned attention over prior layer outputs; Block variant: attention over summed block representations)

Mixture of experts

• MoE, mixture-of-experts, sparse expert model, routed FFN, SMoE, sparse mixture of experts → block.block_type: sparse-MoE / moe fields
• top-k routing, expert routing, router, router network, gating network, gating vector → block.moe.routing
• sparse parameter count → scale.total_params
• active parameter count → scale.active_params_per_token
• auxiliary loss, aux loss, load balancing loss, balancing loss → block.moe.load_balancing
• shared expert, always-on expert → block.moe.shared_experts
• activated parameters, active parameters, per-token parameters → scale.active_params_per_token
• fine-grained experts, expert splitting → block.moe.expert_granularity
• LatentMoE, latent experts, routed experts in a compact latent space → block.moe.expert_granularity (routed experts operate at reduced width; shared experts keep full width)
• Quantile Balancing, QB, quantile-based bias update → block.moe.load_balancing (auxiliary-loss-free bias set from the router-score margin quantile matching target load)
• auxiliary-loss-free load balancing, bias-based balancing, bias update speed, sequence-wise balance loss, aux loss → block.moe.load_balancing
• node-limited routing, device-limited routing, restricted routing → block.moe.routing (routing constraint limiting tokens to ≤M nodes)
• redundant expert, expert duplication, dynamic redundancy → efficiency.serving
• SparseMixer, sparse backpropagation → block.moe.routing (MoE router training via sparse backpropagation [LGC23, LDL+23])
• Jamba block → block.block_type: hybrid (report's name for the repeated unit of attention/Mamba layers + MLP/MoE)
• attention-to-Mamba ratio, a:m ratio, ratio of attention-to-Mamba layers → block.attention_layer_pattern

Positional encoding

• RoPE, rotary, rotary position embeddings, rotary embeddings → block.position_encoding.method: RoPE; rope_base for the base frequency
• ALiBi, attention with linear biases → block.position_encoding.method: ALiBi
• NoPE, no positional encoding → block.position_encoding.method: NoPE
• no positional information, no explicit positional encoding, without explicit positional information → block.position_encoding.method: NoPE (report states positional embeddings/RoPE are not necessary)
• YaRN, YaRN-NTK, YaRN scaling → block.position_encoding.extension.method: YaRN
• NTK-aware scaling, NTK scaling, dynamic NTK → block.position_encoding.extension.method: NTK
• linear scaling, position interpolation, PI → block.position_encoding.extension.method: PI
• LongRope, long-rope, LongRoPE, long rope → block.position_encoding.extension.method: other (RoPE-frequency-rescaling context extension; 4K to 128K)
• context window, context length, sequence length, max sequence length → context.*

Normalisation and activation

• RMSNorm → block.normalization.type: RMSNorm
• LayerNorm, LN → block.normalization.type: LayerNorm
• pre-norm, pre-LN, PreNorm → block.normalization.placement: pre
• post-norm, post-LN → block.normalization.placement: post
• QK-norm, query-key normalisation, QK layernorm → block.normalization.qk_norm
• SwiGLU, GLU, SiLU-gated linear unit, gated activation → block.activation: SwiGLU
• SiTU-GLU, sigmoid tanh unit GLU, tanh-softcapped GLU → block.activation (record exactly as stated; bounded SwiGLU variant with β·tanh soft-caps)
• GEGLU → block.activation: GEGLU (gated linear unit with GELU nonlinearity)
• softcapping, logit capping, logit softcap, attention logit capping → block.stability.softcapping
• attention sink, sink token, streaming attention sink → block.stability.attention_sinks (designed sinks only)

Training and precision

• bfloat16, BF16, bf16 mixed precision → training.precision: BF16
• FP8, FP8 mixed precision, 8-bit training → training.precision: FP8
• AdamW, Adam → training.optimizer (record exactly as stated)
• annealing, data annealing, cooldown, stage 2 → training.curriculum
• tokens seen, training tokens, corpus size → training.tokens
• expert parallelism, EP → training.parallelism
• pipeline parallelism, PP → training.parallelism
• tensor parallelism, TP → training.parallelism
• context parallelism, CP → training.parallelism
• sequence parallelism → training.parallelism
• FSDP, fully sharded data parallel → training.parallelism
• DualPipe, bidirectional pipeline scheduling, computation-communication overlap → training.parallelism
• E4M3, E5M2, E5M6, fine-grained quantization, tile-wise quantization, block-wise quantization, online quantization → training.precision
• FIM, fill-in-the-middle, Prefix-Suffix-Middle, PSM, document packing → training.data_composition
• Maximal Update Parametrization, muP, µP → training methodology (zero-shot hyperparameter transfer from a small proxy model; prose — no dedicated field)
• data optimal regime, data-optimal regime → training.data_composition (data-quality-focused training regime at a fixed model scale, as opposed to compute-optimal scaling)

Post-training

• RLHF, PPO, reinforcement learning from human feedback → post_training.preference_optimization: RLHF
• DPO, direct preference optimisation → post_training.preference_optimization: DPO
• GRPO, group relative policy optimisation → post_training.preference_optimization: GRPO
• RLAIF, RL from AI feedback → post_training.preference_optimization: other (note)
• chain-of-thought, CoT, reasoning traces, thinking tokens, thinking mode → post_training.reasoning_training
• test-time compute, self-consistency, best-of-n → post_training.reasoning_training
• RLVR, RL with verifiable rewards → post_training.reasoning_training
• distillation, KD, knowledge distillation, teacher model → post_training.distillation
• MOPD, multi-teacher on-policy distillation, on-policy distillation, OPD → post_training.distillation
• generative reward model, GRM, agentic reward model → post_training.preference_optimization (note the reward structure; e.g. tournament-style group reward with binary comparisons)
• rejection sampling (used to curate SFT data) → post_training.sft

Inference

• speculative decoding, speculative sampling, self-speculative, draft model → efficiency.speculative_dedup
• EAGLE, EAGLE-3, MTP draft, draft from MTP layer → efficiency.speculative_dedup
• MTP, multi-token prediction, multi-token forecasting → efficiency.speculative_dedup (and training objective → prose)
• quantisation, quantization, INT4, INT8, W8A8, AWQ, GPTQ, MXFP4, MXFP8, MXFP4 QAT → efficiency.quantization (record shipped formats as stated)
• KV cache, key-value cache → efficiency.kv_cache
• IBGDA, GPUDirect Async → efficiency.serving
• mixed context window approach → context.extension_method (used with long-rope for the phi-3.5 series' 4K to 128K mid-training)

Attention (2026-08-10 batch — gallery ingestion)

• DSA, DeepSeek Sparse Attention, lightning indexer, fine-grained token selection, keep routing, keep sampling mask → block.attention_variant / attention_layer_pattern (content-based top-k sparse attention over the KV cache; DSA appears as the sparse stage inside CSA)
• CSA, compressed sparse attention, HCA, heavy compression attention → block.attention_layer_pattern (KV compressed every m tokens then sparsely/densely attended; DeepSeek V4)
• CCA, CCGQA, compressed convolutional attention → block.attention_variant: hybrid (attention in a compressed latent space with short conv + grouped head-wise conv preconditioners and GQA-style KV sharing; Zyphra ZAYA1)
• banded-window attention, off-by-one attention, learned softmax-denominator bias → block.attention_layer_pattern / block.stability.other (GPT-OSS: window/dense alternation and per-head softmax-denominator bias)
• mHC, manifold-constrained hyper-connections, Hyper-Connections, connection matrix → block.depth_mixing: hyper-connections (learned connection matrix over the residual stream; doubly-stochastic constraint in DeepSeek V4)
• sliding-window, SWA, local attention → block.attention_variant: sliding-window (alias for the gallery batch)
• attention sink bias → block.stability.attention_sinks (learnable sink in the softmax denominator; gpt-oss lineage)

Mixture of experts (2026-08-10 batch)

• SMEBU, sequence auxiliary loss → block.moe.load_balancing (sequence-level expert-balancing loss; Arcee Trinity)
• zero-experts, dynamic activation, sparsity scaling → block.moe (experts that can be skipped per token, making active params input-dependent; LongCat-Flash-Lite)
• n-gram embedding, over-encoding, N-gram Cache, embedding amplification → scale.total_params / prose (hashed n-gram lookup tables as a parameter block outside the FFN; LongCat-Flash-Lite)
• LatentMoE → block.moe.expert_granularity (routed experts in a compact latent space; Nemotron 3 Super, Kimi K3's Stable LatentMoE)
• Sqrt(Softplus) affinity, hash routing, expert bias, post-top-k score normalization → block.moe.routing (router variants as stated)
• GenRM, group relative length control → post_training.preference_optimization (reward-model/RM structures in RLHF; Nemotron 3)

Post-training (2026-08-10 batch)

• OlmoRL, active sampling, token-level loss, clip-higher, truncated importance sampling → post_training.reasoning_training (GRPO + DAPO/Dr.GRPO-style RLVR algorithm; OLMo 3)
• CISPO, clipped importance sampling policy optimization → post_training.preference_optimization: other (MiniMax M2, Laguna)
• MGPO, max-entropy guided policy optimization → post_training.preference_optimization: other (GRPO variant with max-entropy prompt weighting; VibeThinker)
• pivotal token search, PTS → post_training.preference_optimization (DPO-pair construction from pivotal tokens; Phi-4)
• midtraining, mid-training, continued pretraining stage → training.curriculum (stage between pretraining and post-training)
• MOPD → post_training.distillation (already listed; also used by Upstage Solar Open 2 and cited by Kimi K3)
• Long2Short RL, length-reward redistribution, offline self-distillation → post_training.reasoning_training (VibeThinker)
• Looped Transformer, layer reuse, two-pass stack reuse → block.depth_mixing / prose (same stack processed twice; Nanbeige 4.2)

Training (2026-08-10 batch)

• Muon, MuonClip, QK-Clip, hybrid Newton-Schulz, WSD → training.optimizer / block.normalization.qk_norm (Muon optimizer family; MuonClip is per-head weight clipping — NOT QK-norm; WSD = warmup-stable-decay LR)
• checkpoint souping, model souping → training.curriculum
• micro-annealing, microanneal → training.curriculum (cheap data-source ablations via short anneal runs)

Misc (2026-08-10 batch)

• o200k_harmony → scale.vocab_size / tokenizer.algorithm (GPT-OSS tokenizer name)
• cl100k-derived → tokenizer.algorithm (OLMo 2/3 tokenizer lineage)
• MM Claw → prose only (internal multimodal benchmark; not a modality pipeline — MiniMax M2)

2026-08-10 batch 2 — found-report ingestion

• Lightning Attention → block.attention_variant: linear/state-space (transpose-free linear attention; TransNormerLLM lineage; Ling 2.6)
• TransMLA → block.attention_variant: MLA (transplanting GQA checkpoints to MLA via QK-norm absorption + partial-RoPE decoupling; Ling 2.6)
• GDN, gated delta net, Hybrid-Attention MoE → block.attention_variant: linear/state-space (delta-rule gated linear attention inside a hybrid MoE; Qwen3.5)
• pp-RoPE → block.position_encoding.partial_rope (partial-rotary RoPE, p=0.25 on global layers; Gemma 4)
• keys-as-values reuse, values=keys → block.stability.other (global-attention layer reuse of keys as values; Gemma 4)
• KV cache sharing, cross-layer KV cache → efficiency.kv_cache (shared KV tensors across layer groups — distinct from GQA; Gemma 4 E-series)
• MTP drafter → efficiency.speculative_dedup (multi-token prediction used as draft model)
• 80A3 → scale.total_params / scale.active_params_per_token (report shorthand for 80B total / 3B active; Qwen3-Coder-Next)
• einsums → scale.total_params (non-embedding matmul parameter accounting; Gemma 4 Table 1)
• Looped Transformer, layer reuse, two-pass stack reuse → block.depth_mixing / prose (same stack processed twice; Nanbeige 4.2)

• tied embeddings, weight tying, shared input-output embeddings, tied word embeddings → scale.embedding_tied
• open weights, open-source weights, weights released, public checkpoints → identity.open_weights
• tokenizer, vocabulary, vocab → scale.vocab_size, tokenizer.algorithm
• tiktoken, byte-level BPE, sentencepiece, BBPE → tokenizer.algorithm (record as stated)
• modality, vision-language, VLM, multi-modal → modality.*
• adapter, connector, projector, vision encoder, ViT → modality.attachment

Changelog

Changelog

Every schema/taxonomy change, dated, with the trigger. Current version: v0.4.0.

2026-08-08 — v0.3.5 — depth-mixing field (trigger: Kimi K3 ingestion — Attention Residuals)

1. block.depth_mixing added (schema.md §4, schema.json leafEnumDepthMixing): sequential-residual | attention-residuals. Triggered by Kimi K3's Attention Residuals (AttnRes) — per-layer learned attention over prior layer outputs — which no existing field could represent; without a field it would have lived only in prose.
2. Backfilled all 5 existing records: depth_mixing → sequential-residual (inferred, absence rule — their stored reports describe the block in detail and never mention attention over prior layers).
3. Kimi K3 record: depth_mixing → attention-residuals (stated, §2.2; Block variant: 8 blocks × 12 layers + partial final block).

2026-08-08 — v0.3.4 — ingest pipeline: arXiv PDF fallback (trigger: report 2607.24653 has no HTML version)

• ingest.py _arxiv_source_url: arXiv abs URLs now resolve HTML → ar5iv → PDF via export.arxiv.org/pdf/<id> instead of erroring when no HTML exists. PDFs extract via pymupdf (installed) or pypdf.
• SKILL.md pitfall updated: PDF is last-resort extraction; flag PDF layout artifacts (math/tables garble) in prose, and rely on the step-7 grep-verify against source.txt.
• No schema/taxonomy fields changed — no backfill needed.

2026-08-08 — v0.3.3 — release-date convention (trigger: first seed batch — all five reports are undated in extracted text; Llama record initially carried an untraceable stated date)

1. identity.release_date rule extended (schema.md §2, SKILL.md conventions): stated when the report prints a date; otherwise inferred from arXiv v1 submission metadata (note records the arXiv ID + API as evidence); announcement/marketing dates are never used. Strict "report text only" dating left the timeline strip empty (zero dated models) and forced world-knowledge dates to masquerade as stated.
2. Backfilled all 5 records: release_date → inferred with arXiv-ID evidence (Llama 3.1 corrected from an untraceable stated 2024-07-23 — the announcement date — to the arXiv v1 date 2024-07-31).

2026-08-08 — v0.3.2 — reference-variant rule refined (trigger: Phi-3 ingestion)

• schema.md §3 + SKILL.md conventions: reference variant is now the variant the report leads with as its flagship (title/abstract framing decides; example: phi-3-mini), falling back to largest disclosed when the report leads with none. The v0.2.0 rule ("largest disclosed") misclassifies reports whose flagship is not the largest (Phi-3: mini 3.8B leads; small 7B / medium 14B are variants).
• No backfill needed — the Phi-3 record (analysed under v0.3.1) already uses the correct reference; its skill_version field records the version it was extracted under.

2026-08-08 — v0.3.1 — schema.md/data.schema.json alignment (trigger: first ingestion batch — Llama 3.1, DeepSeek-V3, Mixtral)

Clarifications so the human schema and the machine schema can never disagree:

1. block.block_type values corrected to dense | sparse-MoE | hybrid in schema.md (was dense | moe | hybrid; the machine enum and taxonomy.md already used sparse-MoE). Two independent extractors hit the mismatch.
2. n/a leaf shape clarified in the record form: value: null + provenance: "n/a" + ref (numeric-typed leaves accept null, so n/a is always expressible).
3. prose.notable_omissions clarified as a leaf whose value is an array of strings.

2026-08-08 — v0.3.0 — prose group (trigger: Prompt B, site bootstrap)

• schema.md §14 added: prose group (design_overview, lineage_in[], influence_out[], notable_omissions) — authored narrative lives inside the record so one JSON file per architecture remains the single source of truth for both specs and prose. All leaves tagged inferred ("authored by atlas analyst").
• taxonomy.md: added machine-parse format contract (build.py reads axis names from ## Axis N — name headings and the first table of each section).
• No backfill needed — no records exist yet.

2026-08-08 — v0.2.0 — dry-run validation fixes (trigger: Llama 3.1 validation fill, dry-runs/llama-3.1.md)

Fixes applied after dry-running the schema on a well-known architecture. No backfill needed — no records exist yet.

1. Absence rule added (schema.md §4 + SKILL.md): for a mechanism the report doesn't mention — if the report's architecture description is detailed enough that the mechanism would appear were it used, absence → inferred "not used" with that evidence; otherwise → unknown. Triggered by qk_norm, softcapping, partial_rope, embedding_tied on Llama 3.1.
2. Designed vs emergent distinction (schema.md block.stability.attention_sinks, SKILL.md): only explicitly designed mechanisms fill schema fields; emergent behaviour (e.g. emergent attention sinks) goes in prose. Llama 3.1 certainly has emergent sinks; the report designs none.
3. Reference-variant convention (schema.md §3, SKILL.md conventions, methodology.md §7): families with multiple disclosed sizes get one record; scale fields describe the largest variant; per-variant configs in scale.variants[]. Triggered by Llama 3.1's 8B/70B/405B.
4. n/a provenance tag (schema.md record form, SKILL.md): for fields inapplicable to a mechanism (e.g. attention_heads_kv under MLA), distinct from unknown (not disclosed).
5. undisclosed openness value (taxonomy.md Axis 4): report silence on release is itself a classification; never force a guess from world knowledge.
6. Release date convention (schema.md §2, SKILL.md): report publication date, not model availability date; ref required.
7. Active params for dense models (schema.md §3, SKILL.md conventions): active_params_per_token = total_params, tagged derived.
8. Distillation nuance (schema.md §8): teacher-generated training data is not distillation; noted in prose, not the field. Triggered by Llama 3.1 using 405B to generate SFT data for 8B/70B.
9. Benchmark value rule (schema.md §11): values stored digits-as-printed; no rounding of report numbers.
10. Closest-relatives rule (methodology.md §10): fixed comparable field set + tie-breaks, so the computation is reproducible.

2026-08-08 — v0.1.0 — initial schema and taxonomy (trigger: Prompt A, README.md)

• schema.md v0.1: record form (per-leaf provenance objects), groups 1–13 as in the prompt.
• taxonomy.md v0.1: six axes with values, decision rules, anchors.
• methodology.md v0.1: comparison conventions.
• glossary.md v0.1: alias table (~60 entries).

2026-08-10 — v0.4.0 — depth_mixing gains hyper-connections (trigger: DeepSeek V4 ingestion)

• DeepSeek V4's mHC (Manifold-Constrained Hyper-Connections) is a learned residual-matrix mechanism over the residual stream — neither plain sequential residuals nor Attention Residuals. Extended block.depth_mixing enum to hyper-connections.
• No backfill needed: no existing record uses the mechanism; the K3 Attention Residuals value is unaffected.
• data/schema.json leafEnumDepthMixing updated in sync.