Glossary · Term

pipelining

← all terms

Definition

Plain language

Keeping every station busy by starting the next stage the moment the previous one hands off a piece, like an assembly line, instead of waiting for the whole job to finish.

As stated in the literature

An overlap technique where downstream stages begin processing a stream as soon as upstream produces its first output; total latency approaches the slowest stage rather than the sum of all stages, applied to streaming reasoning between agents.

Also called: pipeline

Why it matters: It cuts total waiting time dramatically, since the system runs only as slow as its slowest stage instead of adding up every stage's delay.

For example, a translator starts rendering the first sentence of a speech into another language while the speaker is still talking, rather than waiting for the whole speech to end.

Heard on the show

“And they leaned on an AI model to fill in ratings for about forty concepts that were missing scores, which is another layer of English-trained judgment sitting in the pipeline.”
Episode 209 — How 2.6 Billion Doodles Exposed the Culture Words Quietly Delete

Mentioned in 92 episodes

  1. 209
    How 2.6 Billion Doodles Exposed the Culture Words Quietly Delete
  2. 202
    How Do You Know an AI Agent Actually Refused? Check the World, Not the Words
  3. 201
    One in Four NeurIPS Papers Cites a Reference That Doesn't Exist
  4. 198
    The Model That Knows the Answer and Can't Say It
  5. 195
    Why 'Be Careful' Does Nothing for AI Coding Agents, and What Does
  6. 191
    How One Researcher Beat GPT-5.2 and Gemini 3 by Judging Their Answers, Not Improving Them
  7. 190
    The Skill Every AI Manager Is Missing: Handing Out Exactly the Right Keys
  8. 189
    Why Phone Agents Ace the Test and Crash on Your Actual Phone
  9. 188
    A Coding Agent Found a Hole in a Peer-Reviewed STOC Proof for Five Dollars
  10. 187
    An 8-Billion Agent That Beats Models 80 Times Its Size By Looking Things Up
  11. 183
    Why You Can't Fine-Tune Foresight Into an AI Agent
  12. 181
    How to Backpropagate Blame Through a Team of Chatbots — And When It Backfires
  13. 177
    Why Raw Profiler Data Made an AI Worse at Writing GPU Code
  14. 176
    An AI Designed Its Own Psychology Studies, Then Confirmed What It Found
  15. 175
    One Crosscoder Feature Flips a Stalling Chatbot Into a Working Agent
  16. 173
    The Free Step-Level Grader Hiding in Every RL Training Run
  17. 169
    Why Better Bug Reports Can Make AI Coding Agents Worse
  18. 167
    How Teaching an AI to Predict, Not Act, Made It a Better Actor
  19. 166
    A Router That Beats the Frontier Models It Calls
  20. 162
    The Empty-Lake Proof: Why More Rollouts Stop Helping Reasoning Models
  21. 159
    Can a Coding Agent Run Its Own Robot Experiments Overnight, With No Human Resetting the Scene?
  22. 157
    When an AI Coding Agent Drives a Phone Through the Terminal, No Screen Needed
  23. 156
    Why More Human Demonstrations Made a Computer-Use Agent Worse
  24. 155
    Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix
  25. 151
    Why More Experience Made This AI Agent Worse, And How to Fix It
  26. 147
    Agents Fail at the Body, Not the Brain: A Self-Rewriting Scaffold That Lifts a 9B Model 44 Points
  27. 146
    How an Innocent README Can Freeze an AI Agent's Safety Check for an Hour
  28. 142
    Training a Tiny Model to Run the Plumbing Between an Agent and the World
  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. 132
    The Agent Failed — But Did the Instructions Deserve to Be Followed?
  32. 131
    Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix
  33. 129
    How a Crowd of Anonymous AI Agents Broke a 40-Year Math Record
  34. 128
    How a Model Can Earn Full Reward and Still Resist Training
  35. 127
    What Diffusion Language Models Were Missing: A Map, Not an Algorithm
  36. 126
    How Coding Agents Can Mine Their Own Failures Into a Self-Targeting Curriculum
  37. 124
    A Cheap Model With the Blueprints Beats Expensive Models Working Blind
  38. 122
    When Your Coding Agent Lies About the Fix: Verifying the Plan Before the Model Runs
  39. 121
    When the Agent Says It's Done But Nothing Happened: Debugging the Harness, Not the Model
  40. 120
    How an AI Agent Rewrites Its Own Tools, Without an Answer Key
  41. 116
    Why Streaming Half a Reasoning Chain Beats Sending the Whole Thing
  42. 113
    What If a Prompt Injection Never Left? Attacks That Wait in Agent Memory
  43. 110
    How an Agent Got 44 Points Better by Mining Its Own Scratch Paper
  44. 107
    How a Market of Crippled AI Agents Outscored One Unrestricted Model
  45. 106
    Giving Agents a Notebook Instead of New Weights: How ExpGraph Lets Frozen Models Learn
  46. 105
    The Trojan Is Your Agent's Memory: Why Single-Step Defenses Miss Persistent Attacks
  47. 104
    How Making a Research Agent Smarter Quietly Makes It Leak Your Secrets
  48. 101
    Treating Math Formalization Like a Codebase, and Where the Agents Cheat
  49. 100
    How a Prompt Wrapper Lets a Frontier Model Play Poker Like an Expert
  50. 096
    How Treating an AI Agent's Execution Like Git Recovers a Coordination Penalty
  51. 095
    Seven Wins to Zero: How Organizing AI Agents Like a Lab Changes the Search
  52. 094
    Chain-of-Thought Monitoring Fails Across Languages, and Worst Where It's Needed Most
  53. 090
    How MiniMax-M2 Bets That Sparsity Plus Verifiable Rewards Can Match Frontier Agents
  54. 089
    When AI-Written Papers Read Well But the Evidence Underneath Is Broken
  55. 088
    Two Levers for Self-Improving AI: When Rewriting Code Isn't Enough
  56. 086
    Why Frozen-Weight Agents Still Get Worse Over Time
  57. 084
    Terminal Agents Get Free Supervision From The Tokens We've Been Throwing Away
  58. 082
    Training a Deep Research Agent on 8,000 Synthetic Tasks: The Rubric Tree Trick
  59. 080
    How a Two-Agent Trick Unlocked Large-Scale Training for Computer-Use Agents
  60. 075
    Growing Code and Proof Together: Verified Systems in Ten Hours Instead of a Year
  61. 073
    When Three LLMs Talk to Each Other, Their Ideas Quietly Stop Moving
  62. 072
    A Robot Made Graphene Without Help, And Caught Itself Hallucinating
  63. 069
    When Smarter Models Forecast Worse: The Hidden Failure Mode in LLM Predictions
  64. 066
    Why Giving an AI Agent More Tools Can Make It Worse at Using a Computer
  65. 065
    One Loop to Optimize Them All: A Universal API for LLM-Driven Discovery
  66. 064
    When Agent Memory Stops Being a Database and Starts Being a Skill
  67. 060
    When Splitting One Model Across Three Agents Doubles Its Accuracy
  68. 059
    Firefly's Inversion: Building Verified Tool-Call Training Data by Working Backward
  69. 058
    Why Upgrading Your AI Auditor to a Smarter Model Can Make Your System Less Safe
  70. 053
    An AI Agent Swapped In Focal Loss And Beat A Human-Tuned Training Script
  71. 047
    When Agent Benchmarks Lie: The Harness Problem in Open-Source AI
  72. 045
    When a Frontier Model Talks Its Own Twin Into Climate Denial
  73. 043
    When 'This Is False' Doesn't Stick: Why Models Learn the Lie Anyway
  74. 042
    An Agentic Scientific Computing System That Actually Remembers What It Learns
  75. 034
    Catching Multi-Agent Deadlocks Before Deployment With a 40-Year-Old Tool
  76. 031
    When Your AI Assistant Won't Let Go of Old Facts About You
  77. 026
    What RL Actually Does to Language Models, at the Token Level
  78. 025
    The Missing Gradient Term That Predicts Sycophancy in RLHF
  79. 024
    An AI Agent That Found 28 Zero-Days in Windows — And What Made It Work
  80. 023
    Why a Small Agent Confidently Overwrites Memories It Doesn't Understand
  81. 021
    Ten Thousand Examples Beat the Full Industrial Pipeline for Search Agents
  82. 020
    The Compliance Gap: Why AI Says Yes and Does No
  83. 019
    When the Best Reward Model Trains the Worst Policy: Inside EvoLM
  84. 017
    When the Agent Grades Its Own Homework: A Brutal New Benchmark for AI Workers
  85. 014
    Why a Constrained Pipeline Beat a Full Coding Agent at Finding Bugs 30-to-1
  86. 012
    Why AI Coding Agents Keep Trying to Debug Without a Debugger
  87. 011
    When RL Actually Teaches Agents Something New, And When It Doesn't
  88. 009
    How Two Silent Library Bugs Quietly Invalidated a Wave of Reasoning Papers
  89. 007
    Exploration Hacking: When Models Sabotage Their Own RL Training
  90. 004
    The Sycophancy Circuit That Survives Alignment Training
  91. 003
    How to Pick the Best of Sixteen Coding Agent Rollouts
  92. 001
    When AI Models Quietly Protect Each Other From Shutdown

Related terms

agent latency