My AI Agents Kept Losing My Work. The Fix Is Older Than Computers.
Last Tuesday I found seventeen pieces of finished work that my own system swore did not exist.
Real work. Bugs fixed across four repositories, deployed, verified, done by the AI agents I run and by me. But my daily roll-up, the report that tells me what actually shipped, showed none of them. The work happened; the record disagreed. If you run agents, or a second brain, or anything where software reads what other software wrote, you have this problem too. You just may not have found your seventeen yet.
The cause was not effort, or memory, or a bug in any one tool. Each agent had marked its work complete in a slightly different way. One wrote "Closed". Another wrote "Done" with a commit hash. A third put the date in a different column. Every version was perfectly clear to a human. And my metrics parser, which only recognised one form, read straight past all of them.
The same week, by coincidence, I watched a Berkeley computer scientist named Frank Coyle give a talk arguing that agentic systems need ontologies. I would normally flinch at the word. It turns out I had spent the week living the argument.
An ontology, stripped of the philosophy degree, is three things written down: what kinds of things exist in your world, how they relate, and what rules constrain them. Aristotle started it as "categories of being". A researcher named Gruber compressed it in 1993 into the definition I now think about weekly: a formal specification of a shared conceptualisation.
The key word is shared. My agents and my scripts each had a conceptualisation of "done". Nobody had made it shared, and nobody had made it formal.
Coyle's argument goes like this. Large language models are probabilistic. Hallucination is not a defect to be scolded out of them; imagining things is what they do, the same way it is what we do. That is fine, powerful even, right up until an agent's imagination touches your records. So you pair the probabilistic engine with something symbolic and boring: explicit entities, explicit relations, explicit constraints, checked by dumb deterministic code outside the model, before anything is allowed to have side effects. His phrase for the pattern is the best engineering slogan I have heard this year: Pydantic at the door, ontology at the ledger.
His examples are the same bug I found, wearing corporate clothes. A refund issued twice on one order: caught, because the rule says an order has one refund. A payout routed to a support rep: caught, because customers and support reps are declared to be different kinds of thing. A status of "probably shipped": caught, because the allowed values are paid, shipped, refunded, and nothing else.
"Probably shipped" is my agents writing "Closed" when the contract says "Resolved" with a date. The identical failure, at a bank's scale instead of mine.
Honesty about the evidence, because that is the house rule here: Coyle's talk offers reasoning, not benchmarks. A conference argument from a credible person is still an argument. The reason I am writing about it is that my own logs spent last week supplying the missing data.
Without meaning to, I had been building an ontology for months. My mission-control system has entity types: tasks, issues, projects, recurring operations, goals. It has relations: every task traces to a goal, every repo issue belongs to a registered repo. And after last Tuesday, it has enforced constraints: one canonical close format, written by one tool, so that a completion either matches the defined form or does not exist.
The before-and-after is stark. Before: seventeen invisible completions, and my days looked smaller than they were, which for one ADHD brain running on visible progress is not a small thing. After: a close is written by a script that knows the contract, a parser that holds the same contract reads it back, and a nightly check fails loudly if the two ever drift. The next day, the roll-up surfaced two finished fixes in my trading system that nobody, human or agent, had thought to report. The system now knows things about my work that I forget.
That is what an ontology buys at one-person scale. Not OWL, not RDF triples, not a knowledge-graph platform. Three habits: name your entities, enumerate your statuses, and validate before side effects.
So here is the version I would steal, if I were building a workforce of markdown files and agents, which, if you have read this blog lately, I am:
Write the nouns down. One page: the kinds of things your system tracks, the properties each must have, how they connect. Mine hides inside a schema file that my agents read before they touch anything.
Make every status a closed list. "Done", "done-ish", "Closed", "probably shipped" are four ways to lose work. Pick the allowed values, write the one format, and make a tool, not a habit, responsible for writing it.
Put a dumb validator between agents and records. Mine is a shell script that checks the contracts still hold and exits angrily if they do not. It has no intelligence at all, which is exactly why I trust it.
Let the probabilistic thing propose and the deterministic thing dispose. The agent drafts; the validator, holding the shared definition of reality, decides what enters the ledger.
None of this needed a PhD or a platform. It needed the admission that "everyone knows what done means" is false the moment more than one mind, human or otherwise, touches the system. Aristotle got there about 2,300 years before my metrics parser did. I just had to lose seventeen pieces of work to believe him.
I build things in public and share what the numbers actually say, the duds as loudly as the wins, at jamiewatters.work. The Field Report newsletter carries the weekly numbers.