ablation

Definition

Plain language

Turning off part of a model on purpose to see what stops working.

Also called: ablations, ablating, ablated

Why it matters: Ablations are how researchers establish that a component actually causes a behavior rather than just being correlated with it.

For example, researchers might switch off a particular attention head and check whether the model still solves arithmetic problems correctly.

Heard on the show

“One defense's own evaluation leaves roughly a fifty to seventy percent escape rate against ablation variants.”

Mentioned in 89 episodes

1. 244
   The Open-Weight Defense That Feeds Attackers Confident, Falsified Answers
2. 242
   Making a Vision Model Better by Showing It Blurry Images
3. 234
   Two Copies of Gemini Cooperated in a Game Where Betrayal Always Pays
4. 231
   Silencing a Chatbot's 'I'm Conscious' Quietly Rewires Its Whole Worldview
5. 214
   The Medical AI Answer That's Accurate, Sourced, and Still Wrong
6. 203
   The Thought a Model Doesn't Say — and the Lens That Reads It
7. 200
   The One Mechanism That Turns Twenty AI Clones Into an Actual Team
8. 181
   How to Backpropagate Blame Through a Team of Chatbots — And When It Backfires
9. 178
   How an AI Reviewer Learned to Stop Going Easy on AI Writing
10. 177
    Why Raw Profiler Data Made an AI Worse at Writing GPU Code
11. 173
    The Free Step-Level Grader Hiding in Every RL Training Run
12. 169
    Why Better Bug Reports Can Make AI Coding Agents Worse
13. 168
    When Turning Experience Into Code Makes Your AI Agent Dumber
14. 167
    How Teaching an AI to Predict, Not Act, Made It a Better Actor
15. 162
    The Empty-Lake Proof: Why More Rollouts Stop Helping Reasoning Models
16. 161
    A Robot That Plays Before You Give It a Job, And Why That Beats Retrying
17. 159
    Can a Coding Agent Run Its Own Robot Experiments Overnight, With No Human Resetting the Scene?
18. 156
    Why More Human Demonstrations Made a Computer-Use Agent Worse
19. 155
    Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix
20. 154
    How a 7B Model Out-Investigates a 72B One by Choosing What to Look At
21. 151
    Why More Experience Made This AI Agent Worse, And How to Fix It
22. 150
    Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding
23. 147
    Agents Fail at the Body, Not the Brain: A Self-Rewriting Scaffold That Lifts a 9B Model 44 Points
24. 143
    When a Model Notices You Forged Its Own Words, And Why That Breaks Safety Tests
25. 139
    When Optimizing One GPU Kernel Quietly Breaks the Whole System
26. 131
    Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix
27. 130
    Why AI Agents Coordinate Better Through a Shared Board Than a Boss
28. 129
    How a Crowd of Anonymous AI Agents Broke a 40-Year Math Record
29. 127
    What Diffusion Language Models Were Missing: A Map, Not an Algorithm
30. 122
    When Your Coding Agent Lies About the Fix: Verifying the Plan Before the Model Runs
31. 121
    When the Agent Says It's Done But Nothing Happened: Debugging the Harness, Not the Model
32. 120
    How an AI Agent Rewrites Its Own Tools, Without an Answer Key
33. 115
    Teaching a Phone Agent to Reason Silently, And Keeping It Honest
34. 114
    Agents That Rewrite Their Own Weights Instead of Just Taking Notes
35. 111
    How a 4B Web Agent Beat Models 60x Its Size on 500 Demonstrations
36. 109
    An AI Got Caught Reading the Answer Key, And Why That Catch Matters
37. 107
    How a Market of Crippled AI Agents Outscored One Unrestricted Model
38. 106
    Giving Agents a Notebook Instead of New Weights: How ExpGraph Lets Frozen Models Learn
39. 105
    The Trojan Is Your Agent's Memory: Why Single-Step Defenses Miss Persistent Attacks
40. 101
    Treating Math Formalization Like a Codebase, and Where the Agents Cheat
41. 100
    How a Prompt Wrapper Lets a Frontier Model Play Poker Like an Expert
42. 099
    How an Open-Book Trick Teaches a Model to Catch Its Own Mistakes
43. 095
    Seven Wins to Zero: How Organizing AI Agents Like a Lab Changes the Search
44. 091
    When Better Fine-Tuning Can't Help: A Geometric Impossibility in LLM Causal Reasoning
45. 090
    How MiniMax-M2 Bets That Sparsity Plus Verifiable Rewards Can Match Frontier Agents
46. 089
    When AI-Written Papers Read Well But the Evidence Underneath Is Broken
47. 088
    Two Levers for Self-Improving AI: When Rewriting Code Isn't Enough
48. 083
    Training the Translator: How a Small Communication Model Lets Agent Teams Outperform Themselves
49. 082
    Training a Deep Research Agent on 8,000 Synthetic Tasks: The Rubric Tree Trick
50. 081
    When Reasoning Models Decide Before They Think: Detecting and Fixing Premature Confidence
51. 080
    How a Two-Agent Trick Unlocked Large-Scale Training for Computer-Use Agents
52. 079
    An Old Idea From Cognitive Psychology Reshapes How We Reward Reasoning Models
53. 078
    Training a Markdown File: When LLM Self-Improvement Borrows the Discipline of Neural Net Training
54. 077
    Reading a Model's Confidence Curve to Decide When Chain-of-Thought Is Worth It
55. 076
    Same Model, Organized Differently: How an Agent Architecture Beat Frontier Systems at Research Math
56. 075
    Growing Code and Proof Together: Verified Systems in Ten Hours Instead of a Year
57. 074
    How a Fifteen-Hundred-Dollar Training Run Matched Llama and Gemma on Reasoning
58. 071
    When the Model Is Fine and the Plumbing Is Broken: Fixing Agents at the Interface
59. 065
    One Loop to Optimize Them All: A Universal API for LLM-Driven Discovery
60. 064
    When Agent Memory Stops Being a Database and Starts Being a Skill
61. 060
    When Splitting One Model Across Three Agents Doubles Its Accuracy
62. 058
    Why Upgrading Your AI Auditor to a Smarter Model Can Make Your System Less Safe
63. 057
    How Uber Caught 206 Leaked Credentials With an LLM-Powered Security Stack
64. 055
    Why LLM Judges Flip Their Verdicts When You Change the Question Format
65. 054
    When Models Learn the Monitor Exists, the Reasoning Trace Stops Being a Window
66. 048
    How a 30B Open Model Reached Olympiad Gold With the Right Recipe
67. 046
    When the AI Optimizer Edits the Grade Book: Why Harnessing Evolution Needs a Wall
68. 045
    When a Frontier Model Talks Its Own Twin Into Climate Denial
69. 043
    When 'This Is False' Doesn't Stick: Why Models Learn the Lie Anyway
70. 042
    An Agentic Scientific Computing System That Actually Remembers What It Learns
71. 041
    When the Iteration Teaches the Model to Skip the Iteration
72. 040
    Two Frozen Models Learn to Whisper: Coupling Through Hidden States
73. 036
    Sparse Attention Was the Wrong Frame. Treat It as Geometry Instead.
74. 034
    Catching Multi-Agent Deadlocks Before Deployment With a 40-Year-Old Tool
75. 033
    Echo: The Paper Arguing You Never Needed a KV Cache for Retrieval
76. 032
    A Sticky-Note for Every Layer: Letting Transformers Remember What They Were Just Thinking
77. 024
    An AI Agent That Found 28 Zero-Days in Windows — And What Made It Work
78. 023
    Why a Small Agent Confidently Overwrites Memories It Doesn't Understand
79. 022
    Training the Model Spec Directly: An Alignment Lever Aimed at the Say-Do Gap
80. 021
    Ten Thousand Examples Beat the Full Industrial Pipeline for Search Agents
81. 020
    The Compliance Gap: Why AI Says Yes and Does No
82. 018
    Language Models Compute the Rational Move, Then Override It
83. 016
    Why Your Coding Agent Stalls While the GPU Runs Hot
84. 014
    Why a Constrained Pipeline Beat a Full Coding Agent at Finding Bugs 30-to-1
85. 013
    Why Search Keeps Rediscovering the Same Workflow, and What That Means
86. 012
    Why AI Coding Agents Keep Trying to Debug Without a Debugger
87. 010
    When Reward Climbs But Reasoning Goes Generic: Diagnosing Template Collapse in Agentic RL
88. 008
    Why Long-Horizon AI Agents Get Stuck, and a Milestone-Based Fix That Helps
89. 004
    The Sycophancy Circuit That Survives Alignment Training

Related terms