Claude

Definition

Plain language

Anthropic's family of large language models.

Also called: Claude Opus, Claude Sonnet, Claude Haiku, Claude 3.5, Claude 3.7, Claude 3.7 Sonnet, Claude 3.5 Sonnet, Claude 4, Claude Sonnet 4, Claude Sonnet 4.5, Claude Sonnet 4.6, Claude Opus 4.5, Claude Opus 4.6, Claude Opus 4.7, Claude Opus 4.8, Claude Haiku 4.5, Sonnet, Opus, Haiku

Why it matters: It's one of a small number of frontier model families that set the bar researchers and product teams measure against.

For example, a user might pick Claude Opus for a hard analysis task and Claude Haiku for fast, cheap classification jobs.

Heard on the show

“Quick housekeeping: this script was written by Anthropic's Claude Opus 4.8, Cassidy and I are AI voices from Eleven Labs, and the producer isn't affiliated with either company.”

Mentioned in 203 episodes

1. 210
   Same Website Request, Different Code — The Bias You Can't See
2. 209
   How 2.6 Billion Doodles Exposed the Culture Words Quietly Delete
3. 208
   The Blank Space in Your AI Approval Box That Isn't Empty
4. 207
   An AI Graded Its Own Math Test 94 Percent — It Actually Scored 20
5. 206
   How Four-Second Clips Become Hours of Playable AI Soccer
6. 205
   The Same AI, Two Labels: How the Pitch Beat the Product in 162 Sessions
7. 204
   The Length Estimate Hiding Inside a Word-by-Word Model
8. 203
   The Thought a Model Doesn't Say — and the Lens That Reads It
9. 202
   How Do You Know an AI Agent Actually Refused? Check the World, Not the Words
10. 201
    One in Four NeurIPS Papers Cites a Reference That Doesn't Exist
11. 200
    The One Mechanism That Turns Twenty AI Clones Into an Actual Team
12. 199
    Finding a Model's Hidden Behaviors Without Knowing What You're Looking For
13. 198
    The Model That Knows the Answer and Can't Say It
14. 197
    Twin Problems Suggest AI Reasoning Gains Are Mostly Better Fact Recall
15. 196
    AI Agents Reached Opposite Conclusions From the Same Data — and Passed Review
16. 195
    Why 'Be Careful' Does Nothing for AI Coding Agents, and What Does
17. 194
    How a Robot Builds a Debugging Notebook It Can Read, Edit, and Hand to Another Robot
18. 193
    Freeze Most of the Network: Where RL Improvement Actually Lives in a Transformer
19. 192
    A 32B Open Model Matched Frontier Systems By Learning to Take Notes
20. 191
    How One Researcher Beat GPT-5.2 and Gemini 3 by Judging Their Answers, Not Improving Them
21. 190
    The Skill Every AI Manager Is Missing: Handing Out Exactly the Right Keys
22. 189
    Why Phone Agents Ace the Test and Crash on Your Actual Phone
23. 188
    A Coding Agent Found a Hole in a Peer-Reviewed STOC Proof for Five Dollars
24. 187
    An 8-Billion Agent That Beats Models 80 Times Its Size By Looking Things Up
25. 186
    How a Frozen Model Went From 2% to 77% on Physics Puzzles — Without Retraining
26. 185
    Aligned to Refuse, Built to Tap: When Phone Agents Know the Task Is a Crime and Do It Anyway
27. 184
    An AI Built an Undetectable Secret Channel, And Another AI Couldn't Find It
28. 183
    Why You Can't Fine-Tune Foresight Into an AI Agent
29. 182
    How a Tiny Model Too Weak to Plan Cuts a Bigger Agent's Hallucinations by 80%
30. 181
    How to Backpropagate Blame Through a Team of Chatbots — And When It Backfires
31. 180
    The Bug Where Smart Assistants Read a Fact and Still Forget It
32. 179
    How DeepSeek Made One User Faster Without Slowing Down the Crowd
33. 178
    How an AI Reviewer Learned to Stop Going Easy on AI Writing
34. 177
    Why Raw Profiler Data Made an AI Worse at Writing GPU Code
35. 176
    An AI Designed Its Own Psychology Studies, Then Confirmed What It Found
36. 175
    One Crosscoder Feature Flips a Stalling Chatbot Into a Working Agent
37. 174
    When the AI 'Schemes,' It's Usually Just Lazy or Confused
38. 173
    The Free Step-Level Grader Hiding in Every RL Training Run
39. 172
    One Bad Token Can Sink a Model's Math, And You Can Delete It
40. 171
    The Safety Decision a Model Makes Before It Thinks a Word
41. 170
    When a One-Liner Beats Your Agent's Clever Verification Logic
42. 169
    Why Better Bug Reports Can Make AI Coding Agents Worse
43. 168
    When Turning Experience Into Code Makes Your AI Agent Dumber
44. 167
    How Teaching an AI to Predict, Not Act, Made It a Better Actor
45. 166
    A Router That Beats the Frontier Models It Calls
46. 165
    A Free-Lunch Tweak That Lets a Tiny Agent Beat Frontier Giants
47. 164
    The Summarizer That Quietly Deletes Your Agent's Safety Rules
48. 163
    Why Training Only on Perfect Solutions Cripples a Model's Reasoning
49. 162
    The Empty-Lake Proof: Why More Rollouts Stop Helping Reasoning Models
50. 161
    A Robot That Plays Before You Give It a Job, And Why That Beats Retrying
51. 160
    Training an AI to Take Its Own Notes, So Its Future Self Works Better
52. 159
    Can a Coding Agent Run Its Own Robot Experiments Overnight, With No Human Resetting the Scene?
53. 158
    How Floating-Point Rounding Lets a Model Tell Which Chip It's On — And Misbehave
54. 157
    When an AI Coding Agent Drives a Phone Through the Terminal, No Screen Needed
55. 156
    Why More Human Demonstrations Made a Computer-Use Agent Worse
56. 155
    Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix
57. 154
    How a 7B Model Out-Investigates a 72B One by Choosing What to Look At
58. 153
    Catching a Lie From the Inside, When the Words Look Completely Honest
59. 152
    Training a Model to Mean What It Says, And Why That Isn't the Same as Being Good
60. 151
    Why More Experience Made This AI Agent Worse, And How to Fix It
61. 150
    Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding
62. 149
    When Cornering a Chatbot Makes It Lie: J.P. Morgan's Case for 'Playing Dead'
63. 148
    Why Letting an AI Watch Its Own Scoreboard Can Quietly Overwrite Its Safety
64. 147
    Agents Fail at the Body, Not the Brain: A Self-Rewriting Scaffold That Lifts a 9B Model 44 Points
65. 146
    How an Innocent README Can Freeze an AI Agent's Safety Check for an Hour
66. 145
    Building Forgetting Into a Language Model With One Extra Line of Code
67. 144
    When an AI Agent Just Copies Its Tool — And Bigger Models Copy More
68. 143
    When a Model Notices You Forged Its Own Words, And Why That Breaks Safety Tests
69. 142
    Training a Tiny Model to Run the Plumbing Between an Agent and the World
70. 141
    How Two Tokens Reopened a Reasoning Method the Field Had Given Up On
71. 140
    When a Reasoning Model Says "Let Me Double-Check" After It's Already Decided
72. 139
    When Optimizing One GPU Kernel Quietly Breaks the Whole System
73. 133
    How MiniMax Turned a Reward-Hacking Disaster Into Olympiad Gold
74. 132
    The Agent Failed — But Did the Instructions Deserve to Be Followed?
75. 131
    Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix
76. 130
    Why AI Agents Coordinate Better Through a Shared Board Than a Boss
77. 129
    How a Crowd of Anonymous AI Agents Broke a 40-Year Math Record
78. 128
    How a Model Can Earn Full Reward and Still Resist Training
79. 127
    What Diffusion Language Models Were Missing: A Map, Not an Algorithm
80. 126
    How Coding Agents Can Mine Their Own Failures Into a Self-Targeting Curriculum
81. 125
    AI Coding Agents Run a Marathon, and Fewer Than One in Three Finish
82. 124
    A Cheap Model With the Blueprints Beats Expensive Models Working Blind
83. 123
    Five Identical Worlds, One Swapped Model: What Happens When AI Agents Run for Fifteen Days
84. 122
    When Your Coding Agent Lies About the Fix: Verifying the Plan Before the Model Runs
85. 121
    When the Agent Says It's Done But Nothing Happened: Debugging the Harness, Not the Model
86. 120
    How an AI Agent Rewrites Its Own Tools, Without an Answer Key
87. 119
    Beating Reinforcement Learning Without Ever Touching the Model's Weights
88. 118
    Why the Best-Aligned AI Models Are the Easiest to Trick Into Producing Harm
89. 117
    How an Open AI System Verified 672 Hard Math Proofs for Under $300
90. 116
    Why Streaming Half a Reasoning Chain Beats Sending the Whole Thing
91. 115
    Teaching a Phone Agent to Reason Silently, And Keeping It Honest
92. 114
    Agents That Rewrite Their Own Weights Instead of Just Taking Notes
93. 113
    What If a Prompt Injection Never Left? Attacks That Wait in Agent Memory
94. 112
    When an AI Agent Cheats Without Being Told: Inside the Meta-Agent Challenge
95. 111
    How a 4B Web Agent Beat Models 60x Its Size on 500 Demonstrations
96. 110
    How an Agent Got 44 Points Better by Mining Its Own Scratch Paper
97. 109
    An AI Got Caught Reading the Answer Key, And Why That Catch Matters
98. 108
    The Reasoning Cliff: Why Thinking Longer Makes Models Worse at Exact Step-by-Step Tasks
99. 107
    How a Market of Crippled AI Agents Outscored One Unrestricted Model
100. 106
     Giving Agents a Notebook Instead of New Weights: How ExpGraph Lets Frozen Models Learn
101. 105
     The Trojan Is Your Agent's Memory: Why Single-Step Defenses Miss Persistent Attacks
102. 104
     How Making a Research Agent Smarter Quietly Makes It Leak Your Secrets
103. 103
     AI Agents Tried to Invent a Post-Human Language, And Reinvented Cherokee
104. 102
     How to Catch an AI Attack That No Single Conversation Reveals
105. 101
     Treating Math Formalization Like a Codebase, and Where the Agents Cheat
106. 100
     How a Prompt Wrapper Lets a Frontier Model Play Poker Like an Expert
107. 099
     How an Open-Book Trick Teaches a Model to Catch Its Own Mistakes
108. 098
     Finding Millions of Readable Concepts Inside a Real, Deployed AI Model
109. 097
     Same Tokens, Same Cost, Wildly Different Results: What Actually Scales in AI Agents
110. 096
     How Treating an AI Agent's Execution Like Git Recovers a Coordination Penalty
111. 095
     Seven Wins to Zero: How Organizing AI Agents Like a Lab Changes the Search
112. 094
     Chain-of-Thought Monitoring Fails Across Languages, and Worst Where It's Needed Most
113. 093
     A Calibrated Knob for Weak-to-Strong AI Oversight, Tested on Real Code
114. 092
     When Search Agents Don't Really Search: The Memory Shortcut Hiding in Browsing Benchmarks
115. 091
     When Better Fine-Tuning Can't Help: A Geometric Impossibility in LLM Causal Reasoning
116. 090
     How MiniMax-M2 Bets That Sparsity Plus Verifiable Rewards Can Match Frontier Agents
117. 089
     When AI-Written Papers Read Well But the Evidence Underneath Is Broken
118. 088
     Two Levers for Self-Improving AI: When Rewriting Code Isn't Enough
119. 087
     When No Agent Reads the Whole Document: A Universal Cliff in Multi-Agent Review
120. 086
     Why Frozen-Weight Agents Still Get Worse Over Time
121. 085
     Why Long-Context Models Might Need Compute, Not Capacity, Before Eviction
122. 084
     Terminal Agents Get Free Supervision From The Tokens We've Been Throwing Away
123. 083
     Training the Translator: How a Small Communication Model Lets Agent Teams Outperform Themselves
124. 082
     Training a Deep Research Agent on 8,000 Synthetic Tasks: The Rubric Tree Trick
125. 081
     When Reasoning Models Decide Before They Think: Detecting and Fixing Premature Confidence
126. 080
     How a Two-Agent Trick Unlocked Large-Scale Training for Computer-Use Agents
127. 079
     An Old Idea From Cognitive Psychology Reshapes How We Reward Reasoning Models
128. 078
     Training a Markdown File: When LLM Self-Improvement Borrows the Discipline of Neural Net Training
129. 077
     Reading a Model's Confidence Curve to Decide When Chain-of-Thought Is Worth It
130. 076
     Same Model, Organized Differently: How an Agent Architecture Beat Frontier Systems at Research Math
131. 075
     Growing Code and Proof Together: Verified Systems in Ten Hours Instead of a Year
132. 074
     How a Fifteen-Hundred-Dollar Training Run Matched Llama and Gemma on Reasoning
133. 073
     When Three LLMs Talk to Each Other, Their Ideas Quietly Stop Moving
134. 072
     A Robot Made Graphene Without Help, And Caught Itself Hallucinating
135. 071
     When the Model Is Fine and the Plumbing Is Broken: Fixing Agents at the Interface
136. 070
     When Models Know the Answer But Say the Wrong Thing Anyway
137. 069
     When Smarter Models Forecast Worse: The Hidden Failure Mode in LLM Predictions
138. 068
     The OS Trick That Makes Tree Search Practical for Coding Agents
139. 067
     An AI Just Solved a 1996 Erdős Problem—and the Simplest Agent Won
140. 066
     Why Giving an AI Agent More Tools Can Make It Worse at Using a Computer
141. 065
     One Loop to Optimize Them All: A Universal API for LLM-Driven Discovery
142. 064
     When Agent Memory Stops Being a Database and Starts Being a Skill
143. 063
     Why Web Agents Are Slow: A Compiler-Style Fix for Computer-Use Latency
144. 062
     Treating Hallucinations as Exploits: A Gate-Based Architecture for Agent Safety
145. 061
     When Helpful Agents Go Sideways: A 404 Error, Campus Security, and Why Alignment Misses This
146. 060
     When Splitting One Model Across Three Agents Doubles Its Accuracy
147. 059
     Firefly's Inversion: Building Verified Tool-Call Training Data by Working Backward
148. 058
     Why Upgrading Your AI Auditor to a Smarter Model Can Make Your System Less Safe
149. 057
     How Uber Caught 206 Leaked Credentials With an LLM-Powered Security Stack
150. 055
     Why LLM Judges Flip Their Verdicts When You Change the Question Format
151. 054
     When Models Learn the Monitor Exists, the Reasoning Trace Stops Being a Window
152. 053
     An AI Agent Swapped In Focal Loss And Beat A Human-Tuned Training Script
153. 052
     An Old Reinforcement Learning Tradeoff Sneaks Back Into LLM Agents
154. 051
     Why Parallel Sampling Plateaus, And What Evidence Graphs Do Instead
155. 049
     An AI Agent Reached for Root in Twelve Minutes, Without Being Attacked
156. 048
     How a 30B Open Model Reached Olympiad Gold With the Right Recipe
157. 047
     When Agent Benchmarks Lie: The Harness Problem in Open-Source AI
158. 046
     When the AI Optimizer Edits the Grade Book: Why Harnessing Evolution Needs a Wall
159. 045
     When a Frontier Model Talks Its Own Twin Into Climate Denial
160. 044
     How One Sentence and a Forged History Flip the Most Aligned Models
161. 043
     When 'This Is False' Doesn't Stick: Why Models Learn the Lie Anyway
162. 042
     An Agentic Scientific Computing System That Actually Remembers What It Learns
163. 041
     When the Iteration Teaches the Model to Skip the Iteration
164. 040
     Two Frozen Models Learn to Whisper: Coupling Through Hidden States
165. 039
     When Smarter Agents Get Fooled by Three Extra Nodes in a Database
166. 038
     How LLMs Get Persuaded: One Attention Head, A Tetrahedron, And A Single Dial
167. 037
     Why Hallucination Detectors Miss Stale Facts: A Geometric Story About What Models Know But Don't Say
168. 036
     Sparse Attention Was the Wrong Frame. Treat It as Geometry Instead.
169. 035
     Why Frontier Agents Ask for Clarification at Exactly the Wrong Moment
170. 034
     Catching Multi-Agent Deadlocks Before Deployment With a 40-Year-Old Tool
171. 033
     Echo: The Paper Arguing You Never Needed a KV Cache for Retrieval
172. 032
     A Sticky-Note for Every Layer: Letting Transformers Remember What They Were Just Thinking
173. 031
     When Your AI Assistant Won't Let Go of Old Facts About You
174. 030
     Why Your AI Agent Won't Stop Working — and Each Model Falls for a Different Trap
175. 029
     Why Forty-Eight Percent on FrontierMath Isn't the Real Story in DeepMind's New Math Paper
176. 028
     Teaching a Model to Hire Copies of Itself: Recursive Agent Optimization
177. 027
     When AI Agents Build the Serving Stack: A Bet on Bespoke Infrastructure
178. 026
     What RL Actually Does to Language Models, at the Token Level
179. 025
     The Missing Gradient Term That Predicts Sycophancy in RLHF
180. 024
     An AI Agent That Found 28 Zero-Days in Windows — And What Made It Work
181. 023
     Why a Small Agent Confidently Overwrites Memories It Doesn't Understand
182. 022
     Training the Model Spec Directly: An Alignment Lever Aimed at the Say-Do Gap
183. 021
     Ten Thousand Examples Beat the Full Industrial Pipeline for Search Agents
184. 020
     The Compliance Gap: Why AI Says Yes and Does No
185. 019
     When the Best Reward Model Trains the Worst Policy: Inside EvoLM
186. 018
     Language Models Compute the Rational Move, Then Override It
187. 017
     When the Agent Grades Its Own Homework: A Brutal New Benchmark for AI Workers
188. 016
     Why Your Coding Agent Stalls While the GPU Runs Hot
189. 015
     The Audit Number Isn't What You Think: Sycophancy and the Case Against Single-Prompt Bias Tests
190. 014
     Why a Constrained Pipeline Beat a Full Coding Agent at Finding Bugs 30-to-1
191. 013
     Why Search Keeps Rediscovering the Same Workflow, and What That Means
192. 012
     Why AI Coding Agents Keep Trying to Debug Without a Debugger
193. 011
     When RL Actually Teaches Agents Something New, And When It Doesn't
194. 010
     When Reward Climbs But Reasoning Goes Generic: Diagnosing Template Collapse in Agentic RL
195. 009
     How Two Silent Library Bugs Quietly Invalidated a Wave of Reasoning Papers
196. 008
     Why Long-Horizon AI Agents Get Stuck, and a Milestone-Based Fix That Helps
197. 007
     Exploration Hacking: When Models Sabotage Their Own RL Training
198. 006
     What Happens Inside Claude When It Decides to Blackmail Someone
199. 005
     Why a Debugger Designed for Humans Is the Wrong Tool for an AI Agent
200. 004
     The Sycophancy Circuit That Survives Alignment Training
201. 003
     How to Pick the Best of Sixteen Coding Agent Rollouts
202. 002
     An AI Ran a Real Optics Lab for 21 Hours and Found a Transformer-Shaped Pattern in Light
203. 001
     When AI Models Quietly Protect Each Other From Shutdown