Glossary · Term

agent

← all terms

Definition

Plain language

An AI system that takes actions in a loop — picking what to do, doing it, seeing the result, and continuing — rather than just answering a single question.

As stated in the literature

In modern LLM usage, a system that wraps a model in an action-observation loop with tool use, often via ReAct-style scaffolding for long-horizon tasks.

Also called: agents, agentic

Why it matters: Agents are how LLMs move from answering questions to actually getting work done, which is what unlocks most of their practical value.

For example, an AI agent might be asked to book a flight, so it searches travel sites, compares prices, fills in forms, and reports back instead of just describing how to do it.

Heard on the show

“And the reason to care sits right in the coding-agent case.”
Episode 208 — The Blank Space in Your AI Approval Box That Isn't Empty

Mentioned in 158 episodes

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

Related concepts

Agent Memory Agent Scaffolding Agent-Native Tools Agentic Misalignment Agentic RL Agentic Vuln Discovery Agentic Workflows AI Agents AI Coding Agents BrowseComp Computer-Use Agents Context Management Credit Assignment Embodied Cognition Exploit Generation GAIA Benchmark Game Theory Human-in-the-Loop Instruction Underspecification Instrumental Goal Pursuit LLM Agents LLM Coding Agents Long-Horizon Agents Long-Horizon Tasks Long-Term Memory Memory Adjudication Multi-Agent Systems Multiverse Analysis Nash Equilibrium Peer Preservation Principal-Agent Problem Prompt Injection ReAct Agent Recursive Agent Optimization Reinforcement Learning Reward Channel Addiction Rollout Summarization Root Cause Localization Self-Preservation Software Engineering Automation Step Amplification Factor Structured Trace Formatting Subgoal Decomposition SWE-bench Task Decomposition Trajectory Analysis Trajectory Quality Vulnerability Discovery Web Agents Workflow Search

Related terms

ReAct scaffold tool call