trajectory

Definition

Plain language

The full record of what an AI agent did from start to finish on a task.

Also called: trajectories

Why it matters: Trajectories are the raw material of agent RL — both for credit assignment during training and for human review during debugging.

For example, an agent's trajectory on a flight-booking task includes every web page it viewed, every click, and every observation it received along the way.

Heard on the show

“And a real robotics engineer, faced with that, would replay the run, inspect the camera overlays, look at the trajectories, figure out which subsystem broke — and then remember the fix for next time.”

Mentioned in 87 episodes

1. 194
   How a Robot Builds a Debugging Notebook It Can Read, Edit, and Hand to Another Robot
2. 192
   A 32B Open Model Matched Frontier Systems By Learning to Take Notes
3. 189
   Why Phone Agents Ace the Test and Crash on Your Actual Phone
4. 187
   An 8-Billion Agent That Beats Models 80 Times Its Size By Looking Things Up
5. 186
   How a Frozen Model Went From 2% to 77% on Physics Puzzles — Without Retraining
6. 183
   Why You Can't Fine-Tune Foresight Into an AI Agent
7. 181
   How to Backpropagate Blame Through a Team of Chatbots — And When It Backfires
8. 177
   Why Raw Profiler Data Made an AI Worse at Writing GPU Code
9. 174
   When the AI 'Schemes,' It's Usually Just Lazy or Confused
10. 173
    The Free Step-Level Grader Hiding in Every RL Training Run
11. 170
    When a One-Liner Beats Your Agent's Clever Verification Logic
12. 168
    When Turning Experience Into Code Makes Your AI Agent Dumber
13. 167
    How Teaching an AI to Predict, Not Act, Made It a Better Actor
14. 166
    A Router That Beats the Frontier Models It Calls
15. 165
    A Free-Lunch Tweak That Lets a Tiny Agent Beat Frontier Giants
16. 160
    Training an AI to Take Its Own Notes, So Its Future Self Works Better
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. 154
    How a 7B Model Out-Investigates a 72B One by Choosing What to Look At
20. 150
    Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding
21. 143
    When a Model Notices You Forged Its Own Words, And Why That Breaks Safety Tests
22. 142
    Training a Tiny Model to Run the Plumbing Between an Agent and the World
23. 141
    How Two Tokens Reopened a Reasoning Method the Field Had Given Up On
24. 133
    How MiniMax Turned a Reward-Hacking Disaster Into Olympiad Gold
25. 131
    Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix
26. 130
    Why AI Agents Coordinate Better Through a Shared Board Than a Boss
27. 125
    AI Coding Agents Run a Marathon, and Fewer Than One in Three Finish
28. 124
    A Cheap Model With the Blueprints Beats Expensive Models Working Blind
29. 123
    Five Identical Worlds, One Swapped Model: What Happens When AI Agents Run for Fifteen Days
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. 119
    Beating Reinforcement Learning Without Ever Touching the Model's Weights
34. 116
    Why Streaming Half a Reasoning Chain Beats Sending the Whole Thing
35. 115
    Teaching a Phone Agent to Reason Silently, And Keeping It Honest
36. 111
    How a 4B Web Agent Beat Models 60x Its Size on 500 Demonstrations
37. 109
    An AI Got Caught Reading the Answer Key, And Why That Catch Matters
38. 108
    The Reasoning Cliff: Why Thinking Longer Makes Models Worse at Exact Step-by-Step Tasks
39. 107
    How a Market of Crippled AI Agents Outscored One Unrestricted Model
40. 106
    Giving Agents a Notebook Instead of New Weights: How ExpGraph Lets Frozen Models Learn
41. 104
    How Making a Research Agent Smarter Quietly Makes It Leak Your Secrets
42. 099
    How an Open-Book Trick Teaches a Model to Catch Its Own Mistakes
43. 096
    How Treating an AI Agent's Execution Like Git Recovers a Coordination Penalty
44. 095
    Seven Wins to Zero: How Organizing AI Agents Like a Lab Changes the Search
45. 093
    A Calibrated Knob for Weak-to-Strong AI Oversight, Tested on Real Code
46. 092
    When Search Agents Don't Really Search: The Memory Shortcut Hiding in Browsing Benchmarks
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. 084
    Terminal Agents Get Free Supervision From The Tokens We've Been Throwing Away
50. 083
    Training the Translator: How a Small Communication Model Lets Agent Teams Outperform Themselves
51. 082
    Training a Deep Research Agent on 8,000 Synthetic Tasks: The Rubric Tree Trick
52. 081
    When Reasoning Models Decide Before They Think: Detecting and Fixing Premature Confidence
53. 080
    How a Two-Agent Trick Unlocked Large-Scale Training for Computer-Use Agents
54. 079
    An Old Idea From Cognitive Psychology Reshapes How We Reward Reasoning Models
55. 078
    Training a Markdown File: When LLM Self-Improvement Borrows the Discipline of Neural Net Training
56. 077
    Reading a Model's Confidence Curve to Decide When Chain-of-Thought Is Worth It
57. 073
    When Three LLMs Talk to Each Other, Their Ideas Quietly Stop Moving
58. 071
    When the Model Is Fine and the Plumbing Is Broken: Fixing Agents at the Interface
59. 069
    When Smarter Models Forecast Worse: The Hidden Failure Mode in LLM Predictions
60. 068
    The OS Trick That Makes Tree Search Practical for Coding Agents
61. 066
    Why Giving an AI Agent More Tools Can Make It Worse at Using a Computer
62. 064
    When Agent Memory Stops Being a Database and Starts Being a Skill
63. 061
    When Helpful Agents Go Sideways: A 404 Error, Campus Security, and Why Alignment Misses This
64. 059
    Firefly's Inversion: Building Verified Tool-Call Training Data by Working Backward
65. 053
    An AI Agent Swapped In Focal Loss And Beat A Human-Tuned Training Script
66. 052
    An Old Reinforcement Learning Tradeoff Sneaks Back Into LLM Agents
67. 051
    Why Parallel Sampling Plateaus, And What Evidence Graphs Do Instead
68. 048
    How a 30B Open Model Reached Olympiad Gold With the Right Recipe
69. 047
    When Agent Benchmarks Lie: The Harness Problem in Open-Source AI
70. 044
    How One Sentence and a Forged History Flip the Most Aligned Models
71. 042
    An Agentic Scientific Computing System That Actually Remembers What It Learns
72. 041
    When the Iteration Teaches the Model to Skip the Iteration
73. 040
    Two Frozen Models Learn to Whisper: Coupling Through Hidden States
74. 037
    Why Hallucination Detectors Miss Stale Facts: A Geometric Story About What Models Know But Don't Say
75. 035
    Why Frontier Agents Ask for Clarification at Exactly the Wrong Moment
76. 028
    Teaching a Model to Hire Copies of Itself: Recursive Agent Optimization
77. 027
    When AI Agents Build the Serving Stack: A Bet on Bespoke Infrastructure
78. 025
    The Missing Gradient Term That Predicts Sycophancy in RLHF
79. 021
    Ten Thousand Examples Beat the Full Industrial Pipeline for Search Agents
80. 019
    When the Best Reward Model Trains the Worst Policy: Inside EvoLM
81. 017
    When the Agent Grades Its Own Homework: A Brutal New Benchmark for AI Workers
82. 013
    Why Search Keeps Rediscovering the Same Workflow, and What That Means
83. 011
    When RL Actually Teaches Agents Something New, And When It Doesn't
84. 008
    Why Long-Horizon AI Agents Get Stuck, and a Milestone-Based Fix That Helps
85. 007
    Exploration Hacking: When Models Sabotage Their Own RL Training
86. 005
    Why a Debugger Designed for Humans Is the Wrong Tool for an AI Agent
87. 002
    An AI Ran a Real Optics Lab for 21 Hours and Found a Transformer-Shaped Pattern in Light

Related concepts

Related terms