AI Research Q&A — Agentic RL, World Models & Embodied AI

AI Research Q&A — Study Compendium

Today's papers — 6.26 list

The ten papers behind today's questions, from the 6.26 daily list. Tags link to the Q&A section where each one is discussed.

OPID: On-Policy Skill Distillation for Agentic Reinforcement Learning

arXiv 2606.26790 · Yang, Wu, Lu, Shen et al. · buzz 27

Extracts dense token-level supervision from the agent's own on-policy trajectories by turning hindsight into hierarchical skills (episode-level workflows + step-level decisions) and injecting them into the interaction history — avoiding external skill memories. A critical-first router picks step-level skills at key timesteps; the old policy re-scores under original vs. skill-augmented context to form a self-distillation advantage. Tested on ALFWorld, WebShop, Search-QA.

§3 skill injection §4 memory §5 walked trajectories §6 new scenarios

EBench: Elemental Diagnosis of Generalist Mobile Manipulation Policies

arXiv 2606.18239 · Gao, Zheng, Gao, Ma et al. · buzz 15

A diagnostic benchmark (26 sim tasks) that decomposes manipulation-policy evaluation into 5 capability + 4 generalization axes, exposing that models with near-identical success rates have very different capability profiles (π₀, π₀.₅, XVLA, InternVLA-A1) — aggregate scores hide the gaps.

§8 mobile manipulation §10 benchmarks §12 diagnostic proxies

RoPE-Aware Bit Allocation for KV-Cache Quantization

arXiv 2606.24033 · Liang, Zhang, Jia · buzz 6 · the paper from your screenshot

Block-GTQ: a KV-cache quantizer that exploits RoPE's frequency-block structure. It computes label-free energy scores per RoPE block per layer/head, then greedily assigns integer bit-widths by marginal gain (an offline, static allocation) on a TurboQuant-MSE backbone. Big long-context gains (e.g. Llama-3.1-8B NIAH 70.6→97.4) and sub-3-bit quantization without collapse on reasoning tasks. This answers the open question from our discussion: the allocation is computed offline, energy-based, validated on Llama-3.1-8B and DeepSeek-R1-Distill-7B.

§20 block structure §22 derivation §24 reconstruction vs logit §30 quantization

Hallucination in World Models is Predictable and Preventable

arXiv 2606.27326 · Hansen, Wang · buzz 1

Frames world-model hallucination as a data-coverage problem: predictable signals flag failure regions, and the same signals drive coverage-aware sampling + curiosity finetuning. Introduces MMBench2 and adapts 350M world models to unseen environments with ~50 real trajectories.

§11 WAM vs WM §9 world models

Plans Don't Persist: Why Context Management Is Load Bearing for LLM Agents

arXiv 2606.22953 · Mehta, Datta · buzz 1

Shows agent plans don't internalize into persistent hidden state but stay context-dependent — plan signal drops ~4.1× within one step. Introduces "replay pairing" (run with/without plan history, measure hidden-state distance) and corrects a reasoning-trace confound. The benchmark I referenced for negative transfer / skills not persisting.

§6 new scenarios §4 memory

Are We Ready For An Agent-Native Memory System?

arXiv 2606.24775 · Zhou, Zhou, Han, Xu et al. · buzz 95

Decomposes agent memory into four components (storage, extraction, retrieval/routing, maintenance) and evaluates 12 systems as a data-systems problem rather than black-box end-to-end. Finding: no architecture dominates — effectiveness depends on workload alignment; localized maintenance beats global reorganization. The "memory as data systems" framing behind Mode B.

§4 memory management

Why Multi-Step Tool-Use RL Collapses and How Supervisory Signals Fix It

arXiv 2606.26027 · Hao, Jin, Liao, Liu et al. · buzz 10

Pinpoints catastrophic collapse in tool-use RL to probability spikes in control tokens that break the execution format (the underlying capability stays intact). Interleaving SFT with RL substantially stabilizes training. The "tool-use RL work" from the briefing.

§2 agentic RL

JetSpec: Breaking the Scaling Ceiling of Speculative Decoding with Parallel Tree Drafting

arXiv 2606.18394 · Hu, Feng, Wu, Yuan et al. · buzz 18

Speculative decoding that breaks the draft-budget scaling ceiling: a causal parallel draft head over fused hidden states yields candidate trees aligned with the target's autoregressive factorization. Up to 9.64× on MATH-500, with vLLM integration. The "speculative inference" thread from the briefing.

§21 inference efficiency

Confidence-Aware Tool Orchestration for Robust Video Understanding

arXiv 2606.26904 · He, Choi, Yoon · buzz 6

Robust-TO attaches per-frame trustworthiness scores throughout the reasoning pipeline so video agents stop "blindly trusting" degraded frames (motion blur, glare, occlusion), routing trustworthy frames to specialist tools and aggregating with confidence-cost GRPO. The "tool orchestration robustness" signal from the briefing.

context only — not discussed directly

V-Zero: Answer-Label-Free On-Policy Distillation with Contrastive Evidence Gating

arXiv 2606.25319 · Sun, Yi, Deng, Zhou et al. · buzz 21

Answer-label-free on-policy distillation for fine-grained visual reasoning, adding contrastive evidence gating (a question-relevant crop paired with a negative view) to supply the missing trajectory-level discrimination. ~5× faster than SFT, ~10× than RL. The "V-Zero" paper from the briefing's OPD cluster.

§1 self-supervised §2 on-policy distillation

Part I

Agentic RL & On-Policy Distillation

1Self-supervised learning

Question

What is self-supervised learning?

In one sentence: the supervision signal comes from the data itself, not from human annotation.

It sits between the two classic paradigms. Supervised learning needs humans to provide (input, label) pairs — e.g. ten thousand images hand-labeled "cat/dog." Unsupervised learning has no labels at all and just finds structure. Self-supervised learning is the clever middle ground: it automatically manufactures labels out of the data's own structure, so you neither need humans nor lack a clear prediction target.

The canonical example is the language model itself: given the preceding words, predict the next token. The "label" is just the next token already present in the text — nobody annotated anything; the text supervises itself. BERT masks words and makes the model guess them; vision has masked autoencoders (reconstruct hidden patches) and contrastive learning (two augmentations of one image should match).

Why it matters: human annotation is expensive and slow — it is the bottleneck for scaling. Self-supervision lets a model consume the vast unlabeled data on the internet directly, which is one reason large models can scale. In the briefing's context, extracting "dense, self-supervised learning signals … without external labels" from agent trajectories means distilling learning signal out of trajectories the agent produces itself, rather than relying on external reward annotation. The trajectory already contains learnable structure — that is what "self-supervised" means here.

↑ contents

2Agentic RL (and on-policy distillation)

Question

What is agentic RL?

The skeleton of RL: an agent takes an action in an environment, receives a reward, and learns a policy that maximizes cumulative reward. Agentic RL specifically means using RL to train LLM-based agents — models that do multi-step reasoning, call tools, plan, and interact with an environment (search the web, run code, click buttons).

The key contrast with RLHF: RLHF (ChatGPT-style alignment) is basically single-step — one answer, one reward, update, done. Agentic RL is long-horizon and multi-step — an agent might take ~50 steps (search → filter → call tool → reason → verify), and feedback often arrives only at the very end (did the task succeed?). This creates three core difficulties, which the papers attack:

Credit assignment — 50 steps but one terminal reward; which steps were right vs. wrong?
Sparse reward — feedback is too rare and too late.
Data bottleneck — annotating every step's quality is prohibitively expensive.

Aside — on-policy distillationThe title term means the student model is corrected on trajectories it generated itself. The advantage: it learns to fix the mistakes it actually makes, rather than fitting a teacher's distribution it would never encounter on its own.

↑ contents

3OPID's hierarchical skill injection

Question

I don't fully understand OPID's "hierarchical skill injection — representing hindsight as two-level abstractions (episode workflows + step-level decisions) and injecting them back into the interaction history." Explain it carefully.

Three components, then two extensions.

1 · Hindsight. In RL, hindsight means waiting until a trajectory finishes and the outcome is known, then going back to reinterpret it. The classic source is Hindsight Experience Replay14: a robot meant to reach point A but reaching point B is a "failure" — yet it did successfully reach B, so you relabel the trajectory as a successful example of "how to reach B." Even failures yield signal. In one line: hindsight uses the god's-eye view of "I already know the outcome" to retroactively assign new meaning to a trajectory.

2 · Two-level abstraction (= "hierarchical"). OPID doesn't do hindsight monolithically; it splits retrospective understanding into two granularities. The episode workflow (macro) is the overall strategy — "first search X, then converge on Y, finally verify Z," a coarse playbook. The step-level decisions (micro) ask, at each concrete step given that state, whether the local decision was good and why. The same experience is abstracted at both levels at once.

3 · Skill injection. These two levels are not just used as training targets — they are fed back into the context (interaction history) the agent can see. The agent effectively writes itself two sticky notes after a task: "the playbook that worked was X" and "here is why each step's decision was correct." Next time it reads its history, those notes condition its behavior. It is a "skill" because the distilled workflow + decisions form a reusable capability; injecting it into history lets the model invoke that skill at the in-context level.

Putting it together: take a self-generated trajectory → look back in hindsight → split into workflow + per-step decisions → inject them back into context as a skill. You get dense supervision at two granularities at once, all sourced from the trajectory itself, with no external annotation — easing all three difficulties (coarse signal helps globally, fine signal helps per-step credit assignment, self-generation solves the data bottleneck).

Why "immediately extensible" — two directions. First, decouple reasoning traces from execution traces: a trajectory entangles "thinking" (chain of thought) and "doing" (actions, tool calls). The two-level template can split one level for reasoning, one for execution — so a failed plan can be attributed to "thought wrong" (bad plan) vs. "did wrong" (botched action) and each improved independently. Second, long-horizon credit assignment in embodied robotics: horizons are enormous and per-step supervision is scarce; the episode workflow gives a coarse skeleton ("approach → grasp → lift → place") and step decisions push credit down to concrete actions — all generated in hindsight, no external per-step labels. The reason it's elegant is that "hierarchical hindsight + injection into context" is domain-agnostic: the two levels map onto any natural hierarchy — workflow/step, reasoning/execution, subtask/atomic action.

↑ contents

4Memory management of injected skills

Question

If you inject episode workflows + step-level decisions into context, how is memory managed? Does the agent read all this from context every time, as prior knowledge?

The instinct is right — literally dumping everything into context every turn would blow up. There are two modes, differing on training-time vs. inference-time use.

Mode A — distillation scaffolding (primary for OPID). Because the method is on-policy distillation, injection is mainly a training-time vehicle. The pipeline: generate a trajectory → build an augmented context where the hindsight workflow + step decisions are present → train the student to act conditioned on that augmented context → distill the behavior into the weights. Afterward the skill lives in the parameters and the scaffold is discarded. That is distillation's whole purpose: move knowledge out of context (expensive, ephemeral, token-limited) and into weights (cheap at inference, permanent). So "does it read from context every time?" → no; the injection was a temporary teaching mechanism.

Mode B — external retrievable memory (the "agent memory as data systems" framing). The abstractions live in an external store (vector DB or structured store); on a new task you retrieve only the top-k relevant entries and inject those — never the whole library. This is essentially RAG-for-skills, matching the "prior knowledge" intuition.

Either way you never load everything every turn — which is exactly why the field treats agent memory as a data-systems problem (retrieval, indexing, eviction, staleness). And note the hierarchy is itself a compression scheme: storing "workflow + decisions" (a few sentences) instead of the raw trajectory (thousands of tokens) already does part of the memory management.

↑ contents

5"Only already-walked trajectories?"

Question

Isn't what this provides only trajectories that already worked?

Partly yes, partly no — and the "no" is the whole point of hindsight. The HER trick rescues failures: a trajectory that failed its original goal still reached some other outcome, and you relabel it toward what it actually achieved, so the raw material isn't restricted to successes. The suspicion holds for one specific use — the positive skill library (workflows injected as "do this") is naturally biased toward what led somewhere good. But failures get used differently: as contrastive signal ("this pattern leads nowhere") or negative examples, not as playbooks to imitate. The method isn't blind to failure; it files it under a different label.

↑ contents

6Do hindsight skills help in new scenarios?

Question

These come from completed trajectories — for genuinely new scenarios, are the hindsight skills useful?

This is the sharpest question, and it is where the hierarchy earns its keep, because the two levels generalize differently — the hierarchy is a generalization dial. Step-level decisions are brittle: "when search returned zero results, I broadened the query" is tied to a specific state that won't recur, so they transfer poorly. Episode workflows are transferable: "search → filter → verify → synthesize" is a strategy schema, not a state-specific reflex, so a new task with different content but the same shape can reuse it.

The honest limitationHindsight skills are interpolative, not extrapolative. They help when the new scenario sits inside the convex hull of what's been seen. For something truly out-of-distribution (a new tool, an unseen failure mode), step decisions are useless and the workflow can even hurt — the agent over-applies a stale pattern (negative transfer). The "Plans Don't Persist" benchmark is a diagnostic for exactly this.

Two mitigations. The on-policy part matters: the student keeps generating fresh trajectories on its current distribution — including new scenarios — and those get hindsight-abstracted too, so the skill library co-evolves rather than freezing. And hindsight can manufacture signal even from a first failed attempt in a new scenario; the one thing it cannot do is conjure signal from a scenario the agent has never touched — there must be at least one trajectory to look back on. The honest value proposition: these abstractions amortize exploration so that similar future scenarios become cheap; they do not replace exploration for genuinely novel ones.

↑ contents

Part II

VLA, WAM & World Models

7How VLA and WAM relate

Question

What is the connection between VLA (Vision-Language-Action) and WAM (World Action Models)?

Both are paradigms for robot/embodied policies — turning what a robot sees (and is told) into actions. The difference is how they decide. A VLA learns a reactive mapping: observation + instruction → action, directly; VLAs are pretrained on static image-text data and predict actions directly from visual and language inputs3 (RT-2, OpenVLA, NVIDIA GR00T). A WAM adds a predictive layer: instead of going straight to an action, it models how the world will evolve, targeting a joint distribution over future states and actions rather than actions alone4.

So: VLA asks "given what I see, what do I do?"; WAM asks "given what I see, what will happen next, and therefore what should I do?" WAMs emerged as a fix for a VLA weakness — VLAs excel at semantic generalization but struggle to generalize to unseen physical motions in novel environments1. WAMs attack that gap by learning physical dynamics from large-scale video, developing transferable motion priors3. Genealogically, WAMs emerge from the convergence of VLA policies and predictive world models8. Crucially the categories overlap: a WAM built on a pretrained VLM is simultaneously both a VLA and a WAM5 — RynnVLA-002 is a concrete unified example10.

	VLA	WAM
Core question	"What action, given observation?"	"What future, therefore what action?"
Mechanism	Reactive observation → action	Predictive: models dynamics, then acts
Main data	Image-text + robot demos	Large-scale video (dynamics)
Strength	Semantic / language generalization	Physical / motion generalization
Relationship	Predecessor paradigm	Absorbs VLA + world models

Caveat: this taxonomy is very fresh (early–mid 2026); definitions are still settling, and many "WAM beats VLA" claims come from the proposing groups, though independent robustness studies are beginning to test it9.

↑ contents

8Generalist mobile manipulation policies

Question

What are generalist mobile manipulation policies?

Three parts. Mobile manipulation = a robot that must both navigate (a mobile base moving through space) and manipulate (an arm/gripper acting on objects) — as opposed to a fixed arm on a table. The canonical framing is OVMM (Open-Vocabulary Mobile Manipulation): picking any object in any unseen environment and placing it at a commanded location, requiring perception, language understanding, navigation, and manipulation at once6. The hard part is the integration and the long horizon (find → approach → grasp → carry → place) — the same credit-assignment regime as Part I.

Generalist = one policy across many tasks, objects, scenes, and often embodiments, rather than one task-specific policy. So a generalist mobile manipulation policy is a single learned controller that drives a mobile-base-plus-arm robot to follow open-ended language across novel objects and scenes — the most demanding corner of embodied AI, stacking navigation, manipulation, open-vocabulary grounding, and long-horizon planning into one policy.

↑ contents

9Is WAM mainly video-trained?

Question

You mentioned WAM is mainly trained on large-scale videos?

Yes — that is the defining data choice. WAMs learn physical dynamics from diverse, large-scale video rather than memorizing task-specific demonstrations; trained to predict how the world evolves visually across many motions, they develop transferable motion priors3. DreamZero, which coined "WAM," is built on a video-diffusion backbone1. The logic is the self-supervised one again: video is an abundant, unlabeled record of "how the world moves," far cheaper than labeled robot trajectories.

Important nuance: "world model" does not imply "video." LeWM is a world model trained from raw pixels of control environments, not internet-scale video — so the video-substrate claim is specific to the WAM line (especially the DreamZero/video-diffusion family), not to world models in general.

↑ contents

10Common benchmarks

Question

Could you list several common benchmarks?

Split by what they actually test.

Mobile manipulation (navigation + manipulation, long-horizon):

HomeRobot OVMM — the open-vocabulary mobile-manipulation benchmark; an agent navigates household environments to grasp novel objects and place them on target receptacles, with both a simulation component and a real Hello Robot Stretch stack6.
BEHAVIOR / BEHAVIOR-1K — long-horizon everyday household activities.
Habitat rearrangement — embodied navigation + object rearrangement in 3D homes.
RoboCasa — large-scale simulation of everyday tasks for generalist robots11 (kitchen-scale).

Tabletop / fixed-arm manipulation (where most VLA & WAM numbers are reported):

LIBERO / LIBERO-Plus — lifelong & robustness manipulation; very common for VLA eval.
CALVIN — long-horizon language-conditioned manipulation.
RLBench, ManiSkill / ManiSkill2, MetaWorld — broad skill suites.
THE COLOSSEUM — generalization under systematic perturbations16.
RoboTwin (2.0 / -Plus) — bimanual/dual-arm generalization; used alongside LIBERO-Plus in WAM-vs-VLA robustness studies9.

Real-world generalist evaluation (newer, deployment-oriented): RoboArena (distributed real-world evaluation of generalist policies11), AutoEval (autonomous real-world evaluation11), and SimplerEnv (sim eval calibrated to predict real performance).

Carry this caveatThese are diagnostics, not deployment proxies. As one 2026 dataset survey bluntly puts it: none of these benchmarks are production proxies — do not treat high LIBERO scores as deployment readiness12. (See §12 and §16.)

↑ contents

11WAM vs. WM (world model)

Question

I've run world-model experiments with LeWM as the base substrate. Explain the difference between the two schemes: WAM versus WM.

LeWM is the perfect reference point because it sits cleanly on the WM side of the line.

World Model (WM) — what LeWM is. A WM is a predictive model of dynamics: given the current latent state and an action, predict the future state/embedding. Crucially it does not itself produce the action. LeWM is a Joint-Embedding Predictive Architecture that maps observations into a latent space and predicts future embeddings conditioned on actions7. To act, you wrap the WM with an external decision procedure — planning/MPC/sampling in the latent space (what you'd do with LeWM), or train a separate actor "in imagination" (the Dreamer/DayDreamer pattern, where an actor-critic optimizes a policy from imagined latent rollouts13). The world model is the simulator; the policy lives outside it.

World Action Model (WAM) — the coupling. A WAM folds action generation into the predictive model itself: it unifies predictive state modeling with action generation, targeting a joint distribution over future states and actions4. The sharp test: future-state prediction must be part of the policy, not just an auxiliary backbone or external simulator8. That last clause is exactly what separates it from your LeWM setup, where prediction is an external simulator you plan against.

	World Model (LeWM, Dreamer)	World Action Model (DreamZero)
Predicts future states?	Yes	Yes
Generates actions itself?	No — selection is external	Yes — generation is internal
Prediction's role	External simulator to plan against	Part of the policy
Typical substrate	Raw pixels, latent JEPA (compact)	Large-scale video (diffusion backbone)
Output target	future state	joint (future state, action)

The field subdivides WAMs by coupling tightness: Cascaded WAMs predict the future then derive the action; Joint WAMs model future states and actions together in one distribution8. The Cascaded variant is the closest bridge from a pure WM — almost "a WM plus an action head wired into the same policy." Mental model across all the terms: a WM predicts dynamics; bolt action selection outside it → classic model-based RL/planning (LeWM); fuse action generation into it → a WAM; if that WAM also inherits a VLM's language grounding → it is a VLA too.

↑ contents

Part III

Foundational Concepts

12Diagnostic vs. deployment proxies

Question

What is the difference between diagnostic proxies and deployment proxies? Are there other proxies?

A proxy is a measurable stand-in for something you care about but can't measure directly or cheaply; every proxy has a gap to the true quantity. A diagnostic proxy isolates a specific capability under controlled conditions ("does the policy survive lighting changes?") — narrow, high-signal debugging that deliberately isn't realistic about everything else. A deployment / production proxy tries to predict real-world success on the actual target task ("will this work on my robot, in my building?"). The earlier warning is precisely that LIBERO etc. are good diagnostic proxies but bad deployment proxies12. This maps onto the briefing's "diagnostic benchmarking replacing monolithic metrics."

Other proxies worth naming: a surrogate training objective (next-token prediction is a proxy for "understands language"; video prediction a proxy for "understands physics"); a reward proxy (a hand-designed reward standing in for the true goal — see reward hacking / Goodhart in §16); a sim-to-real proxy (sim performance for real performance; the "sim-to-real gap" is the proxy gap); and an offline-for-online proxy (validation loss for online task success). The unifying principle is Goodhart's law (§16).

↑ contents

13Embedding space vs. latent space

Question

The concepts of embedding space and latent space are fuzzy to me.

They overlap heavily — both mean "a vector space where data lives as points" — and are often used interchangeably. The difference is emphasis. Embedding space emphasizes the map from raw input to a vector representation (a word/image/sentence embedding you then use for similarity, retrieval, downstream heads); the image is "input → encoder → embedding." Latent space emphasizes a hidden internal variable of a model — especially generative/predictive ones (a VAE bottleneck, diffusion latent, a world model's state); "latent" literally means "not directly observed," and the image is "a compressed internal space you can sample from, reconstruct from, or roll forward in time."

Crisp heuristic"Embedding" stresses representation (the encoding of something real); "latent" stresses generation/dynamics (a hidden variable you operate on). An embedding is a point in a latent space, so they aren't disjoint.

LeWM illustrates why people sometimes keep them distinct: the encoder maps pixels → a vector (call it the embedding), and the predictor rolls that vector forward under actions (call it latent dynamics). Same vectors, two framings. The whole JEPA pitch is "predict in latent/embedding space rather than in pixel space" — that's where the distinction carries weight.

↑ contents

14JEPA in detail

Question

More details on Joint-Embedding Predictive Architecture (JEPA)?

JEPA is LeCun's proposed architecture15, with I-JEPA (images), V-JEPA (video) and now LeWM (world model) instantiations. Understand it by contrast with two other families:

Generative / reconstructive (autoencoders, MAE): predict the actual input — reconstruct pixels. Problem: forced to model every detail, including unpredictable noise, wasting capacity.
Contrastive joint-embedding (SimCLR-style): encode two views, pull embeddings together, push from negatives. Problem: needs negatives and careful anti-collapse tricks.
JEPA (joint-embedding predictive): encode context x and target y separately into embeddings, then a predictor maps the context-embedding to the predicted target-embedding — optionally conditioned on a latent z or an action a. You predict in representation space, not input space.

The motivating principle: don't predict pixels if what you care about is how the world changes — learn a compact latent state, predict how actions move it forward, and plan in that space7. Predicting embeddings lets the encoder discard unpredictable detail and keep only predictable, semantic structure.

JEPA (action-conditioned, world-model form). Two encoders produce embeddings; the predictor maps the context embedding (plus action) to a predicted target embedding, scored against the target. Stop-gradient freezes the target side in the backward pass; the target encoder's weights are an EMA copy of the online encoder (§17). LeWM removes both tricks, using a Gaussian-latent regularizer instead.

The central failure mode is representation collapse: the encoder can map different frames to nearly identical embeddings, making prediction trivially easy but destroying the representation7. Every JEPA needs an anti-collapse mechanism — I-JEPA/V-JEPA use stop-gradient + an EMA target encoder; LeWM instead trains stably end-to-end from raw pixels with only two loss terms (a next-embedding prediction loss + a regularizer forcing latent embeddings toward a Gaussian), dropping the EMA/stop-gradient/pretrained-encoder hacks7. For the world-model case (your setup), the predictor is action-conditioned — (state embedding, action) → next state embedding — a latent dynamics model learned without pixel reconstruction or rewards.

↑ contents

15Why a WAM can also be a VLA

Question

You said WAM is more advanced than VLA — so why add a pretrained VLM's language grounding to a WAM to "turn it into" a VLA?

The "WAM > VLA on one ladder" framing (including my earlier "superset" phrasing) was too glib. WAM and VLA improve different axes, not points on one line. VLA's strength is semantic / language grounding (from a pretrained VLM) — understanding "pick up the red mug left of the sink." WAM's strength is physical-dynamics / motion generalization (from video prediction) — anticipating how the world moves.

A pure WAM (built only on a video-diffusion backbone) can have excellent motion priors yet relatively weak open-vocabulary language understanding. So adding VLM grounding is not downgrading a WAM into a VLA — it gives the WAM the other capability it lacked. The result has both axes and therefore satisfies both definitions at once. "Being a VLA" just means "takes vision + language, outputs action"; a VLM-backed WAM does exactly that, so it is a VLA, while also being a WAM. The statement "simultaneously a VLA too" is categorical, not a capability claim.

Two axes, not a ladder. Moving up is the WAM contribution (dynamics); moving right is the VLA contribution (grounding). Adding a VLM pushes a pure WAM rightward into the top-right corner — strongest on both, and a model there is a VLA and a WAM at once.

So you aren't "turning a WAM into a VLA" — you're adding the axis the pure WAM was missing, landing in the corner that's strongest on both. The frontier models (RynnVLA-002, GR00T 2) deliberately want both.

↑ contents

16Goodhart's law

Question

Does Goodhart's law mean: if we treat metrics as optimization targets, the metric becomes a failed metric because it induces people to use inappropriate means to get a better result rather than be evaluated fairly?

Correct in spirit — and worth sharpening in one place. Your version is one real mechanism, but it's a special case of something broader. The deeper statement is about the gap between a proxy and the true thing you care about. A metric is only a correlate of real quality; under normal conditions the two move together. The moment you apply hard optimization pressure, the optimizer (person or algorithm) finds the cheapest way to raise the metric, and the cheapest way is almost always to exploit the slack between proxy and true goal rather than improve the goal. The correlation that made the metric useful was a "statistical regularity" — and, exactly as Goodhart's original wording says, that regularity dissolves once you push on it for control17.

The key widening: the failure does not require bad faith. It happens even with honest, blind optimization:

Human gaming (your case): teaching to the test — scores were a proxy for learning, so optimizing scores yields test-taking tricks, not learning.
Pure optimization, no malice: an RL agent maximizing a proxy reward finds degenerate shortcuts ("reward hacking") that score high while doing the wrong thing. Nobody cheated; the optimizer just exploited the proxy-target gap.
The original: once the Bank of England targeted a money-supply aggregate, the historical relationship between that aggregate and the economy broke down17.

So the precise version: optimizing a proxy exploits the gap between proxy and true objective, so the proxy stops tracking what you care about — via gaming, via blind shortcut-finding, or via the regularity simply collapsing. Your "fair evaluation" instinct is the flip side: a metric stays a good measure only while it isn't the target. This is exactly why LIBERO is a fine diagnostic but a bad deployment proxy (§10, §12): once a whole field overfits to a benchmark, a high score stops meaning real-world competence.

↑ contents

17Stop-gradient & EMA target encoder

Question

In "plus an EMA target encoder," what are stop-gradients and EMA?

Both are tricks for the same purpose: preventing representation collapse in self-supervised setups with two encoders (used in I-JEPA/V-JEPA/BYOL18). The setup is a student-teacher pair: an online encoder (the one being trained) produces a context embedding, and a target encoder produces the embedding you're trying to predict. The collapse danger is the trivial solution "map every input to the same constant vector" — prediction becomes perfect and the representation worthless.

Stop-gradient is an operation that's an identity in the forward pass but blocks gradients in the backward pass — anything behind it is treated as a constant (gradient zero). Wrapping the target embeddings in a stop-gradient makes the loss update only the online encoder toward the target, never the target side. Why this prevents collapse: if gradients flowed into both encoders symmetrically, the laziest way to match two embeddings is to drag both toward the same constant (mutual collapse). Stop-gradient breaks the symmetry — the online encoder must actually learn to predict a target it cannot trivially pull to zero. Image: you're aiming at a target; if the target could slide to wherever you point, you'd both meet at a meaningless spot — stop-gradient pins the target.

EMA (Exponential Moving Average) target encoder answers: if the target encoder isn't trained by gradients, where do its weights come from? They're a slowly-updated copy of the online encoder's weights:

Update ruleθ_target ← τ · θ_target + (1 − τ) · θ_online, with τ close to 1 (often 0.99–0.999).

So the target encoder is a lagging, smoothed "slow teacher" trailing the "fast student." EMA itself is just a weighted average favoring recent values and decaying old ones exponentially (Adam's moment estimates and Polyak weight-averaging are EMAs too); here it's applied to the encoder weights. The point is stability: a target identical to the online encoder every step is a moving goalpost that destabilizes training and invites collapse; the EMA makes the target evolve slowly and consistently. Together they form an asymmetric student-teacher loop — the target is an EMA copy (not directly trained), and stop-gradient guarantees the loss never optimizes it — which is what lets these methods avoid collapse without negative samples.

And this closes the LeWM thread: LeWM's selling point is throwing both of these out, replacing the stop-gradient + EMA machinery with a single explicit regularizer (force the latent toward an isotropic Gaussian), training end-to-end with one encoder and two loss terms7.

↑ contents

Part IV

Worked Example & Vocabulary

18The cobra effect

Question

"A bounty on dead cobras leads people to breed cobras" — what is this?

It's the anecdote that gives Goodhart's law its nickname, the "cobra effect." The story (told about British colonial Delhi): worried about venomous cobras, the government offered a bounty — cash for every dead cobra turned in. The logic was sensible: pay for dead cobras → people kill cobras → fewer cobras. It worked at first. Then people realized that if the government pays for dead cobras, the smart move isn't to hunt wild ones (hard, dangerous, limited) but to breed cobras at home specifically to kill them and collect the bounty — farming cobras as a cash crop. When the government discovered this and scrapped the program, the breeders' now-worthless snakes were released, leaving more cobras than before.

It's the perfect Goodhart example: the true goal was fewer cobras in the city; the target metric was dead cobras turned in. Normally those track together, but once the metric had money attached, the cheapest way to raise it (breeding) decoupled from — even opposed — the real goal. Note nobody was being elaborately "evil"; they were rational agents optimizing the reward given, the same structure as reward hacking in RL (§16).

Honest footnote: the Delhi cobra story is the standard textbook anecdote but is poorly documented historically. A better-documented case is colonial Hanoi, where the French paid a bounty per rat — proven with a severed tail — and ended up with tailless rats breeding in the city, because cutting a tail and releasing the rat was more profitable than killing it. Same mechanism, sturdier evidence.

↑ contents

19Vocabulary: venomous, bounty

Question

Explain "venomous" and "bounty."

venomous. An animal that produces venom — a toxic substance it injects into another creature to kill prey or defend itself. For a snake, venomous means it can bite and inject poison through its fangs; a cobra bite can seriously harm or kill, which is why the government wanted them gone. The easily-confused pair: venomous = it injects the toxin into you (a snake bite, a scorpion sting); poisonous = it harms you when you touch or eat it (a poison dart frog, certain mushrooms). Memory aid: if it bites you and you get sick, it's venomous; if you bite it and you get sick, it's poisonous. A cobra is venomous, not poisonous.

bounty. A reward (usually money) offered by an authority for accomplishing a specific task — often catching, killing, or capturing something. "A bounty on dead cobras" means a price on every dead cobra: hand one in, get paid. (Hence "bounty hunter" — someone who catches wanted criminals for the reward posted for them.) So "a bounty on dead cobras leads people to breed cobras" reads as: because the government offered cash for each dead venomous snake, people raised cobras on purpose just to kill them and collect the payments.

↑ contents

Part V

RoPE Attention & KV-Cache Quantization

20RoPE: block structure — inherent or by definition?

Question

What is the principle of RoPE attention? Is the block-wise feature inherent or by definition? What other attentions are there?

RoPE (Rotary Position Embedding19) encodes position by rotating the query and key vectors. The block structure is by construction — but a well-motivated construction, not an arbitrary one. It is not an emergent property of trained weights, nor a property of attention in general; it is baked into RoPE's definition.

RoPE splits a head vector into d_h/2 coordinate-pairs and rotates pair i by an angle proportional to the token's position, using frequency θᵢ (a geometric series). So the rotation matrix R_m is block-diagonal with d_h/2 2×2 rotation blocks. Because rotations compose (R_mᵀ R_n = R_{n−m}), the logit (R_m q)ᵀ(R_n k) = qᵀ R_{n−m} k depends only on the relative offset Δ = n−m — RoPE's whole reason to exist. And since R_Δ is block-diagonal, the logit is a sum of independent per-block terms: 𝒦_Δ(q,k) = Σᵢ q⁽ⁱ⁾ᵀ R(Δθᵢ) k⁽ⁱ⁾.

The consequence the paper exploits: a cached key is not used through a flat-vector interface. When a future query attends to it at relative distance Δ, the key passes through R_Δ — consumed block-by-block. Each block contributes its own additive term and the blocks differ in frequency (and so in error-sensitivity), so a uniform quantizer wastes precision. RoPE-aware bit allocation instead hands each block bits in proportion to its logit impact (the paper here is Block-GTQ2).

The paper's thesis in one picture. The key is really dₕ/2 rotated blocks, each with its own logit impact — so bits should follow impact, not be spread uniformly over a flat vector.

Other attentions split into two axes. Positional schemes (RoPE's actual category): absolute (sinusoidal/learned), relative (Shaw, T5 bias), RoPE (rotary), ALiBi (linear logit penalty), NoPE (none, §25). Under absolute/ALiBi/NoPE the key is a genuinely flat vector, so this paper's trick doesn't apply — it is specific to RoPE. Architecture variants (how heads/KV are organised, §26–27): MHA, MQA, GQA, MLA, plus sliding-window/sparse/linear attention.

↑ contents

21KV-cache quantization & bit allocation

Question

Is key-cache quantization a research topic? What are its applications? What is the relationship between bit allocation and KV-cache quantization? What is the default setting?

Yes — it's an active subfield of LLM inference efficiency / model compression. The KV cache stores every past key and value so the model needn't recompute them each step, but its size grows as layers × heads × head_dim × seq_len × batch; at long context or high concurrency it dominates GPU memory and bandwidth, and decoding is bandwidth-bound, so a fatter cache directly slows generation. Quantizing K/V from 16-bit to 8/4/2-bit shrinks both. Representative directions: KIVI, KVQuant, GEAR20; in production, FP8 KV in vLLM/TensorRT-LLM and KV-quant flags in llama.cpp26. Applications: long-context inference, serving many users cheaply, on-device/edge LLMs.

Quantization vs. bit allocationQuantization is the operation (map floats to a few levels via a shared scale). Bit allocation is the policy deciding how many bits each part gets — a design axis inside quantization. Uniform quantization gives every element the same bits; mixed-precision allocates unevenly by importance. "RoPE-aware bit allocation" is one informed policy: spread a fixed budget across RoPE blocks by logit impact.

Default setting shared by RoPE models: RoPE on Q/K per head with base 10000 and even head_dim; KV quantization typically per-channel (asymmetric) int8/int4 for keys, per-token for values (§30), with a calibration pass. The full modern default looks like: softmax attention, RoPE, GQA, and a quantized KV cache.

↑ contents

22RoPE re-derived: per-head, formula, why block-diagonal

Question

Does RoPE only act on the head? Can you re-describe the whole process with the formula and subscripts, draw a picture, and explain why it's block-diagonal?

Per-head: RoPE acts on the per-head query and key vectors, independently for each head, and only on Q and K — never on V, and not on the residual stream. The "head vector" is the slice of dimension d_h = d_model / n_heads for one head; RoPE rotates that head's q and k just before the logit is computed, with the same frequencies usually shared across heads.

The process, with subscripts: (1) token at position m has query q_m ∈ ℝ^{d_h}; cached token at n has key k_n. (2) Split d_h into d_h/2 pairs; pair i is a 2-D vector. (3) Frequency θᵢ = base^{-2(i-1)/d_h} (fast for small i, slow for large i). (4) Rotate pair i by angle m·θᵢ with the 2×2 matrix R(mθᵢ). (5) Stacking gives R_m = block-diag(R(mθ₁), …), and q̃_m = R_m q_m, k̃_n = R_n k_n. (6) Logit = q̃_mᵀ k̃_n = q_mᵀ R_mᵀ R_n k_n = q_mᵀ R_{n−m} k_n — only Δ = n−m survives.

Why block-diagonal: each 2-D pair is rotated on its own, with no mixing between pairs. A block-diagonal matrix is exactly "a separate transform per disjoint coordinate-group, zero elsewhere." The independence is deliberate: it is cheap (O(d_h)), it makes rotations compose per block so the relative-position identity holds, and it provides many frequencies at once (Fourier-feature-like).

Block-diagonal structure. Coloured 2×2 blocks rotate matching coordinate-pairs of the vector; off-diagonal zeros mean pairs never mix. Composition of rotations gives the relative-position identity.

↑ contents

23SO(2), the rotation group

Question

I've met SO(2) before but want it explained more clearly.

SO(2) is the special orthogonal group in 2-D — all rotations of a plane. Orthogonal (O): matrices with QᵀQ = I, preserving lengths and angles. Special (S): determinant +1, dropping reflections and keeping proper rotations. (2): acting on 2-vectors. So SO(2) is exactly the matrices R(θ) = [[cosθ, −sinθ],[sinθ, cosθ]], one per angle.

Two properties power RoPE: it's a group (rotations compose, each has an inverse), and angles add under composition: R(α)R(β) = R(α+β). Since the inverse rotates back (R_mᵀ = R(−mθ)), R_mᵀ R_n = R((n−m)θ) = R_{n−m} — the whole relative-position trick. Each RoPE block is an SO(2) element; the full R_m is a block-diagonal product of d_h/2 independent SO(2) rotations.

↑ contents

24Reconstruction error vs. logit error

Question

How to understand that flat reconstruction error ‖k − k̂‖² does not map linearly onto logit error?

Let e = k − k̂ be the quantization error. Flat reconstruction error ‖e‖² is the raw Euclidean size of the error — isotropic, every direction counts equally. Logit error is how much the score moves: qᵀR_Δ(k − k̂) = qᵀR_Δ e = Σᵢ qᵢᵀ R(Δθᵢ) eᵢ.

The logit error is a linear functional of e weighted by q and the rotation, not the magnitude of e. So two errors with identical ‖e‖ can give wildly different logit errors: error aligned with R_Δᵀq corrupts the logit a lot; error orthogonal to it is invisible. Per block, error in a block where qᵢ is large (or the rotation lines it up with qᵢ) hurts more. Minimizing ‖e‖² spends bits equalizing every direction — including ones the logit ignores. The right objective is minimizing logit error, i.e. putting bits where qᵀR_Δ is sensitive. "Doesn't map linearly" = small ‖e‖² does not guarantee small |qᵀR_Δ e|.

↑ contents

25NoPE (no positional encoding)

Question

Is NoPE a future direction? Introduce it in detail.

NoPE = No Positional Encoding. A decoder-only (causal) transformer can be trained with no explicit position signal at all, because the causal mask itself leaks position — token t can attend to exactly t previous tokens, so attention can "count" and implicitly reconstruct position. Kazemnejad et al. (2023)24 showed NoPE decoders can match or beat explicit encodings on some length-generalization tasks (extrapolating beyond training length) — exactly where RoPE and other explicit PEs tend to struggle.

Is it a future direction? It's an active research area, and some models experiment with NoPE or hybrids (most layers RoPE, a few NoPE) for long-context extrapolation — but RoPE still dominates production, so NoPE is a promising angle, not the default. Connection to this paper: under NoPE the key really is a flat vector (no rotation interface), so the RoPE-aware trick wouldn't apply and flat reconstruction error would be the right quantization objective. The paper's value is tied to RoPE being present.

↑ contents

26MHA / MQA / GQA

Question

MHA, MQA, GQA are common — explain the principles and use cases, with a comparison table.

These organise the key/value heads (orthogonal to position) and directly control KV-cache size. In standard attention each query head has its own K and V; the variants share K/V to shrink the cache. Decoding speed is limited by how much KV must be read per token, so fewer KV heads = less to read = faster and smaller22.

	MHA (multi-head)	MQA (multi-query)	GQA (grouped-query)
Query heads	h	h	h
KV heads	h (one per query head)	1 (all share)	g groups (1 < g < h)
KV-cache size	Largest (×h)	Smallest (×1)	In between (×g)
Quality	Best	Slight drop, can hurt	Near-MHA
Decoding speed	Slowest	Fastest	Fast, balanced
Typical use	Smaller models, max quality	Aggressive inference savings	Modern default for large LLMs

MQA collapses to one shared KV head — maximal savings but can lose quality and destabilise training. GQA is the compromise: split query heads into g groups, each sharing one KV head — almost all of MHA's quality at a fraction of the cache, which is why it's the default in current large models. For this paper, all three still store RoPE-structured keys (GQA/MQA just store fewer), so per-key RoPE-aware allocation applies regardless.

↑ contents

27MLA, low-rank compression & commuting

Question

What are MLA models? "RoPE doesn't commute with the low-rank compression" — how to understand this? Is there a "high-rank" counterpart?

MLA = Multi-head Latent Attention (DeepSeek-V2/V323). It goes further than GQA: instead of caching K and V directly, it compresses them into a small latent vector via a down-projection, caches only that latent, and reconstructs K/V via an up-projection when needed — shrinking the cache far below even GQA.

Low-rank compression means factoring a big projection into two thin matrices (down then up) with a narrow bottleneck of dimension r ≪ d; "rank" is how many independent dimensions the factorization can express. The opposite isn't a named "high-rank compression" technique — it's simply full-rank / uncompressed (plain MHA caches full K/V = full rank, no bottleneck).

"Doesn't commute": two operations commute if AB = BA (order doesn't matter). MLA's efficiency trick folds the up-projection into the query projection so full keys are never materialized — but RoPE inserts a position-dependent rotation R_m between latent and key. You'd need R_m(W_up c) = W_up(R_m c), but R_m depends on position while W_up is fixed across positions, so they don't commute and the fold-in breaks. DeepSeek's fix is decoupled RoPE: split the key into a compressed un-rotated part (low-rank, cached) and a small separate part that carries RoPE at full dimension. Because the RoPE dims are already isolated, RoPE-aware bit allocation is especially natural there.

↑ contents

28Softmax attention & alternatives

Question

Besides softmax, are there other options? Is softmax an activation function here?

"Standard softmax attention" normalizes the raw scores into attention weights with softmax (all positive, summing to 1, a distribution over keys). Alternatives exist: linear attention (Performer, Linear Transformers, RetNet) replaces softmax with a kernel feature map for linear-time/recurrent computation; sparse variants (sparsemax, entmax, top-k) give sparse weights; non-softmax normalizers like sigmoid or ReLU attention. So softmax is the default, not the only choice.

Is softmax an activation function? Yes — it's a vector-valued activation/normalization mapping reals to a probability simplex (the standard output activation for classification). The nuance: unlike a pointwise activation like ReLU, softmax normalizes across the set of keys (it couples the elements), so here it acts as the normalizer over the attention dimension rather than a per-element nonlinearity.

↑ contents

29Offline vs. online (inference time)

Question

Does "offline" refer to inference time in most settings?

No — essentially the opposite. Offline = computed ahead of time, outside the live serving loop — typically a one-time calibration pass on sample data to fix quantization parameters or the bit-allocation budget, before deployment. Online (dynamic) = computed during inference, per token/sequence. So "compute the per-block budget offline" means decide it once via calibration (cheap at runtime, fixed); the alternative — adapting allocation per token while decoding — is the online/inference-time path (adaptive, but costs runtime compute). (Separately, "offline" can also mean batch vs. real-time, or "offline RL" = learning from a fixed dataset; here it means precomputed calibration.)

↑ contents

30Per-channel vs. per-token & outlier channels

Question

How to understand "keys quantize better per-channel, values per-token"? And what is an outlier channel?

Quantization shares one scale across a group; the golden rule is to group values of similar magnitude, because a group that mixes very large and very small values forces a big scale that crushes the small values' resolution. The KV cache (per head) is a matrix of tokens (rows) × channels (columns); you can scale per row (per-token) or per column (per-channel).

The deciding fact: the key cache has outlier channels. An outlier channel is a specific feature dimension whose values are consistently far larger than the others, in the same dimensions across nearly all tokens (first documented for activations in LLM.int8(), central to SmoothQuant/AWQ21). They matter for quality, so can't be clipped.

Group along the axis the outliers live on. Keys: outliers cluster in fixed channels → per-channel isolates them. Values: no channel structure → per-token, which also fits appending one token at a time during decoding.

So grouping keys by channel isolates each outlier into its own column scale (the outlier channel gets a big scale; other channels keep tight, precise ones). Grouping keys by token would put the outlier in every row, inflating every row's scale. Values lack the strong channel-aligned outliers, so per-token works — and it fits decoding, since tokens are appended one at a time, letting each new value vector be quantized on arrival. (Per-channel for keys is slightly awkward because a column's scale depends on all tokens, which is why methods like KIVI keep a small window of recent tokens in full precision.)

↑ contents

31FP8 precision, and llama.cpp

Question

Is the FP8 in "FP8 KV cache" a precision (I've seen FP16 before)? And what is llama.cpp?

FP8 is a precision. FP = floating point; the number is the total bit width, so FP8 is 8-bit, half the size of FP16. The ladder: FP32 (single), FP16 / BF16 (half — same 16 bits split differently: FP16 favors precision, BF16 favors range), FP8 (variants E4M3 and E5M2 by exponent/mantissa split), and emerging FP4. FP8 is floating-point quantization — it keeps a small exponent, so it has wide dynamic range and tolerates outliers better than INT8 (uniform fixed-point, needing explicit scales)25. It also has native support on recent NVIDIA hardware (Hopper/H100, Ada, Blackwell). "FP8 KV cache" = storing K/V in 8-bit floating point — half the memory/bandwidth, with the exponent absorbing most outlier pain.

llama.cpp is an open-source C/C++ inference engine for LLMs, started by Georgi Gerganov26. Originally for Meta's LLaMA models on ordinary hardware (a laptop CPU, no data-center GPU), it now supports many model families and GPU backends. It's known for the GGUF format, very aggressive weight quantization (down to 4- or 2-bit), and being the engine under many local/desktop LLM apps. Its KV-cache quantization flags let you pick the precision the cache is stored at — a concrete, widely-used place the ideas above ship to end users, where shrinking the KV cache is often what lets a long context fit on consumer hardware at all.

↑ contents

References

Primary sources (retrieved)

DreamZero — "World Action Models are Zero-shot Policies." arxiv.org/abs/2602.15922
Liang, Zhang, Jia, "RoPE-Aware Bit Allocation for KV-Cache Quantization" (Block-GTQ). arxiv.org/abs/2606.24033
NVIDIA, "What Is a World Action Model (WAM)?" Glossary. nvidia.com/en-us/glossary/world-action-model
"World Action Models: The Next Frontier in Embodied AI" (survey). arxiv.org/abs/2605.12090
DravenALG, "awesome-vla-wam" (curated list; VLA∩WAM note). github.com/DravenALG/awesome-vla-wam
Yenamandra et al., "HomeRobot: Open-Vocabulary Mobile Manipulation." arxiv.org/abs/2306.11565
Maes, Le Lidec, Scieur, LeCun, Balestriero, "LeWorldModel (LeWM): Stable End-to-End JEPA from Pixels." arxiv.org/abs/2603.19312
"World Action Models" survey site (Joint vs. Cascaded taxonomy; policy-internal prediction boundary). openmoss.ai/Awesome-WAM
"Do World Action Models Generalize Better than VLAs? A Robustness Study." arxiv.org/html/2603.22078v1
RynnVLA-002: "A Unified Vision-Language-Action and World Model" (DAMO/Alibaba). arxiv.org/abs/2511.17502
"RoboArena: Distributed Real-World Evaluation of Generalist Robot Policies" (refs RoboCasa, AutoEval). arxiv.org/pdf/2506.18123
Robotics Center, "Best Robot Learning Datasets 2026" (benchmarks-as-diagnostics vs. production). roboticscenter.ai/datasets/best-2026
Wu et al., "DayDreamer: World Models for Physical Robot Learning." arxiv.org/pdf/2206.14176
Pumacay et al., "THE COLOSSEUM: A Benchmark for Evaluating Generalization for Robotic Manipulation." arxiv.org/pdf/2402.08191
"Goodhart's law" (overview & 1975 original wording). en.wikipedia.org/wiki/Goodhart's_law

Foundational references (background)

Andrychowicz et al., "Hindsight Experience Replay," NeurIPS 2017.
LeCun, "A Path Towards Autonomous Machine Intelligence," 2022 (JEPA position paper); see also Assran et al., I-JEPA (CVPR 2023); Bardes et al., V-JEPA (2024).
Grill et al., "Bootstrap Your Own Latent (BYOL)," NeurIPS 2020 (stop-gradient + EMA target encoder).

Part V — RoPE & KV-quantization (background)

Su et al., "RoFormer: Enhanced Transformer with Rotary Position Embedding," 2021 (RoPE).
KV-cache quantization line: Liu et al., "KIVI" (2024); Hooper et al., "KVQuant" (2024); Kang et al., "GEAR" (2024). (Per-channel keys / per-token values.)
Dettmers et al., "LLM.int8()" (2022); Xiao et al., "SmoothQuant" (2023); Lin et al., "AWQ" (2023). (Outlier channels.)
Shazeer, "Fast Transformer Decoding" (2019, MQA); Ainslie et al., "GQA" (2023).
DeepSeek-AI, "DeepSeek-V2 / V3" (2024) — Multi-head Latent Attention & decoupled RoPE.
Kazemnejad et al., "The Impact of Positional Encoding on Length Generalization in Transformers," 2023 (NoPE).
Micikevicius et al., "FP8 Formats for Deep Learning," 2022 (E4M3 / E5M2).
Gerganov et al., "llama.cpp" (open-source LLM inference). github.com/ggerganov/llama.cpp

Note on freshness: the WAM/VLA/world-model literature is concentrated in early–mid 2026 and the taxonomy is still settling. The WM-vs-WAM inference-time framing for any specific paper (distill-into-weights vs. external store) is reasoned from the mechanism and should be confirmed against the primary source. Several "WAM > VLA" claims originate from proposing groups; treat headline numbers as provisional. The Part V background references (RoPE, KIVI/KVQuant, GQA/MQA, MLA, NoPE, FP8) are cited from background knowledge by author/title/year — verify the exact identifiers before formal use.