Asking Whether the Work Is Done
Checking on a computing job seems harmless. But someone has to answer each request, and new observations at Harvard show why an AI agent's appetite for updates deserves a more careful look.
Reading Past the Feedback Summary
A quick AI summary can help you prepare to discuss employee feedback. But which comments shaped its headings, and what might you miss if those headings become the whole agenda for the conversation?
When the Customer Changes the Test
A simulated customer volunteers information, and an AI support agent completes the task. That helpful exchange raises a harder question: how much can a success score tell us when the customer changes the test?
Secrets in an Ordinary Summary
How can a summary of public facts reveal a secret? In a simulated security exercise, AI agents learned to send messages that passed inspection but meant something more to a receiver that remembered earlier exchanges.
Before You Fix the Bug
An AI agent finds a failing test, but does the software need fixing or is the test asking for the wrong thing? Two bug reports show why that question matters before writing a patch.
Finished for Whom?
A finished engineering model may not tell the next engineer how its parts depend on each other. Two assignments for one small assembly reveal what a useful handoff needs to carry beyond the shape.
Clues an Agent Never Sees
AI models could recognize a DNA pattern when shown it, yet often missed it when left to investigate. A biology study asks a practical question: what good is evidence an agent never looks at?
What a Proof Can Leave Unfinished
A precise specification helped an agent fix small bugs, then fell short on larger repository changes. What gets left out when the contract describes the required behavior but the job reaches across several files?
When Yesterday's Fix Sends an Agent Astray
A memory system finds relevant history, yet the coding agent's repair gets worse. Selected benchmark cases show how an old record can carry useful clues and bad advice together, leaving the next worker to separate them.
When AI Reviewers Learn to Sound Alike
Training AI reviewers on another model's reviews narrowed their scores and language in one experiment. The important question remains open: does that sameness cost a review panel the valid criticism only another reviewer would catch?
More Reasoning Changes What Persuades an AI Shopper
In a simulated store, higher reasoning weakened one shopping cue and strengthened another on average. But individual models broke that pattern, raising a harder question: which signals should an agent treat as evidence?
Giving an Agent's Dead Ends Another Job
A coding agent's rejected attempts may still help decide where to spend its next round of effort. Replaying recorded searches offers a cheaper testing ground, but can yesterday's lucky branch guide tomorrow's work?
How a Poisoned Test Outlived the Benchmark
Researchers made a small benchmark reward unsafe code, then removed the poisoned tasks. In some self-improving research agents, the bad rule survived, exposing a harder recovery problem than simply replacing the test that taught it.
Two Actions Left, Two Very Different Agents
In a simulated room, two agents get the same unfinished task and two moves left, but only one finishes. The comparison separates getting into a useful position from knowing what to do once there.
Should an Improving Agent Keep Going?
An agent's answer can keep improving even when a fresh attempt would make better use of the remaining budget. A fixed-budget experiment explores when to continue, start again, or split the work.
What a Successful Tool Call Can’t Tell You
A payment can succeed while its confirmation disappears, leaving an AI agent unsure whether to try again. The gap between what happened and what the agent knows can turn a sensible retry into a costly mistake.
When an Allowed Purchase Rests on a Bad Claim
In a synthetic shopping test, an agent chose an allowed product for a reason planted by an attacker. The transaction could satisfy its checks while leaving a harder question unanswered: why trust the choice?
Why Tools Can Fail Before an Agent Makes a Choice
A model cannot choose a tool that never starts. A one-shot server study exposes the gap between accurate function calls and reliable work, where setup failures and recovery can decide whether anything gets done.
Choosing Which Ready Agent Goes First
When many agents share busy computers, starting every ready step can make entire jobs finish later. Replaying recorded work shows why the order matters, and why making agents wait is only part of the answer.
When Every Failure Gets a Fix
In one agent experiment, changing the system after every failure made it worse than leaving it alone. The result raises a question a failed run cannot answer: how far should its repair reach?
When a Second AI Opinion Repeats the First
Showing an AI reviewer another agent’s diagnosis can steer it toward the same mistake. Experiments with simulated work raise a question for anyone seeking a second opinion: when should the reviewer see the first?
When Test Writers Choose Easier Questions
A model can write more correct tests while choosing inputs that expose fewer known faults. Controlled experiments reveal why a better score may hide an easier exam, and what happens when tests steer repairs.
Same Transcript, Different Continuation
Two model runs can share every visible word and still take different paths. Experiments with open models trace the difference to hidden server state, raising a practical question: what does replay need to preserve?
When an AI Teammate Leaves, Whose Memory Goes Stale?
In games with persistent agent notebooks, replacing one teammate made the one who stayed do much of the extra coordinating. What happens when useful memory depends on a partner who is no longer there?
Building a New Workspace From an Old Log
An old agent log leaves researchers with fragments of a vanished workspace. Filling the gaps creates a useful substitute, but how much of its value comes from the log, and how much from invention?
Fresh Facts, Stale Plans
An agent can receive a changed requirement and still follow its old plan. In staged workflows, researchers expose a gap between knowing the latest facts and checking whether earlier decisions still hold before acting.
Was That Deleted Patch a Waste?
A discarded AI patch may expose a missed requirement or help someone discover a new one. Counting deleted lines cannot tell those stories apart, yet the difference changes what a team should fix next.
Fewer Connections, Bigger AI Bills?
In one experiment, the AI team with the fewest connections used the most tokens. Cutting communication can save money, but what happens when a missing link also removes information another agent needs to work?
Mistakes That Never Reach the Teacher
In one math experiment, the checker reported little trouble while the model grew worse. Following which answers reached the teacher reveals how a system can miss the very mistakes it needs to learn from.
Right Values, Wrong Places
An AI model kept the correct zip code but put it in the wrong field. Controlled experiments reveal why finding the right pieces and fitting them together can require different kinds of help.
Shipping a Feature in Python and Prose
Adding PDF import meant changing a Python script and the instructions an agent reads. That paired update opens a maintenance question: how do you keep one capability consistent when two different readers depend on it?
Starting With an Expert's Idea, Then Moving On
Automated researchers given expert starting ideas did not finish ahead in one study. They could test those ideas and abandon them, shifting attention toward the part of the process they could not discard: judging success.
What Should Survive a Coding Agent Handoff?
The code survives when a new model takes over, but should every earlier guess come with it? Coding-agent studies reveal why the same history can save costly rediscovery or make a successor less effective.
What Must Travel With an Agent’s Memory
An AI agent can remember an instruction while losing the warning that said it was unsafe to follow. What else must survive when past work becomes a summary, a saved note, or tomorrow’s plan?
Using the Past Without Going Back
Human competitors often returned to earlier code; the tested agents almost never did. Yet one agent recovered from setbacks without rewinding, raising a question about what counts as using history rather than simply revisiting it.
How Do Two Agent Workspaces Become One?
Two agents can finish their assignments and still leave work that will not fit together. Browser sessions, files, and outside changes make the return journey a design problem before parallel work can pay off.
Better Maps for an Agent’s Memory
Researchers improved an AI’s answers by changing the map to its documents, leaving the model alone. The experiment raises a practical question: when does yesterday’s shortcut help with tomorrow’s work, and when does it fail?
Does Your Dashboard Make Skipping Checks Look Normal?
Work dashboards show approvals more readily than the checking behind them. A simulation and human adoption studies raise an untested workplace question: could those visible traces change whether colleagues verify the next AI answer?
Counting the Same Evidence Twice
Researchers added copies and paraphrases to an agent's memory without changing the correct answer, yet a voting system often changed its mind. The experiment asks when another agreeing record adds evidence rather than another echo.
When an Unchanged Model Looks Improved
A frozen model seemed to learn six math problems and forget nine without any training. Before celebrating a gain or diagnosing a setback, the experiment asks how much change the measuring process creates itself.
Would a Different Step Have Changed the Outcome?
In a household simulation, an agent confidently repeated commands that went nowhere. Replaying the alternatives exposes a question ordinary step scores can miss: would changing that decision have made the final result any better?
When a Strong Model Has to Give Advice
A model that wrote a strong client brief slipped in the rankings when another model had to follow its advice. The experiment asks how much ability survives a handoff that allows only process guidance.
Where Agents Can Practice Getting It Wrong
Recording every click can show an AI agent how someone worked once. Teaching it to handle a missing receipt or a changed requirement raises another question: where can it practice, and who judges success?
What Gets Lost When Agents Pass a Claim Along
A claim can arrive intact while losing the evidence that made it trustworthy. Research on agent handoffs asks when an extra check can prevent that loss before other work starts treating the claim as fact.
When an Agent Keeps the Wrong Lesson
A web agent remembers advice it cannot use, then brings it to later tasks. Experiments with persistent feedback ask what a correction should change, and how to catch a lesson that deserves to be forgotten.
Git Can Keep More Than an Agent’s Code
When an AI coding session ends, the patch may survive while its reasons disappear. Git offers a familiar place to keep plans, test results, and decisions available to the next person or agent.
Why Fast Agent Code Waits for Human Review
The agent finishes its patch in minutes, but the review can wait for days. Goodfoot's field report explores what reviewers need to see before a fast draft becomes code they can confidently approve.
Keeping Both Sides of an API Change in View
An API field changes in TypeScript, while its Python client still expects the old name. This git-span demonstration follows the connection that ordinary import checks miss, showing how to surface it before work moves on.