scaffold

Definition

Plain language

The wrapper of code, tools, and loops around an AI model that turns the raw model into an agent that can actually do things.

Also called: scaffolds, scaffolding

Why it matters: It can change a model's behavior and cost by a huge margin, so fair comparisons between models must keep the scaffold fixed or risk measuring the wrapper instead of the model.

For example, the same model can either flail or solve a coding task depending on the surrounding code that feeds it context, runs its tools, and decides when it's done.

Heard on the show

“… we make agents better at long horizons by making the underlying models smarter — or is this a scaffolding problem, where the fix is better memory and better plan-carrying around models that already know …”

Mentioned in 76 episodes

1. 245
   Fifteen Models Ran Football Clubs for Twenty Years, and Size Didn't Decide It
2. 242
   Making a Vision Model Better by Showing It Blurry Images
3. 241
   Swapping the Name Did Nothing, But Hedging Moved Every Model
4. 237
   The Model Built a Perfect Map of the Puzzle, Then Lost It
5. 234
   Two Copies of Gemini Cooperated in a Game Where Betrayal Always Pays
6. 233
   Why a Model Can Grade an Answer But Not Write the Answer Key
7. 230
   Why AI Survey Panels Break Before the Dice Ever Roll
8. 225
   How a Frozen Model Went From Zero to Sixty Percent by Borrowing Another's Thinking
9. 218
   When Universities Say Embrace AI But Half the CS Syllabi Ban It
10. 210
    Same Website Request, Different Code — The Bias You Can't See
11. 200
    The One Mechanism That Turns Twenty AI Clones Into an Actual Team
12. 192
    A 32B Open Model Matched Frontier Systems By Learning to Take Notes
13. 191
    How One Researcher Beat GPT-5.2 and Gemini 3 by Judging Their Answers, Not Improving Them
14. 184
    An AI Built an Undetectable Secret Channel, And Another AI Couldn't Find It
15. 175
    One Crosscoder Feature Flips a Stalling Chatbot Into a Working Agent
16. 166
    A Router That Beats the Frontier Models It Calls
17. 163
    Why Training Only on Perfect Solutions Cripples a Model's Reasoning
18. 160
    Training an AI to Take Its Own Notes, So Its Future Self Works Better
19. 157
    When an AI Coding Agent Drives a Phone Through the Terminal, No Screen Needed
20. 155
    Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix
21. 152
    Training a Model to Mean What It Says, And Why That Isn't the Same as Being Good
22. 151
    Why More Experience Made This AI Agent Worse, And How to Fix It
23. 150
    Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding
24. 147
    Agents Fail at the Body, Not the Brain: A Self-Rewriting Scaffold That Lifts a 9B Model 44 Points
25. 146
    How an Innocent README Can Freeze an AI Agent's Safety Check for an Hour
26. 144
    When an AI Agent Just Copies Its Tool — And Bigger Models Copy More
27. 142
    Training a Tiny Model to Run the Plumbing Between an Agent and the World
28. 140
    When a Reasoning Model Says "Let Me Double-Check" After It's Already Decided
29. 139
    When Optimizing One GPU Kernel Quietly Breaks the Whole System
30. 133
    How MiniMax Turned a Reward-Hacking Disaster Into Olympiad Gold
31. 131
    Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix
32. 130
    Why AI Agents Coordinate Better Through a Shared Board Than a Boss
33. 129
    How a Crowd of Anonymous AI Agents Broke a 40-Year Math Record
34. 125
    AI Coding Agents Run a Marathon, and Fewer Than One in Three Finish
35. 121
    When the Agent Says It's Done But Nothing Happened: Debugging the Harness, Not the Model
36. 120
    How an AI Agent Rewrites Its Own Tools, Without an Answer Key
37. 118
    Why the Best-Aligned AI Models Are the Easiest to Trick Into Producing Harm
38. 114
    Agents That Rewrite Their Own Weights Instead of Just Taking Notes
39. 112
    When an AI Agent Cheats Without Being Told: Inside the Meta-Agent Challenge
40. 110
    How an Agent Got 44 Points Better by Mining Its Own Scratch Paper
41. 109
    An AI Got Caught Reading the Answer Key, And Why That Catch Matters
42. 106
    Giving Agents a Notebook Instead of New Weights: How ExpGraph Lets Frozen Models Learn
43. 102
    How to Catch an AI Attack That No Single Conversation Reveals
44. 101
    Treating Math Formalization Like a Codebase, and Where the Agents Cheat
45. 100
    How a Prompt Wrapper Lets a Frontier Model Play Poker Like an Expert
46. 097
    Same Tokens, Same Cost, Wildly Different Results: What Actually Scales in AI Agents
47. 090
    How MiniMax-M2 Bets That Sparsity Plus Verifiable Rewards Can Match Frontier Agents
48. 088
    Two Levers for Self-Improving AI: When Rewriting Code Isn't Enough
49. 079
    An Old Idea From Cognitive Psychology Reshapes How We Reward Reasoning Models
50. 078
    Training a Markdown File: When LLM Self-Improvement Borrows the Discipline of Neural Net Training
51. 077
    Reading a Model's Confidence Curve to Decide When Chain-of-Thought Is Worth It
52. 076
    Same Model, Organized Differently: How an Agent Architecture Beat Frontier Systems at Research Math
53. 075
    Growing Code and Proof Together: Verified Systems in Ten Hours Instead of a Year
54. 073
    When Three LLMs Talk to Each Other, Their Ideas Quietly Stop Moving
55. 072
    A Robot Made Graphene Without Help, And Caught Itself Hallucinating
56. 071
    When the Model Is Fine and the Plumbing Is Broken: Fixing Agents at the Interface
57. 067
    An AI Just Solved a 1996 Erdős Problem—and the Simplest Agent Won
58. 065
    One Loop to Optimize Them All: A Universal API for LLM-Driven Discovery
59. 060
    When Splitting One Model Across Three Agents Doubles Its Accuracy
60. 053
    An AI Agent Swapped In Focal Loss And Beat A Human-Tuned Training Script
61. 051
    Why Parallel Sampling Plateaus, And What Evidence Graphs Do Instead
62. 047
    When Agent Benchmarks Lie: The Harness Problem in Open-Source AI
63. 046
    When the AI Optimizer Edits the Grade Book: Why Harnessing Evolution Needs a Wall
64. 041
    When the Iteration Teaches the Model to Skip the Iteration
65. 036
    Sparse Attention Was the Wrong Frame. Treat It as Geometry Instead.
66. 028
    Teaching a Model to Hire Copies of Itself: Recursive Agent Optimization
67. 027
    When AI Agents Build the Serving Stack: A Bet on Bespoke Infrastructure
68. 024
    An AI Agent That Found 28 Zero-Days in Windows — And What Made It Work
69. 017
    When the Agent Grades Its Own Homework: A Brutal New Benchmark for AI Workers
70. 014
    Why a Constrained Pipeline Beat a Full Coding Agent at Finding Bugs 30-to-1
71. 013
    Why Search Keeps Rediscovering the Same Workflow, and What That Means
72. 012
    Why AI Coding Agents Keep Trying to Debug Without a Debugger
73. 008
    Why Long-Horizon AI Agents Get Stuck, and a Milestone-Based Fix That Helps
74. 007
    Exploration Hacking: When Models Sabotage Their Own RL Training
75. 002
    An AI Ran a Real Optics Lab for 21 Hours and Found a Transformer-Shaped Pattern in Light
76. 001
    When AI Models Quietly Protect Each Other From Shutdown

Related concepts

Related terms