# Learn AI Visually

> Interactive visual simulations teaching GPU & CUDA, LLM internals, LLM serving, AI agents, and agent engineering — from CUDA kernels to PagedAttention to production agent fleets. Free, browser-based, no GPU required.

## About

Learn AI Visually is an interactive learning platform that teaches how modern AI systems work — spanning GPU & CUDA, LLM internals, LLM serving, AI agents, and agent engineering — through browser-based visual simulations. Each module includes step-by-step explanations with paired interactive visualizations.

Full prose content (FAQ answers + learning objectives for every module) is available at [llms-full.txt](https://learnaivisually.com/llms-full.txt).

## AI Knowledge Map

- [AI Knowledge Map](https://learnaivisually.com/ai-knowledge-map): An interactive visual map of the AI, LLM, and GPU concepts that matter — filter by engineering role to see how the ideas connect and what to learn next.

## Tracks

### LLM Internals (9 modules, free)

- [Tokenization](https://learnaivisually.com/tracks/llm-internals/tokenization): Watch BPE build a vocabulary merge by merge on real text. Interactive simulator for byte pair encoding, subword splitting, and token-to-ID mapping.
- [Embeddings](https://learnaivisually.com/tracks/llm-internals/embeddings): Drag tokens through an embedding lookup and watch them cluster in vector space. Interactive cosine similarity and positional encoding visualizer.
- [Self-Attention](https://learnaivisually.com/tracks/llm-internals/attention): Interact with a live Q/K/V heatmap as attention scores compute in real time. See multi-head attention, causal masking, and softmax weighting step by step.
- [Transformer Block](https://learnaivisually.com/tracks/llm-internals/transformer-block): Step through a transformer block live — LayerNorm, attention, residual, FFN — with activations shown at each stage. Pre-norm vs post-norm side-by-side.
- [Text Generation](https://learnaivisually.com/tracks/llm-internals/generation): Tweak temperature, top-k, and top-p on a live sampling simulator and watch the probability distribution flatten or sharpen token by token.
- [KV Cache](https://learnaivisually.com/tracks/llm-internals/kv-cache): Toggle KV caching on a running decoder and watch redundant recomputation collapse. Visual prefill vs decode, memory math, and grouped-query attention.
- [Quantization](https://learnaivisually.com/tracks/llm-internals/quantization): Drag a precision slider from FP32 down to INT4 and watch weights quantize in real time. Visual GPTQ, AWQ, NF4, QLoRA, and GGUF naming conventions.
- [Batching](https://learnaivisually.com/tracks/llm-internals/batching): Run static and continuous batching side-by-side on a live GPU timeline. Watch padding waste, slot occupancy, and continuous admission in real time.
- [PagedAttention](https://learnaivisually.com/tracks/llm-internals/paged-attention): Watch vLLM page the KV cache into virtual blocks and reuse prefixes across requests live. Interactive block table, copy-on-write, and prefix sharing.

### GPU & CUDA (9 modules, free)

- [Why GPUs?](https://learnaivisually.com/tracks/gpu-cuda/why-gpus): Race a CPU and GPU side-by-side on the same matmul. Visual latency-vs-throughput architecture, SIMD parallelism, and the CUDA software stack.
- [Execution Model](https://learnaivisually.com/tracks/gpu-cuda/execution-model): Watch 32-thread warps march in lockstep across an SM, with divergence and block scheduling visualized. Interactive thread hierarchy and SIMT execution.
- [Memory Hierarchy](https://learnaivisually.com/tracks/gpu-cuda/memory-hierarchy): Move data between registers, shared memory, L2, and HBM on a live bandwidth diagram. Visual latency, capacity, and NVLink vs PCIe tradeoffs.
- [Roofline Model](https://learnaivisually.com/tracks/gpu-cuda/roofline-model): Plot any ML op on an interactive roofline and see compute vs memory limits. Watch larger batch sizes slide ops from memory-bound to compute-bound.
- [Memory Access Patterns](https://learnaivisually.com/tracks/gpu-cuda/memory-access-patterns): Drag thread access patterns and watch 128-byte transactions coalesce or waste bandwidth. Interactive bank conflicts, strided access, and the padding trick.
- [Tiling & Matrix Multiply](https://learnaivisually.com/tracks/gpu-cuda/tiling-matmul): Run naive vs tiled matmul side-by-side on a live shared-memory diagram. Watch data reuse, tree reduction, and the roofline shift toward compute-bound.
- [Tensor Cores](https://learnaivisually.com/tracks/gpu-cuda/tensor-cores): Fire a Tensor Core MMA and watch 4×4 tiles multiply-accumulate in one clock. Visual FP32/TF32/BF16/FP16/FP8 throughput and mixed-precision loss scaling.
- [Operator Fusion](https://learnaivisually.com/tracks/gpu-cuda/operator-fusion): Watch FlashAttention keep Q/K/V tiles in SRAM while naive attention trips to HBM. Interactive kernel fusion, online softmax, and IO complexity.
- [Triton & torch.compile](https://learnaivisually.com/tracks/gpu-cuda/triton-torch-compile): Compare a CUDA kernel and its Triton rewrite side-by-side. Visual torch.compile pipeline, block-level abstractions, and the CUDA vs Triton tradeoff.

### LLM Serving (7 modules, free)

- [Inference Engine Internals](https://learnaivisually.com/tracks/llm-serving/inference-engine): Watch vLLM's scheduler admit, page, and preempt requests on a live GPU timeline. Interactive continuous batching, KV blocks, and prefill vs decode.
- [Speculative Decoding](https://learnaivisually.com/tracks/llm-serving/speculative-decoding): Run a draft model proposing tokens and a target model verifying them in parallel, live. Visual rejection sampling, acceptance rates, and 2-3x latency wins.
- [Prefill/Decode Disaggregation](https://learnaivisually.com/tracks/llm-serving/prefill-decode-disaggregation): See prefill and decode fight on one GPU, then split across pools on a live timeline. Interactive chunked prefill, KV transfer, and 2-7x throughput gains.
- [Serving Metrics & SLOs](https://learnaivisually.com/tracks/llm-serving/serving-metrics): Watch TTFT, TPOT, and P99 move live on a saturation curve as you raise load. Interactive goodput vs throughput, SLO targets, and capacity planning.
- [CUDA Graphs](https://learnaivisually.com/tracks/llm-serving/cuda-graphs): See 300+ per-token kernel launches collapse into one graph replay on a live decode timeline. Interactive capture, padding buckets, and production tradeoffs.
- [Multi-LoRA Serving](https://learnaivisually.com/tracks/llm-serving/multi-lora): Batch requests using different LoRA adapters and watch SGMV group them live. Visual 3-tier paging (GPU/CPU/disk) and the rank-vs-KV cache tradeoff.
- [Prefix Caching](https://learnaivisually.com/tracks/llm-serving/prefix-caching): Fire repeat system prompts and watch the KV prefix hit on a live radix tree. Interactive SGLang vs vLLM APC, eviction safety, and cache hit pricing.

### AI Agents (9 modules, free)

- [Agent Loop & State](https://learnaivisually.com/tracks/ai-agents/agent-loop-state): Visual introduction to the agent loop: gather → act → observe → repeat. See state mutate per tick, the LLM-OS framing, and the workflow-vs-agent decision rule.
- [Tool Use](https://learnaivisually.com/tracks/ai-agents/tool-use): How agents use tools: schemas, the agent-computer interface, structured outputs, MCP, and Skills. Visual examples of good vs bad tool design.
- [Workflow Patterns](https://learnaivisually.com/tracks/ai-agents/workflow-patterns): The five named workflow patterns: chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer. When NOT to use an agent.
- [Retrieval & RAG](https://learnaivisually.com/tracks/ai-agents/retrieval-rag): Retrieval-augmented generation explained visually. Embeddings as coordinates, chunking strategies, the recall-vs-speed trade, and named RAG failure modes.
- [Context Engineering](https://learnaivisually.com/tracks/ai-agents/context-engineering): Context as the agent's most expensive resource. The four context failure modes (poisoning, distraction, confusion, conflict) and the four fixes.
- [Planning & Reflection](https://learnaivisually.com/tracks/ai-agents/planning-reflection): When agents should plan, retry, pause, or stop. Reasoning budget, ReAct, Reflexion, and termination logic — each tied to a 'when' decision.
- [Evals & Diagnostics](https://learnaivisually.com/tracks/ai-agents/evals-diagnostics): Error analysis first, evals second. Compounding errors, the transition failure matrix, golden cases, and the four named eval failure modes.
- [Security & the Lethal Trifecta](https://learnaivisually.com/tracks/ai-agents/security-trifecta): The dominant 2026 safety frame for agents. Private data + untrusted content + exfiltration vector = breach. Structural defenses, capability scoping, and exfiltration via tool calls.
- [Capstone — Three Designs](https://learnaivisually.com/tracks/ai-agents/capstone-three-designs): RAG-only vs deterministic workflow vs autonomous agent on the same customer-order task. Trace comparison, failure modes, trifecta exposure, and the decision rule.

### Agent Engineering (9 modules, free)

- [Production Harness Architecture](https://learnaivisually.com/tracks/agent-engineering/harness-architecture): How an agent harness survives process kills, deploys, and network failures. Idempotency, checkpoints, retry policy, and durable execution platforms compared.
- [Observability for Agents](https://learnaivisually.com/tracks/agent-engineering/observability): Treat each agent tick as a span. What to log, what to alert on, and how to replay a failing trace. Vanity metrics vs metrics that matter.
- [Layered Guardrails](https://learnaivisually.com/tracks/agent-engineering/guardrails): Input filters, output filters, policy enforcement, and the fail-safe-vs-fail-open decision. Defense-in-depth that does not collapse to a single LLM judge.
- [Cost & Latency Engineering](https://learnaivisually.com/tracks/agent-engineering/cost-latency): Where the tokens and seconds actually go in an agent. Prompt and result caching, parallelizing tool calls, and batching at the agent layer.
- [Production Evals](https://learnaivisually.com/tracks/agent-engineering/production-evals): Online vs offline evals, shadow mode, A/B harness, drift detection, and eval-driven rollout. How to ship a prompt change without breaking production.
- [Deployment & Rollout](https://learnaivisually.com/tracks/agent-engineering/deployment-rollout): Treating prompts and tool schemas as code. Canary, rolling release, version pinning, and the rollback discipline that keeps a fleet healthy.
- [Incident Handling](https://learnaivisually.com/tracks/agent-engineering/incident-handling): What to do in the first 15 minutes of an agent incident. Trace replay, root-cause discipline, postmortem pattern, and the drills that build the muscle.
- [Agent Teams](https://learnaivisually.com/tracks/agent-engineering/agent-teams): When teams beat a single agent. Supervisor/worker, parallel agents with voting, handoffs, and the coordination tax you pay for the win.
- [Reliability Operations](https://learnaivisually.com/tracks/agent-engineering/reliability-ops): SLOs, error budgets, on-call rotations, and runbooks that survive contact with production. The bridge from Foundations to running an agent fleet.

### Inside vLLM (12 modules live, free)

- [How a request flows through vLLM](https://learnaivisually.com/tracks/inside-vllm/vllm-request-path): Follow one request through vLLM's real source: rendering, the engine process boundary, scheduling, the forward pass, and streaming back out.
- [vLLM's scheduler, both halves](https://learnaivisually.com/tracks/inside-vllm/vllm-scheduler): Scheduler.schedule() and Scheduler.update_from_output() are one class with two mutating halves. Trace the token budget, the preemption branch, and the collections both halves share.
- [vLLM's KV cache manager, four layers](https://learnaivisually.com/tracks/inside-vllm/vllm-kv-cache-manager): KVCacheManager, KVCacheCoordinator, SingleTypeKVCacheManager, and BlockPool as four real classes — the cache-hit lookup, the block-count arithmetic, and the sentinel-vs-exception failure split at their seams.
- [vLLM's model runner, the persistent batch](https://learnaivisually.com/tracks/inside-vllm/vllm-model-runner): GPUModelRunner as real code: the diff that mutates one persistent batch instead of rebuilding it, the forward pass that returns None and parks logits, and why uni and mp executors differ only in collective_rpc.
- [vLLM's sampler, the logits-processor chain](https://learnaivisually.com/tracks/inside-vllm/vllm-sampler): Sampler.apply_logits_processors and Sampler.forward as real code: on-GPU sampling, the ordered chain that makes logit_bias and repetition_penalty non-commutative, and the request-vs-server split for every sampling knob.
- [vLLM's return leg, detokenization and streaming](https://learnaivisually.com/tracks/inside-vllm/vllm-output-streaming): Follow a token id back across the process boundary, through the incremental detokenizer that holds a byte-fallback character back until it completes, and out as an SSE frame — real code, real methods, closing the round trip.
- [vLLM's attention backend selection, platform and registry](https://learnaivisually.com/tracks/inside-vllm/vllm-attention-backends): CudaPlatformBase.get_attn_backend_cls, the AttentionBackendEnum registry, and the metadata builder every backend must implement — real code for why an attention kernel is chosen once, at startup, and never revisited while the engine serves.
- [vLLM's model registry and weight loading](https://learnaivisually.com/tracks/inside-vllm/vllm-model-registry): From a HuggingFace architecture string to a resolved Python class, through the loader interface that iterates checkpoint tensors, to the parameter-level weight_loader that decides which tensor-parallel shard a rank gets — real code for why loading is not rank-independent.
- [vLLM's compilation config, piecewise split, and CUDA graph capture](https://learnaivisually.com/tracks/inside-vllm/vllm-compilation): CompilationConfig's five fields, why split_graph cuts the traced FX graph at attention instead of capturing one blob, and the ladder of batch sizes Worker.compile_or_warm_up_model captures at startup — real code for why a between-rungs shape still gets a graph and only a shape past the ceiling falls back to eager.
- [vLLM's distributed execution, rank layout and collective_rpc](https://learnaivisually.com/tracks/inside-vllm/vllm-distributed): TP, PP and DP as three independent axes, the world_size vs world_size_across_dp arithmetic vLLM gets right and a casual read gets wrong, the five real communication groups initialize_model_parallel builds, and how one collective_rpc call fans out to a single DP replica and reads back one nominated reply.
- [vLLM's KV connector interface, factory and P/D wiring](https://learnaivisually.com/tracks/inside-vllm/vllm-kv-connectors): One abstract base class, KVConnectorBase_V1, split into a scheduler-side half (get_num_new_matched_tokens) and a worker-side half (start_load_kv), selected by name through KVConnectorFactory at startup — the extension point that makes moving KV cache between disaggregated prefill and decode instances pluggable, illustrated with ExampleConnector's disk-backed implementation at the pinned v0.26.0 ref.
- [The Inside vLLM capstone — predicting a real PR and what the track left out](https://learnaivisually.com/tracks/inside-vllm/vllm-capstone): Three real, merged vLLM pull requests — title and description only, no diff — and a prediction exercise: name every file each one touched using nothing but the eleven-module map this track built, then reveal against the true set, bucketed onto the same startup/request lanes the rest of the track used. Closes with the order to read an unfamiliar diff in and an honest account of the six subsystems this track never taught.

## AI Explained

Trend-driven concept pages that use AI news as a hook to teach the underlying concepts with interactive simulations.

### Topics

- [LLM](https://learnaivisually.com/ai-explained?topic=llm): Trending LLM concepts — model releases, inference internals, training methods.
- [GPU](https://learnaivisually.com/ai-explained?topic=gpu): Trending GPU and CUDA topics — kernels, memory, parallelism.
- [Agent](https://learnaivisually.com/ai-explained?topic=agent): Trending AI agent topics — tool use, planning, evaluation.
- [AI Companies](https://learnaivisually.com/ai-explained?topic=ai-companies): Trending AI company news — releases, fundraising, joint ventures.

### Articles

- [/ai-explained](https://learnaivisually.com/ai-explained): Index of all AI Explained pages
- [Ring-Zero — Trillion-scale zero-RL](https://learnaivisually.com/ai-explained/ring-zero-1t-zero-rl-scaling): Ring-Zero runs zero-RL — reward-only RL with no SFT warm-up — at 1 trillion parameters, reporting higher sample efficiency and a two-phase learning pattern.
- [Regression control in continual agent optimization](https://learnaivisually.com/ai-explained/agent-optimizer-regression-control): A study finds agent-harness optimizers compound gains only with regression control that steers past shortcuts erasing old wins — RELAI-VCL leads at 76.4%.
- [MCPEvol-Bench — Tool-interface drift benchmarking](https://learnaivisually.com/ai-explained/mcpevol-bench-tool-interface-drift): MCPEvol-Bench mutates 123 real MCP servers with 11 operators to test tool-interface drift — the best of 12 LLM agents still loses about 14% as tools evolve.
- [Text-conditioned visual routing in speculative decoding](https://learnaivisually.com/ai-explained/tiger-text-conditioned-visual-routing): TIGER extends speculative decoding to vision-language models by routing the draft model to only the relevant image patches its current sentence is about.
- [Cross-request draft pruning in speculative decoding](https://learnaivisually.com/ai-explained/d-cut-cross-request-draft-pruning): D-Cut ranks draft tokens across concurrent requests by confidence, then cuts at the verification budget: speculative decoding goes 1.26x to 1.65x under load.
- [Trace-weighted kernel benchmarking in Atrex-Bench](https://learnaivisually.com/ai-explained/atrex-bench-trace-weighted-kernel-benchmarking): Atrex-Bench scores LLM-written GPU kernels on operators and shapes sampled from production traces, weighted by real GPU time and scored against the roofline.
- [Rank preservation vs magnitude control in Transformers](https://learnaivisually.com/ai-explained/transformer-rank-study-gradient-rank-preservation): Theory paper recasts skips and Pre-Norm as rank preservation, not magnitude control: why rank collapses under Post-Norm but plateaus under Pre-Norm at init.
- [Harness Handbook — behavior-centric harness map](https://learnaivisually.com/ai-explained/harness-handbook-behavior-centric-map): A behavior-centric harness map links one agent behavior to the source locations that implement it — prompt, state, tool call, coordination — not filenames.
- [Long-Horizon-Terminal-Bench — partial-reward threshold](https://learnaivisually.com/ai-explained/long-horizon-terminal-bench-partial-reward-threshold): The partial-reward threshold is the share of a task's graded reward a run must earn to pass. On Long-Horizon-Terminal-Bench, 1.0 gives 10.9%, 0.95 gives 15.2%.
- [Plan evaluators — deletion non-monotonicity](https://learnaivisually.com/ai-explained/plan-evaluator-deletion-non-monotonicity): Deletion non-monotonicity: a staged plan scorer can rate a plan higher when a needed step is cut, because that step's cost and its failure risk both vanish.
- [MemOps — memory lifecycle operations](https://learnaivisually.com/ai-explained/memops-memory-lifecycle-operations): MemOps grades agent long-term memory as lifecycle operations — remember, forget, update, reflect — tracing each memory event to pinpoint which one failed.
- [Estimate-Execute-Expand (E3) — Minimal Agent Scope](https://learnaivisually.com/ai-explained/e3-minimum-sufficient-execution): Estimate-Execute-Expand (E3) is a coding-agent strategy that starts from minimal scope and expands only when a verification check fails, cutting cost about 85%.
- [LLM-as-Judge Bias as a Steerable Direction](https://learnaivisually.com/ai-explained/judge-bias-activation-geometry): LLM-as-judge bias lives in steerable, low-dimensional directions in the judge's hidden state — a study that predicts failures and steers them to baseline.
- [AVQ-Attention — Adaptive vector-quantized attention](https://learnaivisually.com/ai-explained/avq-adaptive-vector-quantized-attention): AVQ-Attention makes attention cheaper by summarizing keys into codewords and adding detail only where attention concentrates, turning O(N²) into O(MN).
- [KronQ — Kronecker-factored Hessian quantization](https://learnaivisually.com/ai-explained/kronq-kronecker-factored-hessian): KronQ adds gradient covariance to PTQ, scoring each weight by input and output sensitivity — 2-bit LLaMA-3-70B holds at 7.93 perplexity where GPTQ collapses.
- [vLLM 0.25.1 — mixed-dtype quant-fusion guard](https://learnaivisually.com/ai-explained/vllm-0-25-1-mixed-dtype-fusion-guard): vLLM 0.25.1 adds a dtype-match guard so a fused all-reduce + RMSNorm + static-quant kernel stops silently corrupting mixed-precision NVFP4 model outputs.
- [ARMT — Associative recurrent memory](https://learnaivisually.com/ai-explained/armt-recurrent-associative-memory): ARMT extends an LLM's context with a fixed-size recurrent associative memory instead of a growing KV cache: memory stays flat as text grows, ~30% fewer FLOPs.
- [FastTPS — Reloading-free KV-cache concatenation](https://learnaivisually.com/ai-explained/fasttps-reloading-free-kv-concat): Reloading-free KV-cache concatenation lets FastTPS run an LLM's decode without recopying the cache: fused attention hits 93% peak bandwidth, 6× on an NPU.
- [Interaction scaling — instrument-grounded feedback loops](https://learnaivisually.com/ai-explained/interaction-scaling-grounded-feedback-loops): Instrument-grounded feedback loops let agents measure real artifacts and revise, and keep improving on hard coding tasks where reasoning and best-of-N stall.
- [HCRMap — hotness-aware MoE expert placement](https://learnaivisually.com/ai-explained/hcrmap-hotness-aware-expert-placement): HCRMap ranks each MoE expert by hotness, then promotes or evicts its replicas across a multi-chiplet chip's memory tiers, cutting serving latency up to 46.7%.
- [Flint — semantic IR for agent charts](https://learnaivisually.com/ai-explained/flint-semantic-ir-charts): Microsoft's Flint is a semantic intermediate representation for agent charts: the agent writes a short spec, a compiler emits Vega-Lite, ECharts, or Chart.js.
- [GATS — world-model tree search for agents](https://learnaivisually.com/ai-explained/gats-world-model-tree-search): GATS (Graph-Augmented Tree Search) plans an agent by searching a learned world model — zero LLM calls during the search, 100% success where LATS hits 92%.
- [KV-PRM: scoring reasoning from the KV cache](https://learnaivisually.com/ai-explained/kv-prm-verify-token-scoring): KV-PRM scores a reasoning trajectory from the KV cache the model already built — one verify token, not a re-encode — cutting scoring cost O(L²) to O(L).
- [Self-guided test-time training on evidence spans](https://learnaivisually.com/ai-explained/self-guided-ttt-evidence-span-training): Self-Guided Test-Time Training adapts a long-context LLM per question: it trains on only the evidence spans that matter, recovering up to 15% relative accuracy.
- [Danus — verifier-gated fact graph](https://learnaivisually.com/ai-explained/danus-verifier-gated-fact-graph): Danus orchestrates math-reasoning agents so a planner and parallel workers propose claims that a stateless verifier gates into one shared, verified fact graph.
- [Agora — auction-based task allocation](https://learnaivisually.com/ai-explained/agora-auction-task-allocation): Auction-based task allocation (Agora): expert models bid on each agent step by rectified competence and cost, so one dial tunes routing cost vs quality.
- [vLLM 0.25 — Model Runner V2 retires PagedAttention](https://learnaivisually.com/ai-explained/vllm-0-25-model-runner-v2-pagedattention): vLLM 0.25 removes PagedAttention and makes Model Runner V2 the dense default, and reports full CUDA graphs for decode. What the change means, explained.
- [Vera CPU & the agent-step bottleneck](https://learnaivisually.com/ai-explained/nvidia-vera-cpu-agent-step-latency): NVIDIA argues an agent step spends real time on serial CPU work between GPU calls, so its Vera CPU targets maximum single-thread speed to keep GPUs busier.
- [STRACE & causal trace localization](https://learnaivisually.com/ai-explained/strace-causal-trace-localization): STRACE reduces a failed agent's noisy trace to the steps that causally explain the failure — causal localization on a dependency graph, not length trimming.
- [EdgeBench & the environment-learning scaling law](https://learnaivisually.com/ai-explained/edgebench-environment-learning-scaling-law): EdgeBench measures post-deployment agent learning across 134 tasks as a log-sigmoid curve (R²=0.998), and reports learning speed doubling every 3 months.
- [Training-free linear attention & cache routing](https://learnaivisually.com/ai-explained/training-free-linear-attention-cache-routing): A trained model gains linear attention with its backbone frozen: sink tokens, a short convolution, and fixed-budget cache routing recover long-context recall.
- [DominoTree — Conditional draft-tree scoring](https://learnaivisually.com/ai-explained/dominotree-conditional-draft-tree-scoring): DominoTree scores speculative-decoding draft trees by how each token follows the last — block-diffusion drafts then accept longer runs, up to 6.6× on Qwen3-4B.
- [Proactive memory agent — reminder injection](https://learnaivisually.com/ai-explained/proactive-memory-reminder-injection): A proactive memory agent watches a long-horizon task and re-injects a buried instruction at the right moment, lifting pass@1 without changing the action agent.
- [NVIDIA Audex — unified audio-text token space explained](https://learnaivisually.com/ai-explained/nvidia-audex-unified-audio-text-token-space): Audex is one Transformer decoder that hears and speaks: audio shares the token space of text, so one model does both while keeping its text skills.
- [Predictive prefetching for SSD-backed LLM memory](https://learnaivisually.com/ai-explained/tf-engram-ssd-prefetch): TF-Engram stores phrase memories across GPU-DRAM-SSD and prefetches them, so slow SSD reads overlap decode and recover most of the stall — train-free recall.
- [Markov-chain expert pruning — which MoE experts to cut](https://learnaivisually.com/ai-explained/maestro-moe-markov-chain-expert-pruning): Markov-chain expert pruning (MAESTRO) ranks MoE experts by their long-run routing traffic and prunes the rest — up to 10.61% more quality at 50% compression.
- [Correctness agreement — why quantized LLMs drift behind the same score](https://learnaivisually.com/ai-explained/quantization-behavior-drift-correctness-agreement): A quantized LLM can match the original's accuracy yet still change which answers it gets right — correctness agreement measures that hidden decision drift.
- [Pixel-waypoint action space — RGB-only robot navigation](https://learnaivisually.com/ai-explained/robostral-navigate-pixel-waypoints): Robostral Navigate's pixel-waypoint action space: Mistral's 8B model navigates from one RGB camera by predicting a pixel to move toward. 76.6% on R2R-CE.
- [Benchmark task validity — why SWE-Bench Pro tasks broke](https://learnaivisually.com/ai-explained/swe-bench-pro-task-validity): OpenAI found up to 34.1% of SWE-Bench Pro's coding tasks broken — benchmark task validity means a pass rate only counts if its hidden tests are correct.
- [The fragmentation effect — per-agent monitoring's blind spot](https://learnaivisually.com/ai-explained/fakelab-monitoring-fragmentation): The fragmentation effect: split a malicious goal across a team of AI agents so each trace looks harmless, and per-agent monitoring can miss the attack.
- [Adversarial hallucination squatting — the agent supply-chain attack](https://learnaivisually.com/ai-explained/agentic-botnets-hallucination-squatting): Adversarial hallucination squatting: attackers register the fake names LLMs hallucinate (up to 85% of repos, 100% of skills) and hide promptware there.
- [MCP tool design as context engineering](https://learnaivisually.com/ai-explained/aws-mcp-tool-design-context-engineering): MCP tool design as context engineering, from AWS: tighten schemas, trim responses, lazy-load detail, and at the limit expose one agent-as-tool endpoint.
- [ToolFailBench — the four agent tool-use failure modes](https://learnaivisually.com/ai-explained/toolfailbench-tool-use-failure-taxonomy): ToolFailBench grades how agents use tools, not just the answer: a four-mode failure taxonomy — skip, ignore, fabricate, over-use — plus a Clean Tool-Use Rate.
- [SIS — Selective Importance Sampling](https://learnaivisually.com/ai-explained/sis-selective-importance-sampling): Selective Importance Sampling (arXiv 2607.04728) pins agreeing tokens to a unit importance ratio, reusing off-policy RL rollouts without the variance blow-up.
- [Direct-OPD — weak-to-strong reward transfer](https://learnaivisually.com/ai-explained/direct-opd-log-ratio-reward-transfer): Direct-OPD (arXiv 2607.05394) reuses a weak model's before/after RL log-ratio as a dense per-token reward to lift a stronger model — with no RL on the target.
- [Vera — evidence-grounded agent safety verification](https://learnaivisually.com/ai-explained/vera-evidence-grounded-verification): Vera tests LLM-agent safety by judging the real evidence in a sandbox — files, tool calls, commands — against fixed rules, not the model's self-report.
- [Discrete diffusion — denoiser, score & bridge equivalence](https://learnaivisually.com/ai-explained/discrete-diffusion-denoiser-score-bridge-equivalence): The denoiser, score, and bridge parameterizations of a discrete diffusion language model are provably equivalent coordinates for the same reverse jump rate.
- [LLM-as-a-Verifier — verification as a scaling axis](https://learnaivisually.com/ai-explained/llm-as-verifier-logit-score-scaling-axis): LLM-as-a-Verifier averages a verifier's full distribution over its scoring tokens into a continuous score, ranking agent solutions a single pass/fail can't.
- [CheckRLM — In-chain fact-checking](https://learnaivisually.com/ai-explained/checkrlm-in-chain-fact-checking): In-chain retrieval fact-checking (CheckRLM) checks each claim in a reasoning model's chain of thought against retrieved evidence, patching only the wrong step.
- [LangChain dynamic subagents — code-driven fan-out](https://learnaivisually.com/ai-explained/langchain-dynamic-subagents-code-fanout): Programmatic subagent fan-out: LangChain dynamic subagents let a Deep Agent write a short script that fans out one subagent per chunk, so coverage is code.
- [Omnigent — the agent meta-harness](https://learnaivisually.com/ai-explained/omnigent-meta-harness): The agent meta-harness: Omnigent puts one control layer above Claude Code, Codex, and Cursor, holding credentials, session, policy, and an OS-level sandbox.
- [HaloGuard — Paired counterfactual data](https://learnaivisually.com/ai-explained/haloguard-paired-counterfactual-data): Paired counterfactual safety data: HaloGuard trains a 0.8B safety classifier on matched prompt pairs that flip only intent, so it learns intent, not keywords.
- [LACUNA — Weight-level unlearning eval](https://learnaivisually.com/ai-explained/lacuna-output-vs-weight-unlearning): LACUNA is an LLM unlearning testbed that plants a fact in known weights, testing whether unlearning erases it at the weight level or just hides the output.
- [LOCOS — Logit-Contribution Scoring](https://learnaivisually.com/ai-explained/locos-logit-contribution-scoring): LOCOS uses Logit-Contribution Scoring to find the attention heads that retrieve by meaning, not copied tokens, by scoring what each head writes to the answer.
- [TabFM — Tabular in-context learning](https://learnaivisually.com/ai-explained/tabfm-tabular-in-context-learning): TabFM is Google's zero-shot tabular foundation model: it reads an entire table as one prompt and predicts on unseen spreadsheets via in-context learning.
- [SkillCoach — Self-evolving rubrics](https://learnaivisually.com/ai-explained/skillcoach-self-evolving-rubrics): SkillCoach grades how an LLM agent uses its skills across four axes with a self-evolving rubric — one that patches its own criteria under validation gates.
- [AgenticSTS — the memory contract](https://learnaivisually.com/ai-explained/agenticsts-memory-contract): AgenticSTS reframes agent memory as a bounded contract: each decision is built by typed retrieval into a fresh message, not by appending the raw transcript.
- [kNNGuard — Training-free guardrail](https://learnaivisually.com/ai-explained/knnguard-activation-space-guardrail): A training-free activation-space guardrail: kNNGuard flags unsafe prompts by reading a frozen LLM's hidden activations and kNN-matching a 50-prompt bank.
- [BlockSearch — Attention dilution](https://learnaivisually.com/ai-explained/blocksearch-attention-dilution): Attention dilution is why long-context retrieval collapses: the softmax denominator drowns the gold document. BlockSearch fixes it with a length-aware softmax.
- [QVal — Q-aligned dense supervision](https://learnaivisually.com/ai-explained/qval-q-aligned-supervision): QVal is a training-free testbed scoring whether an agent's dense per-action supervision is Q-aligned — ranking actions like a reference policy's Q-values.
- [CausalMix — CATE-based data mixture selection](https://learnaivisually.com/ai-explained/causalmix-cate-data-mixtures): CausalMix chooses an LLM's pretraining data mixture by causal inference — estimating each mixture's CATE from 512 tiny 0.5B proxy runs, then scaling to 7B.
- [Orca — Next-State-Prediction](https://learnaivisually.com/ai-explained/orca-next-state-prediction): Orca trains one shared world model on Next-State-Prediction, a single state-transition objective, then reads it out as text, image, or embodied action.
- [TRIAGE — role-typed credit assignment](https://learnaivisually.com/ai-explained/triage-role-typed-credit): TRIAGE augments GRPO with a judge that types each action — progress, exploration, no-progress, regression — cutting turns 10.4–14.8% on completed rollouts.
- [SkillHone — persistent decision-history memory](https://learnaivisually.com/ai-explained/skillhone-persistent-decision-history): SkillHone (arXiv 2606.08671) improves an LLM agent's skills across sessions via a persistent decision history it reads — no retraining, +15.8 pts on GAIA.
- [ELDR — expert-locality-aware decode routing](https://learnaivisually.com/ai-explained/eldr-expert-locality-decode-routing): ELDR (expert-locality-aware decode routing) predicts a MoE request's experts and routes decode to the worker whose zone matches, cutting reloads and TPOT 5.9–13.9%.
- [Dockerless — execution-free patch verification](https://learnaivisually.com/ai-explained/dockerless-execution-free-verification): Dockerless (execution-free patch verification) judges a coding agent's patch by exploring the repo and reasoning, no Docker tests — 62.0% on SWE-bench Verified.
- [DOPD — dual on-policy distillation](https://learnaivisually.com/ai-explained/dopd-dual-on-policy-distillation): DOPD (dual on-policy distillation) routes each token's supervision between a privileged teacher and student by advantage, dodging the 'privilege illusion'.
- [BlockPilot — instance-adaptive draft block sizing](https://learnaivisually.com/ai-explained/blockpilot-instance-adaptive-block-size): BlockPilot learns a per-input policy that predicts the draft block size for diffusion speculative decoding, reaching 5.92 acceptance and 4.20× on a 4B model.
- [OSWorld2.0 — long-horizon computer-use failure modes](https://learnaivisually.com/ai-explained/osworld2-0-long-horizon-failure-modes): OSWorld2.0 runs computer-use agents through 108 long real-world tasks scored on the final state — the best finishes just 20.6%, undone by four failure modes.
- [Agents-A1 — Scaling the horizon, not the parameters](https://learnaivisually.com/ai-explained/agents-a1-horizon-scaling): Scaling the horizon means training an agent on long ~45K-token task runs, not more parameters — how Agents-A1's 35B model rivals trillion-param systems.
- [Agentic Abstention — When an Agent Should Stop](https://learnaivisually.com/ai-explained/agentic-abstention-when-to-stop): Agentic abstention is knowing when an agent should stop acting under uncertainty — agents mis-time it, and CONVOLVE adds the judgment without retraining.
- [MultiHashFormer — Hash-signature tokens](https://learnaivisually.com/ai-explained/multihashformer-hash-signature-tokens): MultiHashFormer names each token by a short multi-hash signature instead of a vocab-sized embedding row, so its parameters stop scaling with vocabulary size.
- [Ornith-1.0 — Self-scaffolding RL](https://learnaivisually.com/ai-explained/ornith-1-0-self-scaffolding-rl): Ornith-1.0's open MIT-licensed coding models learn self-scaffolding RL — the model writes its own task-specific training scaffold, then solves against it.
- [Cluster-Route-Escalate — Cost-aware LLM cascade](https://learnaivisually.com/ai-explained/cluster-route-escalate-cost-cascade): Cluster, Route, Escalate is a cost-aware LLM cascade — route each query to the cheapest capable model and escalate only weak answers to a stronger model.
- [SGLang v0.5.14 — LPLB load balancing](https://learnaivisually.com/ai-explained/sglang-v0-5-14-lplb-load-balancing): SGLang v0.5.14's LPLB load balancer solves a linear program each step to balance MoE expert load across GPUs, lifting DeepSeek-V4 serving throughput 5x.
- [InfoKV — Forward Influence](https://learnaivisually.com/ai-explained/infokv-entropy-aware-kv-compression): InfoKV is entropy-aware KV-cache compression: it keeps tokens by predictive uncertainty, not attention alone, so long-context recall survives a smaller cache.
- [ViQ — Text-aligned quantized visual tokens](https://learnaivisually.com/ai-explained/viq-text-aligned-visual-tokens): ViQ (Tencent Hunyuan) turns images into discrete, text-aligned visual tokens from a fixed codebook, so an LLM reads pictures like words at any resolution.
- [The Verification Horizon — co-evolving verifiers vs static reward](https://learnaivisually.com/ai-explained/verification-horizon-co-evolving-verifier): The Verification Horizon paper argues a fixed reward saturates and gets hacked as a coding agent improves — so the verifier must co-evolve with the generator.
- [Co-failure ceiling — routing, voting & mixture-of-agents](https://learnaivisually.com/ai-explained/co-failure-ceiling-routing-voting): The co-failure ceiling: when every model misses the same query, no routing, voting, or mixture-of-agents recovers it — a 67-model hard limit on ensembling.
- [AOHP — Agents as first-class OS actors](https://learnaivisually.com/ai-explained/aohp-agents-as-os-actors): AOHP makes AI agents first-class OS actors on Android, acting across apps via clean machine interfaces with secure data flow: +21% tasks, -52% tokens.
- [RL data scheduler — learned data mixture](https://learnaivisually.com/ai-explained/rl-data-scheduler-learned-mixture): An RL agent (Soft Actor-Critic) tunes an LLM's pretraining data mixture each step instead of a fixed blend, hitting target perplexity with 44% fewer steps.
- [NatureBench — Discovery vs Reproduction](https://learnaivisually.com/ai-explained/naturebench-discovery-vs-reproduction): NatureBench scores coding agents on beating published SOTA across 90 Nature-paper tasks, not reproducing it — the best agent wins on only 17.8% of them.
- [Qwen-AgentWorld — World-model RL simulator](https://learnaivisually.com/ai-explained/qwen-agentworld-world-model-simulator): Qwen-AgentWorld trains a language model to predict an environment's next state, so it stands in as a fast, parallel simulator for training RL agents at scale.
- [OpenThoughts-Agent — Task-source Diversity](https://learnaivisually.com/ai-explained/openthoughts-agent-task-source-diversity): OpenThoughts-Agent's open 100,000-example recipe shows task-source diversity, not raw data volume, drives agent capability: 44.8% across 7 agentic benchmarks.
- [DeLS-Spec — Long-short logit fusion](https://learnaivisually.com/ai-explained/dels-spec-long-short-fusion): DeLS-Spec fuses a short-context local head into a block-parallel drafter (DFlash), adding the intra-block signal it lacked so the target accepts more of each block.
- [JetSpec — Parallel tree drafting](https://learnaivisually.com/ai-explained/jetspec-parallel-tree-drafting): JetSpec drafts a tree of candidate tokens in one pass, not a single line, so a bigger draft budget becomes longer accepted runs — up to 9.64× faster decode.
- [Jalapeño — Inference ASIC vs GPU](https://learnaivisually.com/ai-explained/jalapeno-inference-asic-vs-gpu): OpenAI and Broadcom's Jalapeño is a custom LLM-inference ASIC: a compute chiplet beside HBM, trading a GPU's flexibility for early performance-per-watt gains.
- [Agentic CLEAR — system/trace/node eval granularity](https://learnaivisually.com/ai-explained/agentic-clear-system-trace-node-evals): IBM's Agentic CLEAR reads the observability traces your agent already logs and writes an LLM-judge diagnosis at three zoom levels: node, trace, and system.
- [WorldKV — Evict-and-reinsert KV memory](https://learnaivisually.com/ai-explained/worldkv-evict-reinsert-kv): WorldKV is a training-free KV cache for video world models: it evicts KV chunks to camera-indexed storage and reinserts them on revisit, at ~2x throughput.
- [ROBIN — Head-level bias subspace removal](https://learnaivisually.com/ai-explained/robin-head-level-bias-subspace-removal): ROBIN is a training-free method that localizes bias to specific transformer attention heads and removes a small bias subspace from their output at inference.
- [ConSA — controllable attention sparsity](https://learnaivisually.com/ai-explained/consa-controllable-attention-sparsity): ConSA learns, under a sparsity budget you set, which attention heads use full attention and which use a cheap sliding window — beating hand-coded hybrid rules.
- [Ternary Mamba — ternary quantization-aware training explained](https://learnaivisually.com/ai-explained/ternary-mamba-quantization-aware-training): Ternary Mamba forces every weight to -1, 0, or +1 and trains on that grid (QAT) with an FP16 teacher, shrinking a Mamba-2 SSM 3.6x to 744 MB in 4 GPU-hours.
- [AtomMem — atomic-fact agent memory](https://learnaivisually.com/ai-explained/atommem-atomic-fact-memory): AtomMem distills an LLM agent's long history into atomic facts, files them by event and time, and links them in an associative graph for retrieval — SOTA on LoCoMo.
- [Grouped Query Experts — Query-head expert routing](https://learnaivisually.com/ai-explained/grouped-query-experts-moe-query-heads): Grouped Query Experts (GQE) routes a token to only a few of attention's query heads, keeping every key-value head dense so the KV cache stays the same size.
- [Baidu Unlimited OCR — Reference Sliding Window Attention](https://learnaivisually.com/ai-explained/baidu-unlimited-ocr-rswa-constant-kv): Baidu's Unlimited OCR uses R-SWA: each token reads the full document plus the last 128 output tokens, so the KV cache stays constant across 40+ pages.
- [MiniMax-M2 — Forge RL prefix-tree merging](https://learnaivisually.com/ai-explained/minimax-m2-forge-rl-prefix-tree): MiniMax-M2's Forge RL merges multi-turn RL rollouts that share an opening into a prefix tree, computing the shared prefix once for a 40× training speedup.
- [ContextRL — contrastive context-selection RL](https://learnaivisually.com/ai-explained/contextrl-contrastive-context-selection): ContextRL adds a contrastive RL reward for picking which of two near-identical contexts supports the answer — sharpening fine-grained evidence grounding.
- [GateMem — the memory governance trilemma](https://learnaivisually.com/ai-explained/gatemem-governance-trilemma): GateMem benchmarks memory governance in multi-principal shared-memory agents — utility, access control, reliable forgetting — finding no method achieves all three.
- [Multi-LCB — Cross-language generalization gap](https://learnaivisually.com/ai-explained/multi-lcb-cross-language-generalization-gap): Multi-LCB ports each LiveCodeBench task into 12 languages under one judge, exposing the cross-language generalization gap that Python-only scores hide.
- [S-Agent — spatio-temporal evidence accumulation](https://learnaivisually.com/ai-explained/s-agent-spatio-temporal-evidence-accumulation): S-Agent's spatio-temporal evidence accumulation makes a VLM a planner that directs tools to build one shared 3-D model — an 8B agent then rivals GPT-5.4.
- [GLM-5.2 — Active vs total parameters](https://learnaivisually.com/ai-explained/glm-5-2-active-vs-total-parameters): GLM-5.2 lists 744B total but only ~40B active parameters. Here's what the two numbers mean: total sets the memory footprint, active sets per-token compute.
- [Taylor-Calibrate — Taylor-guided gate initialization](https://learnaivisually.com/ai-explained/taylor-calibrate-gate-init-linear-attention): Taylor-Calibrate presets a Gated DeltaNet student's gates from a softmax teacher's attention — converting to hybrid linear attention with 4.9–9.2× fewer tokens.
- [FAPO — failure-attribution-gated prompt optimization](https://learnaivisually.com/ai-explained/fapo-failure-attribution-gated-optimization): FAPO has Claude Code diagnose which stage of a multi-step LLM pipeline fails, then make scoped prompt or chain edits — beating the GEPA baseline in 15 of 18 comparisons.
- [E2M1 shrinkage bias — why FP4 rounding drifts toward zero](https://learnaivisually.com/ai-explained/ufp4-e2m1-shrinkage-bias): E2M1's 4-bit bins are asymmetric, so rounding drifts values toward zero — a shrinkage bias. UFP4 fixes it with a Hadamard transform + stochastic rounding.
- [Predictive validity — why agent leaderboards mislead](https://learnaivisually.com/ai-explained/agent-leaderboards-predictive-validity): IBM shows aggregate-score agent leaderboards don't transfer out-of-distribution; measure predictive validity instead — the in-sample vs OOD rank correlation.
- [HydraHead — head-axis attention hybridization](https://learnaivisually.com/ai-explained/hydrahead-per-head-attention-hybrid): Head-axis attention hybridization mixes full and linear attention per head, not per layer — exact attention only on retrieval-critical heads, at a 7:1 ratio.
- [CacheWeaver — reordering RAG evidence for prefix-cache reuse](https://learnaivisually.com/ai-explained/cacheweaver-prefix-cache-evidence-reordering): CacheWeaver reorders retrieved RAG evidence so the KV prefix cache is reused, cutting median time-to-first-token 20–33% — with no measured quality loss.
- [Strong scaling — why 8,192 GPUs don't train 8,192× faster](https://learnaivisually.com/ai-explained/blackwell-mlperf-6-0-strong-scaling): Strong scaling explains why 2× the GPUs rarely halves training time. Blackwell swept MLPerf Training 6.0 — 8,192 GPUs trained DeepSeek-V3 671B in 2.02 min.
- [LoopCoder-v2 — Weight-tied block looping](https://learnaivisually.com/ai-explained/loopcoder-v2-weight-tied-block-looping): LoopCoder-v2 reuses one transformer block in a loop to add depth without parameters: two loops lift a 7B model 43.0 to 64.4 on SWE-bench, three or more regress.
- [Prefill/decode disaggregation (AMD ATOM + ATOMesh)](https://learnaivisually.com/ai-explained/amd-atom-prefill-decode-disaggregation): AMD's ATOM + ATOMesh bring prefill/decode disaggregation to ROCm: split LLM inference's compute-bound prefill from memory-bound decode onto separate GPU pools.
- [AnchorKV — safety-aware KV-cache compression](https://learnaivisually.com/ai-explained/anchorkv-safety-aware-kv-compression): AnchorKV makes KV-cache compression safety-aware: a refusal anchor in key space adds a soft penalty to eviction, keeping a model aligned under compression.
- [PreAct — compiled trajectory replay](https://learnaivisually.com/ai-explained/preact-compiled-trajectory-replay): PreAct compiles a computer-using agent's successful run into a replayable program, re-run with no per-step model call — 8.5–13× faster on repeated tasks.
- [SoftMoE — differentiable soft top-k routing](https://learnaivisually.com/ai-explained/softmoe-differentiable-routing): SoftMoE replaces a Mixture-of-Experts model's hard top-k router with a differentiable soft top-k (LapSum), so routing trains directly from the task loss.
- [Variable-width transformers — hourglass layer width](https://learnaivisually.com/ai-explained/variable-width-transformers-hourglass): Variable-width transformers give the stack an hourglass shape — wide outer layers, a narrow middle — cutting 22% of FLOPs and 15% of KV-cache at matched loss.
- [SubQ 1.1 — subquadratic sparse attention](https://learnaivisually.com/ai-explained/subq-1-1-subquadratic-sparse-attention): Subquadratic sparse attention scales near-linearly, not with n² — how SubQ 1.1 Small reaches a 12M-token context and runs 56× faster than FlashAttention-2.
- [VibeThinker-3B — diversity-driven RL](https://learnaivisually.com/ai-explained/vibethinker-3b-diversity-driven-rl): Diversity-driven RL keeps a model's solution strategies wide instead of collapsing onto a few — how VibeThinker-3B reaches 94.3 on AIME 2026 at 3B params.
- [FastContext — explorer-subagent context offloading](https://learnaivisually.com/ai-explained/fastcontext-explorer-subagent-offloading): FastContext offloads code search to a read-only explorer subagent that returns file-line citations, cutting a coding agent's token use up to 60% per task.
- [AdaSR — streaming reasoning](https://learnaivisually.com/ai-explained/adasr-streaming-reasoning): AdaSR's streaming reasoning lets an LLM reason while input still streams in, then deliberate once it lands — trained with HRPO and a latency-aware reward.
- [CacheRL — cached rollouts for agent RL](https://learnaivisually.com/ai-explained/cacherl-cached-rollouts-agent-rl): CacheRL trains tool-calling agents with RL by serving tool results from a three-tier fuzzy cache — 92% process accuracy vs GPT-5's 94% at ~100× less compute.
- [OPID — On-Policy Skill Distillation](https://learnaivisually.com/ai-explained/opid-on-policy-skill-distillation): OPID (On-Policy Skill Distillation) mines episode- and step-level skills from an agent's own completed runs to add dense guidance to sparse-reward agentic RL.
- [SIMMER — latent failures in LLM planning](https://learnaivisually.com/ai-explained/simmer-latent-failures-planning): SIMMER measures latent failures in LLM planning — plan steps that run without erroring yet silently fail the goal. Up to 56% of frontier plans hide one.
- [Fused INT8 GEMM kernel — INT8 that actually hits the tensor cores](https://learnaivisually.com/ai-explained/fused-int8-gemm-tensor-cores): A fused Triton INT8 GEMM kernel runs W8A8 matmuls on the tensor cores with a fused dequant epilogue, so INT8 finally beats FP8 and NF4 on a consumer GPU.
- [AgentPerf — trajectory-replay benchmarking for agent infra](https://learnaivisually.com/ai-explained/agentperf-trajectory-replay-benchmarking): AgentPerf replays recorded multi-step agent runs, not single prompts, to grade serving systems — scoring concurrent agents under an SLO as agents per megawatt.
- [LedgerAgent — pre-tool-call policy validation](https://learnaivisually.com/ai-explained/ledgeragent-state-ledger-policy-validation): LedgerAgent tracks a tool-calling agent's state in a separate ledger and checks domain policy against it before any irreversible tool call, blocking violations.
- [HarnessBridge — learned agent harness](https://learnaivisually.com/ai-explained/harnessbridge-learned-agent-harness): HarnessBridge makes the agent harness a learnable module — two bidirectional projections that distill raw trajectories into compact state and vet each action.
- [EvoMem — patch-based agent memory](https://learnaivisually.com/ai-explained/evomem-patch-based-agent-memory): EvoMem stores agent memory as a changelog of patches — what changed and when — so an agent reasons about how its world evolved, not just its current state.
- [EfficientRollout — Quantized self-drafters](https://learnaivisually.com/ai-explained/efficientrollout-quantized-self-drafters): EfficientRollout speeds RL rollouts with self-speculative decoding — the drafter is a quantized copy of the model itself, so it tracks the evolving policy.
- [VIA-SD — Tiered confidence-gated verification](https://learnaivisually.com/ai-explained/via-sd-tiered-speculative-verification): VIA-SD adds a confidence-gated middle tier to speculative decoding: near-misses go to a slim sub-network of the same model, not a full re-run — 10–20% faster.
- [Claude Fable 5 — Safety-routing fallback classifiers](https://learnaivisually.com/ai-explained/claude-fable-5-safety-routing-fallback): Claude Fable 5 ships a frontier model to everyone by routing under 5% of sensitive requests to a more careful model, Opus 4.8, instead of weakening it.
- [SpatialClaw — code-as-action vs structured tool-calls](https://learnaivisually.com/ai-explained/spatialclaw-code-as-action): SpatialClaw gives a VLM agent a code-as-action interface — one Python cell per step on a stateful kernel. Observe-then-act beats rigid tool-calls, +11.2 pts.
- [WeaveBench — trajectory-aware vs outcome-only agent grading](https://learnaivisually.com/ai-explained/weavebench-trajectory-aware-grading): WeaveBench's 114 computer-use tasks expose a grading gap: outcome-only scoring overestimates agents — a trajectory-aware judge catches their shortcut behaviors.
- [Symbolic vs neural environment synthesis](https://learnaivisually.com/ai-explained/agent-env-survey-symbolic-vs-neural-synthesis): A 2026 survey maps building an AI agent's training world as engineering — its core split: symbolic (hand-coded) vs neural (model-generated) environments.
- [CodeSpear — the grammar-constrained decoding jailbreak](https://learnaivisually.com/ai-explained/codespear-constrained-decoding-jailbreak): CodeSpear abuses grammar-constrained decoding: enforce a code grammar and an LLM's natural-language refusal becomes invalid, lifting attack success to ~82%.
- [Manifold Power Iteration — router-to-expert alignment for MoE](https://learnaivisually.com/ai-explained/manifold-power-iteration-router-alignment): Manifold Power Iteration (MPI) aligns each MoE router row with its expert's top singular direction — sharper routing at ~0.2% train cost, zero inference cost.
- [Workflow-GYM — end-to-end GUI workflow completion](https://learnaivisually.com/ai-explained/workflow-gym-end-to-end-completion): Workflow-GYM, ByteDance Seed's benchmark for computer-use agents, grades multi-stage GUI workflows end to end — top models clear only ~30% as errors compound.
- [Role-Agent — one LLM as agent and environment](https://learnaivisually.com/ai-explained/role-agent-dual-role-self-play): Role-Agent trains an LLM agent with one model as both agent and environment — prediction-agreement is a dense process reward, no reward model, for a >4% gain.
- [DRPO — a smooth trust-region penalty for LLM RL](https://learnaivisually.com/ai-explained/drpo-smooth-trust-region-penalty): DRPO swaps LLM RL's hard trust-region mask for a smooth, advantage-weighted penalty, so a diverging token gets a bounded corrective gradient instead of zero.
- [SearchSwarm — distilling delegation into the weights](https://learnaivisually.com/ai-explained/searchswarm-distilled-delegation): SearchSwarm trains a 30B-A3B agent to decompose and delegate web research — baking delegation into the weights with SFT, not prompts, to top BrowseComp.
- [QK-Restore — fixing attention amnesia explained](https://learnaivisually.com/ai-explained/attention-amnesia-qk-restore): QK-Restore is a training-free fix for attention amnesia: chain-of-thought fine-tuning collapses long-range recall in hybrid LLMs, and Q/K rollback recovers it.
- [DiffusionGemma — parallel block decoding explained](https://learnaivisually.com/ai-explained/diffusion-gemma-parallel-block-decoding): DiffusionGemma generates text by parallel block decoding — refining a 256-token block at once via iterative denoising, up to 4x faster than autoregressive.
- [Reasoning Arena — Bradley-Terry trace ranking](https://learnaivisually.com/ai-explained/reasoning-arena-bradley-terry-trace-ranking): Reasoning Arena fixes RLVR reward ties: a judge ranks tied reasoning traces in a pairwise tournament and a Bradley-Terry model turns those games into a reward.
- [Chiaroscuro Attention — Spectral-entropy token routing](https://learnaivisually.com/ai-explained/chiaroscuro-spectral-entropy-routing): Chiaroscuro's CHIAR-Former scores each token's spectral entropy and routes most tokens to a cheap DCT mixer, paying full self-attention only for the few.
- [Latent Context LMs — Encoder-decoder prompt compression](https://learnaivisually.com/ai-explained/latent-context-lms-encoder-decoder-compression): Latent Context LMs use a small 0.6B encoder to compress a long prompt into a 16x shorter sequence of latent embeddings a 4B decoder reads directly as tokens.
- [ThriftAttention — top-5% FP16, rest FP4 mixed-precision attention](https://learnaivisually.com/ai-explained/thriftattention-importance-aware-fp4): ThriftAttention runs the top ~5% of QK attention blocks in FP16 and the rest in FP4, reportedly recovering 89.1% of the FP4→FP16 long-context quality gap on Blackwell tensor cores.
- [Pre-training distillation has a non-monotonic teacher-strength curve](https://learnaivisually.com/ai-explained/non-monotonic-pretrain-distillation): A new pre-training distillation sweep shows the relationship between teacher strength and student gain is non-monotonic — small undertrained teachers help large students, and gains land out-of-domain.
- [Capability vs behavior skill tracks — one expert trace, any host](https://learnaivisually.com/ai-explained/colleague-skill-capability-vs-behavioral-track): COLLEAGUE.SKILL distills an expert trace into a versioned skill package, splitting a capability track (what to do) from a bounded behavior track (how to do it).
- [Gemma 4 12B — encoder-free multimodal projection explained](https://learnaivisually.com/ai-explained/gemma-4-12b-encoder-free-multimodal): Gemma 4 12B drops the separate vision and audio encoders — it projects image patches into the token space with one matrix multiply and folds audio in, no ViT.
- [SigmaScale — learned SVD scaling for low-rank compression](https://learnaivisually.com/ai-explained/sigmascale-learned-svd-scaling): SigmaScale learns the scaling matrices for truncated-SVD weight compression under an activation-aware loss — shrinking LLM weights by rank, not bit-width.
- [EmbedFilter — feature lens for text embeddings](https://learnaivisually.com/ai-explained/embedfilter-unembedding-matrix-feature-lens): EmbedFilter projects a high-frequency-token subspace out of an LLM's unembedding matrix in one linear transform for sharper text embeddings, no retraining.
- [FlashMemory — Lookahead Sparse Attention (LSA)](https://learnaivisually.com/ai-explained/flashmemory-lookahead-sparse-attention): FlashMemory's Lookahead Sparse Attention (LSA) keeps only the KV-cache chunks a token needs via a learned indexer, cutting DeepSeek-V4's cache to 13.5%.
- [Keye-VL-2.0 — DeepSeek Sparse Attention for video](https://learnaivisually.com/ai-explained/keye-vl-2-0-deepseek-sparse-attention-video): Keye-VL-2.0 is a 30B MoE (3B active) vision-language model that ports DeepSeek Sparse Attention to video: a lightning indexer keeps a lossless 256K context.
- [MiniMax M3 — Sparse Attention (MSA)](https://learnaivisually.com/ai-explained/minimax-m3-msa-block-sparse-attention): MiniMax M3 is an open-weight 1M-context model built on MiniMax Sparse Attention (MSA): block-sparse KV gather that cuts per-token compute ~20x at 1M tokens.
- [MLEvolve — Monte Carlo Graph Search](https://learnaivisually.com/ai-explained/mlevolve-monte-carlo-graph-search): MLEvolve's Monte Carlo Graph Search shares sub-results across search branches and schedules explore-then-exploit, reaching SOTA on MLE-Bench in half the budget.
- [Self-evolving agents — experience internalization](https://learnaivisually.com/ai-explained/self-evolving-agents-experience-internalization): Self-evolving agents can get worse as they learn from their own runs — a new paper finds three design choices that decide collapse vs sustained improvement.
- [AdaPlanBench — adaptive replanning under hidden constraints](https://learnaivisually.com/ai-explained/adaplanbench-replanning-hidden-constraints): AdaPlanBench hides each task's rules until a plan violates one, testing adaptive replanning — the best of 10 LLMs scores just 67.75%, and user constraints are harder than world constraints.
- [Code2LoRA — hypernetwork-generated LoRA adapters](https://learnaivisually.com/ai-explained/code2lora-hypernetwork-repo-adapters): Code2LoRA's hypernetwork generates a repository-specific LoRA adapter for a code model — deep repo knowledge with zero extra prompt tokens at inference time.
- [Gated DeltaNet MatMul-only triangular inverse explained](https://learnaivisually.com/ai-explained/gated-deltanet-matmul-inverse): Gated DeltaNet's chunk solve hides a sequential matrix inverse; a truncated Neumann series turns it into parallel MatMuls — about 5x faster and INT4-ready.
- [Tangram per-head KV cache budgets explained](https://learnaivisually.com/ai-explained/tangram-per-head-kv-budgets): Tangram gives each attention head a KV-cache budget sized to its retention pattern instead of one uniform budget — up to 2.6× multi-turn serving throughput.
- [Gemma 4 QAT — quantization-aware training explained](https://learnaivisually.com/ai-explained/gemma-4-qat): Gemma 4 ships quantization-aware-trained 4-bit checkpoints — QAT simulates low-bit rounding during training so the weights learn to land on the grid directly.
- [AutoLab — iterative experiment-loop agent evaluation](https://learnaivisually.com/ai-explained/autolab-experiment-loop-eval): AutoLab scores agents on long-horizon R&D tasks via iterative experiment-loop evaluation — across 17 models, sustained iteration beat first-answer quality.
- [TELBench / DRIFT — span-level error localization for agents](https://learnaivisually.com/ai-explained/telbench-span-level-error-localization): TELBench and DRIFT bring span-level error localization to deep-research agents — pinpointing the first-error step in a trajectory, up to +30 pp over baselines.
- [Token Budgets — affine-typed budget ownership explained](https://learnaivisually.com/ai-explained/token-budgets-affine-typed-budget-ownership): Token Budgets models an agent's token cap as an affine, use-at-most-once resource, so a multi-agent budget overrun fails to compile instead of overspending.
- [StreamMA — streaming inter-agent reasoning explained](https://learnaivisually.com/ai-explained/streamma-streaming-inter-agent-reasoning): StreamMA streams each reasoning step between agents instead of a finished answer, so a downstream agent leans on reliable early steps. +7.3pp average accuracy.
- [MAI-Code-1-Flash — adaptive solution-length control explained](https://learnaivisually.com/ai-explained/mai-code-1-flash-adaptive-solution-length): Microsoft's MAI-Code-1-Flash uses adaptive solution-length control to scale reasoning tokens to task difficulty, hitting its scores at up to 60% fewer tokens.
- [RTX Spark — unified CPU–GPU memory explained](https://learnaivisually.com/ai-explained/rtx-spark-unified-memory): RTX Spark pairs a Grace CPU and Blackwell GPU on one 128GB pool over NVLink-C2C, so the GPU skips the PCIe host–device copy — unified coherent memory explained.
- [KVarN — Hadamard-rotated 2-bit KV cache](https://learnaivisually.com/ai-explained/kvarn-hadamard-2bit-kv-cache): KVarN squeezes the KV cache to 2 bits with a Hadamard rotation that scatters outlier channels first — calibration-free, and the error stays small across decode.
- [dMoE — block-level expert routing for diffusion MoE](https://learnaivisually.com/ai-explained/dmoe-block-level-expert-routing): dMoE pools a diffusion LLM's per-token expert routing into one block-level decision — unique active experts drop 69.5→14.6 and expert-weight memory falls ~77–80%.
- [Crafter — directive critic + typed-edit harness](https://learnaivisually.com/ai-explained/crafter-directive-critic-harness): Crafter's five-agent harness uses a directive critic — per-dimension fixes applied as typed edits, not a scalar score — to lift figure quality 33.73 → 50.34.
- [Harness-1 — externalizing search state into the harness](https://learnaivisually.com/ai-explained/harness-1-externalized-state): Harness-1 is a 20B RL-trained search agent that externalizes working memory into a harness, not a growing transcript — 0.730 curated recall across 8 benchmarks.
- [PEFT scaling — a million adapters on one frozen base](https://learnaivisually.com/ai-explained/peft-scaling-persistent-personal-adapters): PEFT scaling reframes a LoRA adapter as persistent per-user state — ~1,000,000 personal adapters served over one frozen ~1T base, with identity and residency.
- [Rubric reward — per-hop process supervision vs RLVR](https://learnaivisually.com/ai-explained/longtracerl-rubric-process-reward): LongTraceRL's rubric reward gives long-context reasoning a per-hop process-supervision signal, gated to correct rollouts so it cannot be reward-hacked.
- [MarginGate batch-invariant decoding](https://learnaivisually.com/ai-explained/margingate-batch-invariant-decoding): MarginGate makes temperature-0 BF16 decoding batch-invariant by re-checking only the sparse low-margin steps in FP32 — ~2x lower verification overhead.
- [Parallax local-linear attention vs FlashAttention](https://learnaivisually.com/ai-explained/parallax-local-linear-attention): Parallax upgrades softmax attention from a local-constant average to a local-linear slope fit, raising arithmetic intensity past FlashAttention 2/3 on decode.
- [AgentDoG 1.5 — inline guard models for agents explained](https://learnaivisually.com/ai-explained/agentdog-1-5-inline-guard-models): AgentDoG 1.5 trains 0.8–8B inline guard models that screen each agent action — reportedly matching closed safety models at ~100× less deploy overhead.
- [OmniRetrieval source-native query dispatch](https://learnaivisually.com/ai-explained/omniretrieval-source-native-dispatch): OmniRetrieval routes each query to text, tables, or graphs and runs source-native queries, so JOINs and graph edges survive instead of one flat vector index.
- [Opus 4.8 cache-preserving system messages explained](https://learnaivisually.com/ai-explained/opus-4-8-cache-preserving-system-messages): Claude Opus 4.8 can inject a system message mid-conversation without breaking the prompt cache, so the cached prefix is reused instead of recomputed downstream.
- [Opus 4.8 parallel-subagent dynamic workflows explained](https://learnaivisually.com/ai-explained/opus-4-8-parallel-subagent-workflows): Claude Opus 4.8 'dynamic workflows' let Claude Code fan out parallel subagents, so independent subtasks run at once and wall-clock is the slowest, not the sum.
- [Parametric Memory Law — verbatim recall threshold explained](https://learnaivisually.com/ai-explained/parametric-memory-law-verbatim-recall): The Parametric Memory Law uses LoRA as a probe: memorization scales as a power law, and a token is recalled verbatim once its greedy probability passes 0.5.
- [LongLive-2.0 — NVFP4 W4A4 across training and inference](https://learnaivisually.com/ai-explained/longlive-2-0-nvfp4-w4a4-training-inference): LongLive-2.0 is the first NVFP4 training+inference stack: W4A4 matmul and 4-bit KV cache deliver 2.15× training, 1.84× inference, and 45.7 FPS on 5B video.
- [ZEDA — Zero-output expert self-distillation for MoE pruning](https://learnaivisually.com/ai-explained/zeda-zero-output-expert-distill): ZEDA injects parameter-free zero-output experts into a finished MoE and uses two-stage self-distillation to skip ~50% of expert FLOPs at marginal accuracy loss.
- [MSR delegation — Cascading fidelity loss over 20 iterations](https://learnaivisually.com/ai-explained/msr-delegation-fidelity-drift): Microsoft Research clarifies its 20-iteration delegation stress test — strong frontier LLMs lose ~19–34% artifact fidelity over 20 delegated document edits.
- [vLLM v0.20 — FlashAttention 4 packing](https://learnaivisually.com/ai-explained/vllm-v0-20-fa4-packing): vLLM v0.20 ships FlashAttention 4 with packed variable-length attention — one fused kernel handles a whole batch of mixed-length sequences with no padding waste.
- [vLLM v0.20 — TurboQuant 2-bit KV cache](https://learnaivisually.com/ai-explained/vllm-v0-20-turboquant-kv): vLLM v0.20 ships TurboQuant — a 2-bit KV cache with per-block asymmetric scales — cutting KV cache memory roughly 4× without crushing outlier values.
- [DeepSeek V4 — long-context cost](https://learnaivisually.com/ai-explained/deepseek-v4-long-context-cost): V4-Pro and V4-Flash drop both per-token FLOPs and KV cache to ~7-27% of V3.2 at 1M context — same cluster, ~10-14× more concurrent users, paired drop.
- [RLVR — Reinforcement Learning with Verifiable Rewards](https://learnaivisually.com/ai-explained/copd-rlvr): RLVR is post-training where a deterministic verifier — unit tests, equality checks, proof assistant — replaces the learned reward model in the CoPD loop.
- [CoPD — co-evolving policy distillation](https://learnaivisually.com/ai-explained/copd-co-evolving-policy-distillation): CoPD trains N specialist LLMs in parallel as mutual on-policy teachers, fixing inter-capability divergence in mixed RLVR and behavioural-gap loss in frozen-OPD.
- [GLM-5V-Turbo — native multimodal vs vision-bolted designs](https://learnaivisually.com/ai-explained/glm-5v-native-multimodal): GLM-5V-Turbo trains text + vision + tool data jointly from step 1, vs the LLaVA-style default that bolts a frozen ViT onto a text-only LLM. Why it matters for agentic tool use.
- [IBM Granite 4.1 — 8B dense vs 32B MoE](https://learnaivisually.com/ai-explained/ibm-granite-4-1-dense-vs-moe): IBM Granite 4.1 8B dense matches the prior Granite 4.0 32B-A9B MoE on tool calling and instruction following — same per-token bandwidth, one quarter the HBM footprint.
- [Nemotron 3 Nano Omni — 30B-A3B multimodal MoE](https://learnaivisually.com/ai-explained/nvidia-nemotron-3-multimodal-moe): NVIDIA Nemotron 3 Nano Omni routes text, image, audio, and video through one shared expert pool — 30B in HBM, ~3B active per token, ~9× higher decode throughput.
- [AsyncFC — Symbolic futures in the decode stream](https://learnaivisually.com/ai-explained/asyncfc-symbolic-futures): AsyncFC inserts a typed symbolic future placeholder when an LLM emits a tool call, so the decoder keeps generating while tool execution runs in parallel.
- [MCP 2026-07-28 RC — stateless transport](https://learnaivisually.com/ai-explained/mcp-2026-07-28-stateless-transport): MCP's 2026-07-28 RC reworks transport so every tools/call carries its own routing data. Any server in the fleet can serve any request — no sticky session pin.
- [MCP SEP-2663 — async task handles](https://learnaivisually.com/ai-explained/mcp-sep-2663-async-task-handles): MCP SEP-2663 makes tools/call polymorphic: a server returns a Task handle the client drives with tasks/get, tasks/update, and tasks/cancel — no blocking.
- [MCP SEP-2577 — three deprecations and the lifecycle](https://learnaivisually.com/ai-explained/mcp-sep-2577-feature-deprecation): MCP SEP-2577 deprecates Roots, Sampling, and Logging and introduces a Deprecated lifecycle: features stay supported in every spec released within one year, then Removed.
- [PPOW — window-level RL for speculative drafters](https://learnaivisually.com/ai-explained/ppow-window-level-rl-drafters): PPOW trains speculative drafters with window-level RL: three rewards adapt windows by KL, reaching 6.29-6.52 acceptance length and reported 3.4-4.4x speedups.
- [SOP — Hardware-aware per-layer PTQ at FP6](https://learnaivisually.com/ai-explained/sop-ptq-fp6-beats-fp8): SOP searches per-layer codebooks with activation weighting; at FP6 it beats fixed FP8 reconstruction across six open model families using 1.5 fewer bits.
- [Grep vs vector retrieval for agentic search](https://learnaivisually.com/ai-explained/grep-vs-vector-agentic-retrieval): Empirical study on 116 LongMemEval questions: literal grep generally beats vector retrieval inside agents; harness design dominates the algorithm choice.
- [GrepSeek — training a shell-command search agent](https://learnaivisually.com/ai-explained/grepseek-grpo-shell-command-search): GrepSeek trains an agent to search a corpus with shell commands — a Tutor/Planner distillation then GRPO — reporting strongest F1/EM on 7 open-domain QA sets.
- [WASH — washing out text watermarks by averaging models](https://learnaivisually.com/ai-explained/wash-model-averaging-watermark-removal): WASH removes LLM text watermarks by averaging 3–5 independent models: their green-lists cancel, so detection z-scores fall from 5–300 to below 2 (threshold 4).
- [FutureSim — Harness-level agent eval vs single-shot QA](https://learnaivisually.com/ai-explained/futuresim-harness-level-eval): Max Planck's FutureSim replays 3 months of news article-by-article and grades agents end-to-end: best agent ~25%; many fall below no-prediction baseline.
- [CDD — Context-Driven Decomposition for RAG knowledge conflict](https://learnaivisually.com/ai-explained/cdd-context-driven-decomposition): Standard RAG hits 15% under misconception injection; Context-Driven Decomposition extracts retrieval + parametric claims, resolves the conflict, reaches 71.3%.
- [TFGN — Subspace-preserving updates for continual pre-training](https://learnaivisually.com/ai-explained/tfgn-subspace-preserving-updates): TFGN continual pre-trains LLaMA 3.1 8B without replay or task IDs — Read/Write decomposition projects each update into a subspace orthogonal to prior knowledge.
- [HuggingFace — Async continuous batching](https://learnaivisually.com/ai-explained/hf-async-continuous-batching): Async continuous batching overlaps CPU batch prep with GPU compute via CUDA streams, lifting HuggingFace's reported GPU-active time from 76.0% to 99.4%.
- [Compute Where It Counts — Per-token compute controller](https://learnaivisually.com/ai-explained/compute-where-it-counts-per-token-compute): ICML'26 paper: a policy network over a frozen LLM picks per-token attention sparsity, MLP pruning, or precision bits — cuts FLOPs on long, easy contexts.
- [PreFT — Prefill-only LoRA adapters](https://learnaivisually.com/ai-explained/preft-prefill-only-adapters): Stanford PreFT runs LoRA only during prefill and drops it at decode — the signal lives in the KV cache, lifting multi-LoRA throughput 1.9× on 512 adapters.
- [SP-KV — Self-pruned KV cache](https://learnaivisually.com/ai-explained/sp-kv-self-pruned-kv-cache): Meta FAIR's SP-KV trains a utility predictor that writes only high-value KV pairs to cache — 3-10× smaller KV cache with little-to-no validation-loss drop.
- [AOIAYN — Persistent session KV cache](https://learnaivisually.com/ai-explained/aoiayn-stateful-prefix): AOIAYN persists session KV cache as data arrives — prefill leaves the critical path and per-query latency stays constant in accumulated context length.
- [RoPE long-context discrimination limits](https://learnaivisually.com/ai-explained/rope-long-context-limits): Du, Harris, Tian formally prove RoPE attention scores lose position and token discrimination at long context — failure probability approaches 50% (random).
- [QCA — Outlier injection across AWQ/GPTQ/GGUF](https://learnaivisually.com/ai-explained/qca-outlier-injection-ptq): A quantization-conditioned attack injects outlier weights so AWQ / GPTQ / GGUF I-quants collapse nearby weights to zero. FP16 audits clean; INT4 ships malicious
- [Contextual-bandit tool router](https://learnaivisually.com/ai-explained/tool-router-contextual-bandit): Tool-provider selection as a contextual bandit — the router learns answer quality per service cycle from rewards, aimed at improving on lowest-latency routing.
- [TIM — Training-Inference Mismatch](https://learnaivisually.com/ai-explained/tim-training-inference-mismatch): Zhong et al.'s VeXact diagnostic isolates rollout/policy probability drift in LLM RL, showing small same-weight mismatches can independently collapse training.
- [Spec-decode load-dependent latency model](https://learnaivisually.com/ai-explained/spec-decode-latency-load-model): Paper decomposes spec-decode latency into load-independent and load-dependent parts via Little's Law — predicts when wins shrink as the server saturates.
- [RecMem subconscious + recurrence-triggered agent memory](https://learnaivisually.com/ai-explained/recmem-subconscious-recurrence): Encodes every agent interaction into a cheap subconscious store; the LLM only fires for recurring clusters — up to 87% fewer memory-construction tokens.
- [MCP SEP-2468 — RFC 9207 iss parameter](https://learnaivisually.com/ai-explained/mcp-sep-2468-iss-oauth-mix-up): MCP SEP-2468 adopts RFC 9207's iss parameter for OAuth responses; clients validate it string-equal against recorded issuer to block multi-IdP mix-up attacks.
- [SGLang v0.5.12 — TokenSpeed MLA backend](https://learnaivisually.com/ai-explained/sglang-v0-5-12-tokenspeed-mla): SGLang v0.5.12 ships TokenSpeed MLA — a Blackwell backend for MLA that caches one shared low-rank K/V latent ~28× smaller, with ~12× TMA cache-write speedup.
- [EnvFactory — Synthetic envs for tool-use agent training](https://learnaivisually.com/ai-explained/envfactory-tool-env-synthesis): EnvFactory builds 85 stateful tool envs — 5× fewer than EnvScaler / AWM — and topology-aware sampling lifts Qwen3 tool-use by up to 15 pp on BFCL v3 multi-turn.
- [OpenComputer — Verifier-grounded benchmark synthesis](https://learnaivisually.com/ai-explained/opencomputer-verifier-grounded-synthesis): OpenComputer writes the verifier first, then synthesizes 1,000 tasks across 33 desktop apps — GPT-5.4 hits 68.3%, open-source agents drop as low as 5.7%.
- [MCP SEP-2106 — Full JSON Schema 2020-12 in tool I/O](https://learnaivisually.com/ai-explained/mcp-sep-2106-json-schema-2020-12): MCP SEP-2106 lets tool input and output schemas use full JSON Schema 2020-12: composition, conditionals, refs, plus any structuredContent JSON value now.
- [PSD — Parallel spec decode for diffusion LLMs](https://learnaivisually.com/ai-explained/psd-parallel-spec-decode-diffusion-llms): PSD scores every masked position in one diffusion-LLM forward pass, commits multiple confident positions at once — up to 5.5× tokens per pass, training-free.
- [Vera Rubin NVL72 — Rack-scale NVLink domain](https://learnaivisually.com/ai-explained/vera-rubin-nvl72-nvlink-rack-domain): Vera Rubin NVL72 links 72 Rubin GPUs through a sixth-gen NVLink Switch so rack-scale TP/EP collectives can stay on one fast fabric for large-model serving.
- [Mix-Quant — NVFP4 prefill + BF16 decode](https://learnaivisually.com/ai-explained/mix-quant-nvfp4-prefill-bf16-decode): Mix-Quant quantizes only the prefill GEMM to NVFP4 and keeps decode at BF16 — up to 3× prefill speedup because the two phases sit on opposite sides of the roofline.
- [OScaR — Token Norm Imbalance](https://learnaivisually.com/ai-explained/oscar-token-norm-imbalance): OScaR identifies Token Norm Imbalance — sequence-axis outliers — as the dominant INT2 KV cache failure mode, fixed by canalized rotation and per-token scaling.
- [RELEX — Rank-1 RLVR extrapolation](https://learnaivisually.com/ai-explained/relex-rank-1-extrapolation): RELEX fits one line through a 15% window of RLVR checkpoints and extrapolates the rest — reportedly matching full-RLVR Qwen3 quality from a tenth of steps.
- [MSSP — Scale-stable parameterization for MoE](https://learnaivisually.com/ai-explained/mssp-vs-mup-moe-scaling): MSSP applies Dynamical Mean Field Theory to MoE training and derives a parameterization that — unlike muP — keeps the optimal learning rate stable as width and expert count scale.
- [Gated DeltaNet-2 — decoupled erase/write gates](https://learnaivisually.com/ai-explained/gated-deltanet-2-decoupled-erase-write-gates): Gated DeltaNet-2 splits scalar delta-rule gating into channel-wise erase/write gates, improving fixed-state memory and RULER multi-key retrieval at 1.3B.
- [Camouflage Detection Gap — domain-vocabulary injection bypass](https://learnaivisually.com/ai-explained/camouflage-injection-detection-gap): Domain-camouflaged prompt injection drops Llama 3.1 8B detection from 93.8% to 9.7% and Llama Guard 3 to 0%; multi-agent debate amplifies the attack up to 9.9x.
- [ACC — tool-output unmasking for long-context agent SFT](https://learnaivisually.com/ai-explained/acc-tool-output-unmasking): ACC reformats agent trajectories into long-context QA pairs by unmasking tool outputs; Qwen3-30B-A3B gains +18.1 MRCR, matching Qwen3-235B-A22B 8x smaller.
- [Maestro — RL orchestrator over frozen experts](https://learnaivisually.com/ai-explained/maestro-rl-orchestrator-frozen-experts): Maestro is a 4B RL policy that picks (expert, skill) per task from a frozen pool — 70.1% on 10 multimodal benchmarks beats GPT-5, generalizes to unseen experts.
- [Boiling the Frog — multi-turn norm erosion benchmark](https://learnaivisually.com/ai-explained/boiling-frog-norm-erosion): Boiling the Frog shows multi-turn norm erosion in agents: 44.4% avg attack success across 9 models, 93.3% on loss-of-control, vs single-prompt refusal.
- [OpenSCAD Pantheon benchmark — HITL vs autonomous coding agents](https://learnaivisually.com/ai-explained/pantheon-bench-hitl-vs-autonomous-coding): ModelRift's Pantheon bench pits 6 agentic coding tools — Antigravity 2.0 hits 4.5/5 in ~12 min autonomous; ModelRift HITL hits 3.8/5 in ~10 min on the same task.
- [VPO — Vector Policy Optimization vs GRPO](https://learnaivisually.com/ai-explained/vpo-vector-reward-vs-grpo): VPO swaps GRPO's scalar advantage estimator for a vector-valued one — the post-trained policy keeps a diverse distribution that pays off at pass@k as k grows.
- [Targeted textual feedback RL — Cursor Composer 2.5](https://learnaivisually.com/ai-explained/cursor-composer-2-5-targeted-textual-feedback-rl): Cursor Composer 2.5 targeted textual feedback RL — a hint at a target span in a long rollout becomes a teacher, with KL replacing the end-of-rollout scalar.
- [Near-linear I/O approximate attention vs FlashAttention](https://learnaivisually.com/ai-explained/io-optimal-approx-attention-near-linear-io): Approximate-attention with near-linear SRAM-to-HBM I/O in n vs FlashAttention's quadratic n² — matching I/O lower bounds prove the result near-optimal.
- [EFC — a feedback-quality scaling law for agent harnesses](https://learnaivisually.com/ai-explained/efc-feedback-quality-scaling-law): Effective Feedback Compute (EFC) predicts agent-harness success from feedback quality, not raw compute — EFC fits success at R²≈0.94–0.99 vs 0.33–0.42.
- [PushBench measures agent goal-persistence — QGP and harness controllers](https://learnaivisually.com/ai-explained/pushbench-qgp): PushBench introduces Quantitative Goal Persistence — frontier agents drop to 3/9 successes at 100 artifacts; a state-tracking harness controller restores 69–78% QGP.
- [Complete-muE — two-bridge muTransfer from dense to any MoE](https://learnaivisually.com/ai-explained/complete-mue-two-bridge-mutransfer): Complete-muE uses active-width and activated-expert scaling so one dense FFN hyperparameter sweep reportedly transfers to many MoE shapes with minor drift.
- [Jetson Thor — edge Blackwell explained](https://learnaivisually.com/ai-explained/jetson-thor-edge-blackwell): Jetson Thor brings the Blackwell GPU architecture to the edge — 2,070 FP4 TFLOPS at 40–130W, reportedly 7.5× compute vs Jetson Orin, on a robotics SoC.
- [Project Glasswing — detection-saturated pipeline explained](https://learnaivisually.com/ai-explained/glasswing-detection-saturated-pipeline): Project Glasswing partners found 10,000+ high- or critical-severity vulnerabilities in one month. The detection-saturated dynamic is sharpest in cross-org pipelines — Anthropic disclosed 530 H/C OSS bugs to upstreams; only 75 patched.
- [Copilot Cowork — image-URL exfiltration explained](https://learnaivisually.com/ai-explained/copilot-cowork-image-url-exfiltration): Image-URL exfiltration in agent UIs — PromptArmor showed Copilot Cowork posting a Teams DM whose hidden <img src> leaks a pre-auth OneDrive token on open.
- [MobileMoE — DRAM-aware MoE scaling explained](https://learnaivisually.com/ai-explained/mobilemoe-dram-aware-scaling): MobileMoE jointly optimizes DRAM and compute for phones — sub-billion-active MoE LMs that fit under 3 GB at INT4, reportedly 2-4x faster than dense baselines.
- [NVIDIA AI Factories — Tokens per megawatt explained](https://learnaivisually.com/ai-explained/nvidia-ai-factories-tokens-per-mw): NVIDIA's AI Factories framing reorganizes LLM serving around tokens per megawatt — Blackwell Ultra GB300 NVL72 claims ~50x more tokens/MW than Hopper.
- [Gemini Omni — modality unification in a shared token space](https://learnaivisually.com/ai-explained/gemini-omni-shared-token-space): Gemini Omni turns image, audio, video, and text into tokens in one shared space, so a single model can read and generate any modality — what modality unification means.
- [Gemini 3.5 Flash — Agent-first model design explained](https://learnaivisually.com/ai-explained/gemini-3-5-flash-agent-first-vs-chat-retrofit): Agent-first models like Gemini 3.5 Flash are trained against tool-call trajectories — the agent loop is native habitat, not a chat-with-tools retrofit.
- [MaxProof — Defense-in-depth generative verifier](https://learnaivisually.com/ai-explained/maxproof-generative-verifier): MaxProof tunes its proof verifier for a low false-positive rate, so sampling many candidate proofs and picking a tournament winner clears IMO/USAMO gold.
- [GPT-Red — self-play red-teaming](https://learnaivisually.com/ai-explained/gpt-red-self-play-red-teaming): Self-play red-teaming trains an attacker model to invent prompt injections, then folds its finds back in as adversarial training data for the shipped model.

## Interview Explained

- [Interview Explained](https://learnaivisually.com/interview-explained): Structured breakdowns of technical talks and interviews with AI researchers and engineers — each distills a source video into labeled diagrams, key quotes, and takeaways, linked to the concepts it touches.