Yesterday afternoon, one of our agents prepped me for a client call and handed me a partial job. It skipped the pre-call checklist entirely. When I asked why there was no draft email to the client, it found the rule requiring one in two separate places, apologized, and wrote the draft. Then, while re-reading the procedure to make sure, it found two more steps it had skipped.
It was the same agent’s second bad day that week. Earlier, it had closed out a client call, leaving declined tasks open and the call unrecorded. Every one of those steps was written down plainly. The agent had read them. It didn’t do them.
My first theory was wrong
My first reaction was that I had been treating our agents like adults when they are more like smart home-schooled teenagers: brilliant, fast, and in need of clear instruction. That felt right (and clever) for about a minute.
The problem with the teenager theory is the fix it implies. If the agent is immature, you write clearer rules. We had already done that. Each of the four misses produced a new written lesson, a new rule, a sharper sentence in the procedure. The misses kept coming. Clearer instructions were what had already failed four times.
A better picture: an AI agent is a brilliant temp on their first day, and every day is their first day. They read the briefing binder fast, and they reason well. But they remember nothing from yesterday. At the end of the shift, they grade their own work: generously.
None of that is a character flaw. It is what the technology is. Each session starts from zero, so last week’s lesson is only as good as the note that carries it. And when a procedure is long, or calls other procedures, steps quietly fall out of view. The agent then treats “I read that step” as “I did that step.”
Experts fail the same way
This is not only an AI problem. It is a complexity problem, and it has a well-known answer.
In 1935, the Army Air Corps’ new bomber crashed on a demonstration flight, flown by one of its most experienced test pilots. He had forgotten to release a control lock. The plane was not too hard for a novice; it was too complicated for anyone to fly from memory. The fix was not a better pilot. It was the pilot’s checklist.
Atul Gawande told that story in The Checklist Manifesto, and then tested the concept in hospitals. A simple surgical checklist, used across eight hospitals in eight countries, cut major complications from 11 percent to 7 percent and deaths from 1.5 percent to 0.8 percent (Haynes et al., New England Journal of Medicine, 2009). Surgeons are not teenagers. They are among the most highly trained people in the world, and they still skip steps when the work is long and complicated.
Our misses fit that pattern. None came from a short task. They came from the longest procedure we run, one that calls five others, each with multiple steps.
What we changed
We stopped writing better rules and changed the structure around the work. Five pieces:
1. Match the control to the risk. We assign every procedure a tier, computed from its description, so nobody has to remember to opt in. Short internal tasks stay as they are. Long ones, or ones that call other procedures, get a checklist. Anything that sends, publishes, pays, deletes, or touches a client gets a checklist and an independent human check. Of the roughly 180 procedures we run, a bit over half stay untouched. The new process applies wherever a miss is non-trivial.
2. Compile the checklist; never ask the agent to write it. If you ask an agent to list every step of a nested procedure from memory, it rebuilds the top level and forgets the children. That is the original failure. So a small script now reads the procedure and everything it calls and produces one flat list. Our client call prep, which looked like eight steps, compiles to 55. The skipped step, the client email, had lived as a sub-item inside a sub-procedure. On the flatter list, it is a row like any other.
3. Every step closes with evidence, not a sentence. “Drafted the email” is a claim. A draft ID is evidence. A row on the checklist is closed only by something another reader can open: a file, an ID, a link, a check result. The script flags any empty row, any “evidence” that is just a sentence, and any row that quietly disappeared from the list. I tested it on yesterday’s miss: with every row filled except the client email, it flagged exactly that row.
4. The worker does not grade the work. For anything client-facing, a fresh agent that did none of the work gets the procedure and the checklist and is asked one question: which step is not proven? It is told to find the gaps, not to confirm success. Only after that does the request for my approval go out, and it carries one line: how many steps, how many flagged, and what the grader found. Software can’t stop an agent from asking without that line. I can: no line, no approval.
The grader earned its place on day one. Before I put any of this in front of you, I had a fresh agent grade the rollout itself. It found that my first version of the script accepted a sentence as evidence and never noticed a deleted row. Both were fixed the same morning.
5. A miss becomes structure, not a lesson. When something slips through, the fix goes into the checklist or the script, not into another paragraph of instructions. And if anyone edits a procedure in a way that drops a step, the edit has to say where that step went. That email step went missing in the first place because a rewrite meant to shorten the procedure quietly deleted it.
What this says about “managed”
Eleven days ago I wrote that we manage AI agents that learn on the job. This week taught me where that learning has to live. An agent does not remember. A note helps, but it's still something to read and skip. Learning that sticks has to be built into the work itself: the list it cannot lose, the evidence it cannot assert its way past, the check it does not grade.
That is most of what “managed” means. The model is the easy part to buy. The checklist, the evidence, and the second set of eyes are the management, and they're why a client can trust step 47 on a Tuesday afternoon.
Current view, subject to change
I approved this yesterday; we built it this morning, and our first real client runs are later this week. One limit: one of last week’s misses was that the agent never opened the procedure at all, and no checklist helps when nobody starts a list. We now require that every procedure of this kind begin by compiling its own checklist, and I don’t approve work that arrives without it. I expect the checklist to catch things before I do, which is the point. I am watching the number of misses found after an agent said “done.” The target is zero. If the system starts catching more misses before “done,” that is the system working, not a problem. If misses still reach me after “done,” the structure is wrong somewhere, and I will write about that too.
Final thoughts
I started the week thinking my agents needed to grow up. They don’t. They need what every capable professional facing a long, complicated procedure needs: a list they cannot lose, proof for every step, and someone else checking the work before it ships. Pilots figured that out in 1935.
Regards,
Charles Stack
Founder, Coworkers.Global