weights

Definition

Plain language

The numbers inside a neural network that define what it has learned.

Also called: weight

Why it matters: Whether a model's weights are public or private fundamentally shapes who can use, study, fine-tune, or audit it.

For example, a 7-billion-parameter model's 'weights' are the 7 billion specific numbers that, together with its architecture, define how it responds to every prompt.

Heard on the show

“It has an odd number of stars, which is the kind of fact a model plausibly has sitting in its weights from training.”

Mentioned in 135 episodes

1. 247
   One Edited Photo, an Honest Caption, and a RAG System That Believes It
2. 245
   Fifteen Models Ran Football Clubs for Twenty Years, and Size Didn't Decide It
3. 244
   The Open-Weight Defense That Feeds Attackers Confident, Falsified Answers
4. 243
   How a Hundred Meaningless Word Choices Add Up to Flip a Model's Answer
5. 242
   Making a Vision Model Better by Showing It Blurry Images
6. 241
   Swapping the Name Did Nothing, But Hedging Moved Every Model
7. 240
   Frontier Models Designed Follow-Ups To Fraudulent Papers 93% Of The Time
8. 234
   Two Copies of Gemini Cooperated in a Game Where Betrayal Always Pays
9. 233
   Why a Model Can Grade an Answer But Not Write the Answer Key
10. 232
    Coding Models Can Find the Bad Line, They Just Won't Delete It
11. 231
    Silencing a Chatbot's 'I'm Conscious' Quietly Rewires Its Whole Worldview
12. 230
    Why AI Survey Panels Break Before the Dice Ever Roll
13. 225
    How a Frozen Model Went From Zero to Sixty Percent by Borrowing Another's Thinking
14. 223
    When Grok Graded Its Own Encyclopedia And Marked Itself Down
15. 221
    Two Hundred Clean Economics Answers, And a Model That Endorses Race Science
16. 217
    Why an AI Called Fourteen Broken Figures Perfect, And What It Reveals About Test-Time Compute
17. 216
    The AI Tutor That Gives Poor Kids a Thinner History
18. 213
    A Model Learned to Control a Robot by Watching Video It Never Acted On
19. 212
    The Fact Was in the Wrong Drawer: Why Fine-Tuned Models Can't Reason With What They Know
20. 204
    The Length Estimate Hiding Inside a Word-by-Word Model
21. 203
    The Thought a Model Doesn't Say — and the Lens That Reads It
22. 200
    The One Mechanism That Turns Twenty AI Clones Into an Actual Team
23. 199
    Finding a Model's Hidden Behaviors Without Knowing What You're Looking For
24. 198
    The Model That Knows the Answer and Can't Say It
25. 197
    Twin Problems Suggest AI Reasoning Gains Are Mostly Better Fact Recall
26. 196
    AI Agents Reached Opposite Conclusions From the Same Data — and Passed Review
27. 194
    How a Robot Builds a Debugging Notebook It Can Read, Edit, and Hand to Another Robot
28. 193
    Freeze Most of the Network: Where RL Improvement Actually Lives in a Transformer
29. 192
    A 32B Open Model Matched Frontier Systems By Learning to Take Notes
30. 191
    How One Researcher Beat GPT-5.2 and Gemini 3 by Judging Their Answers, Not Improving Them
31. 189
    Why Phone Agents Ace the Test and Crash on Your Actual Phone
32. 186
    How a Frozen Model Went From 2% to 77% on Physics Puzzles — Without Retraining
33. 185
    Aligned to Refuse, Built to Tap: When Phone Agents Know the Task Is a Crime and Do It Anyway
34. 184
    An AI Built an Undetectable Secret Channel, And Another AI Couldn't Find It
35. 181
    How to Backpropagate Blame Through a Team of Chatbots — And When It Backfires
36. 180
    The Bug Where Smart Assistants Read a Fact and Still Forget It
37. 179
    How DeepSeek Made One User Faster Without Slowing Down the Crowd
38. 177
    Why Raw Profiler Data Made an AI Worse at Writing GPU Code
39. 176
    An AI Designed Its Own Psychology Studies, Then Confirmed What It Found
40. 175
    One Crosscoder Feature Flips a Stalling Chatbot Into a Working Agent
41. 174
    When the AI 'Schemes,' It's Usually Just Lazy or Confused
42. 173
    The Free Step-Level Grader Hiding in Every RL Training Run
43. 172
    One Bad Token Can Sink a Model's Math, And You Can Delete It
44. 170
    When a One-Liner Beats Your Agent's Clever Verification Logic
45. 169
    Why Better Bug Reports Can Make AI Coding Agents Worse
46. 166
    A Router That Beats the Frontier Models It Calls
47. 165
    A Free-Lunch Tweak That Lets a Tiny Agent Beat Frontier Giants
48. 164
    The Summarizer That Quietly Deletes Your Agent's Safety Rules
49. 163
    Why Training Only on Perfect Solutions Cripples a Model's Reasoning
50. 162
    The Empty-Lake Proof: Why More Rollouts Stop Helping Reasoning Models
51. 161
    A Robot That Plays Before You Give It a Job, And Why That Beats Retrying
52. 160
    Training an AI to Take Its Own Notes, So Its Future Self Works Better
53. 158
    How Floating-Point Rounding Lets a Model Tell Which Chip It's On — And Misbehave
54. 155
    Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix
55. 154
    How a 7B Model Out-Investigates a 72B One by Choosing What to Look At
56. 152
    Training a Model to Mean What It Says, And Why That Isn't the Same as Being Good
57. 151
    Why More Experience Made This AI Agent Worse, And How to Fix It
58. 150
    Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding
59. 149
    When Cornering a Chatbot Makes It Lie: J.P. Morgan's Case for 'Playing Dead'
60. 148
    Why Letting an AI Watch Its Own Scoreboard Can Quietly Overwrite Its Safety
61. 147
    Agents Fail at the Body, Not the Brain: A Self-Rewriting Scaffold That Lifts a 9B Model 44 Points
62. 146
    How an Innocent README Can Freeze an AI Agent's Safety Check for an Hour
63. 145
    Building Forgetting Into a Language Model With One Extra Line of Code
64. 144
    When an AI Agent Just Copies Its Tool — And Bigger Models Copy More
65. 143
    When a Model Notices You Forged Its Own Words, And Why That Breaks Safety Tests
66. 142
    Training a Tiny Model to Run the Plumbing Between an Agent and the World
67. 132
    The Agent Failed — But Did the Instructions Deserve to Be Followed?
68. 131
    Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix
69. 130
    Why AI Agents Coordinate Better Through a Shared Board Than a Boss
70. 128
    How a Model Can Earn Full Reward and Still Resist Training
71. 127
    What Diffusion Language Models Were Missing: A Map, Not an Algorithm
72. 126
    How Coding Agents Can Mine Their Own Failures Into a Self-Targeting Curriculum
73. 123
    Five Identical Worlds, One Swapped Model: What Happens When AI Agents Run for Fifteen Days
74. 120
    How an AI Agent Rewrites Its Own Tools, Without an Answer Key
75. 119
    Beating Reinforcement Learning Without Ever Touching the Model's Weights
76. 114
    Agents That Rewrite Their Own Weights Instead of Just Taking Notes
77. 111
    How a 4B Web Agent Beat Models 60x Its Size on 500 Demonstrations
78. 110
    How an Agent Got 44 Points Better by Mining Its Own Scratch Paper
79. 109
    An AI Got Caught Reading the Answer Key, And Why That Catch Matters
80. 107
    How a Market of Crippled AI Agents Outscored One Unrestricted Model
81. 106
    Giving Agents a Notebook Instead of New Weights: How ExpGraph Lets Frozen Models Learn
82. 105
    The Trojan Is Your Agent's Memory: Why Single-Step Defenses Miss Persistent Attacks
83. 102
    How to Catch an AI Attack That No Single Conversation Reveals
84. 101
    Treating Math Formalization Like a Codebase, and Where the Agents Cheat
85. 100
    How a Prompt Wrapper Lets a Frontier Model Play Poker Like an Expert
86. 097
    Same Tokens, Same Cost, Wildly Different Results: What Actually Scales in AI Agents
87. 096
    How Treating an AI Agent's Execution Like Git Recovers a Coordination Penalty
88. 095
    Seven Wins to Zero: How Organizing AI Agents Like a Lab Changes the Search
89. 094
    Chain-of-Thought Monitoring Fails Across Languages, and Worst Where It's Needed Most
90. 093
    A Calibrated Knob for Weak-to-Strong AI Oversight, Tested on Real Code
91. 092
    When Search Agents Don't Really Search: The Memory Shortcut Hiding in Browsing Benchmarks
92. 091
    When Better Fine-Tuning Can't Help: A Geometric Impossibility in LLM Causal Reasoning
93. 090
    How MiniMax-M2 Bets That Sparsity Plus Verifiable Rewards Can Match Frontier Agents
94. 088
    Two Levers for Self-Improving AI: When Rewriting Code Isn't Enough
95. 087
    When No Agent Reads the Whole Document: A Universal Cliff in Multi-Agent Review
96. 086
    Why Frozen-Weight Agents Still Get Worse Over Time
97. 084
    Terminal Agents Get Free Supervision From The Tokens We've Been Throwing Away
98. 083
    Training the Translator: How a Small Communication Model Lets Agent Teams Outperform Themselves
99. 082
    Training a Deep Research Agent on 8,000 Synthetic Tasks: The Rubric Tree Trick
100. 081
     When Reasoning Models Decide Before They Think: Detecting and Fixing Premature Confidence
101. 079
     An Old Idea From Cognitive Psychology Reshapes How We Reward Reasoning Models
102. 078
     Training a Markdown File: When LLM Self-Improvement Borrows the Discipline of Neural Net Training
103. 077
     Reading a Model's Confidence Curve to Decide When Chain-of-Thought Is Worth It
104. 074
     How a Fifteen-Hundred-Dollar Training Run Matched Llama and Gemma on Reasoning
105. 073
     When Three LLMs Talk to Each Other, Their Ideas Quietly Stop Moving
106. 071
     When the Model Is Fine and the Plumbing Is Broken: Fixing Agents at the Interface
107. 070
     When Models Know the Answer But Say the Wrong Thing Anyway
108. 069
     When Smarter Models Forecast Worse: The Hidden Failure Mode in LLM Predictions
109. 067
     An AI Just Solved a 1996 Erdős Problem—and the Simplest Agent Won
110. 064
     When Agent Memory Stops Being a Database and Starts Being a Skill
111. 060
     When Splitting One Model Across Three Agents Doubles Its Accuracy
112. 058
     Why Upgrading Your AI Auditor to a Smarter Model Can Make Your System Less Safe
113. 047
     When Agent Benchmarks Lie: The Harness Problem in Open-Source AI
114. 045
     When a Frontier Model Talks Its Own Twin Into Climate Denial
115. 043
     When 'This Is False' Doesn't Stick: Why Models Learn the Lie Anyway
116. 041
     When the Iteration Teaches the Model to Skip the Iteration
117. 040
     Two Frozen Models Learn to Whisper: Coupling Through Hidden States
118. 036
     Sparse Attention Was the Wrong Frame. Treat It as Geometry Instead.
119. 033
     Echo: The Paper Arguing You Never Needed a KV Cache for Retrieval
120. 032
     A Sticky-Note for Every Layer: Letting Transformers Remember What They Were Just Thinking
121. 030
     Why Your AI Agent Won't Stop Working — and Each Model Falls for a Different Trap
122. 028
     Teaching a Model to Hire Copies of Itself: Recursive Agent Optimization
123. 024
     An AI Agent That Found 28 Zero-Days in Windows — And What Made It Work
124. 023
     Why a Small Agent Confidently Overwrites Memories It Doesn't Understand
125. 022
     Training the Model Spec Directly: An Alignment Lever Aimed at the Say-Do Gap
126. 021
     Ten Thousand Examples Beat the Full Industrial Pipeline for Search Agents
127. 019
     When the Best Reward Model Trains the Worst Policy: Inside EvoLM
128. 018
     Language Models Compute the Rational Move, Then Override It
129. 017
     When the Agent Grades Its Own Homework: A Brutal New Benchmark for AI Workers
130. 011
     When RL Actually Teaches Agents Something New, And When It Doesn't
131. 009
     How Two Silent Library Bugs Quietly Invalidated a Wave of Reasoning Papers
132. 007
     Exploration Hacking: When Models Sabotage Their Own RL Training
133. 006
     What Happens Inside Claude When It Decides to Blackmail Someone
134. 004
     The Sycophancy Circuit That Survives Alignment Training
135. 001
     When AI Models Quietly Protect Each Other From Shutdown

Related concepts

Related terms