Watch an agent's logs long enough and you will see it write the same bash script five runs in a row. If a human did that, you would pull them aside. Yet almost every agent deployment runs forward-only: trigger, execute, output, done. Nothing flows backward. The run ends and everything the system just learned evaporates.
I spent an hour this week with a founder running an AI-native tax and accounting firm in Berlin, and their architecture has the piece almost everyone is missing. After every successful run, a second agent reads the execution logs and asks one question: what should we skip next time? Repeated bash script? Make it a skill. Code review bot flagging the same error class on five consecutive PRs? The root cause is a misworded prompt — propose the fix. The suggestion lands in Slack. A human thumbs-up approves it. Ignored means rejected.
That is the whole loop: run data plus human guidance produces a better agent. And the reason most teams do not have it is structural, not technical. The person who catches an agent's mistake corrects the output and moves on — they were trying to finish their own work, not maintain the agent. So the same correction gets made five times by five people, and the prompt never changes. The fix is not asking humans to be more diligent. It is making the system propose its own corrections and route them through human approval.
None of this works unless your agents are actually software — defined in code, versioned in git, changed through reviewable diffs. If your prompts live in a UI text box, you cannot see who changed what, you cannot roll back, and you certainly cannot let an agent propose improvements safely. The back edge requires agents that are software, not prompts.
This founder put it in terms any operator understands: in payroll and tax, you cannot make the same mistake two months in a row and keep the client. Hold your agents to the same standard. If a failure mode survives five runs, the problem is not the model. It is that you never built the edge that points backward.
Related Essays
Non-Determinism Demands Human Correction Loops
Agents are non-deterministic by nature. The way they get smart is through human correction at scale, and the atomic mesh is what makes that tractable.
Controllability Is Not Optional. Enterprise Teams Do Not Want Magic
Enterprise teams do not want magic agents. They want control over which submodules load, which tools run, and what the agent remembers — because they have been burned by black boxes before.
Controllability Beats Magic Every Time
Enterprise teams do not want a black box agent. They want full control over how code gets written, reviewed, and shipped.
Key takeaways
- Most agent systems execute forward only — nothing learned from a run ever flows back into the agent definition.
- Human corrections evaporate because the person who fixes an output is done with their task and never fixes the prompt.
- The working pattern is run analysis plus a suggested change plus a human approval, all versioned in git.
FAQ
Why don't humans just update the prompt when an agent makes a mistake?
Because the person who hit the failure was trying to finish their own task. Once they correct the output, they move on. The fifth person to hit the same failure fixes it a fifth time. Without a system that proposes prompt and tool changes from run data, corrections never accumulate.
Should agents update their own prompts automatically?
No. The suggestion should be automated, the approval should be human. A change to an agent's prompt is a change to production software — it should arrive as a reviewable diff with a stated reason, so you can approve it, reject it, or roll it back.