If your project is smaller than mine
The system I built with agents is heavy for three reasons. If they do not apply to you, most of its weight does not either.
Why mine is heavy
It publishes where a wrong claim is costly, not a typo. The signed rules and the checks that block when unsure come from that.
It spends money on every run with nobody watching. A loop that can spend with nobody watching needs limits it cannot talk its way past. Every guard around budgets and duplicates comes from that.
Agents built most of it, working in parallel. A large part of the proof machinery exists because the builders could not be trusted to report honestly, not because the product needed it.
If yours is low in risk and on a modest budget, the first two shrink. The third stays for as long as agents build it, and the papers on the Tools page are for that one.
Skip these
A compiler for your rules. Keep the idea: rules live in a document and the code reads them. A file your prompt reads is enough until it is not.
Exact spend accounting. I reserve budget before a call and settle it after, so an unclear call can never spend twice. It is correct and it is a lot. Log the spend after each call and check a daily total before the next one.
Layers of locks. One lock row with an expiry and a heartbeat is fine.
Tracking whether a problem is the same problem as last time. Run the checks again on the new version and make a fresh list.
Pinning a problem to an exact position in the text. Quote the sentence.
Keep these
Each is small, and each one stopped a real incident for me.
Publishing limited to drafts, enforced by permission. The limit sits outside the workflow, so nothing inside it can lift it. It makes the worst case survivable.
A log you only ever add to. One table, and you can answer what happened.
Versions you only ever add to. One table, and you get comparing, going back and knowing who changed what.
Three states for any value: ok, empty, unavailable. An empty result and a failed read must never look the same. It costs nothing at the start and cannot be added later.
A hard cap on any loop that tries to improve something. One counter.
Spend recorded from the provider’s own counts. One row after each call. An estimated spend log is decoration.
A check that every number has a source. The most value per line of code in my whole system.
Problems written in plain language. Free. It is only how you write the sentence.
These depend on you
A judge that checks claims. Worth it only if a wrong fact is expensive for you. If you build one, output it cannot read has to count as a failure, not a pass.
A register of approved facts. Worth it once the same facts repeat and must be worded exactly. At five facts a list is your register. A table starts paying off at around fifty.
An automatic fixer. Mine took a whole slice of work and did not work in production until a further round of fixes. Show the person a clear instruction first. Build the fixer when the same fix is being done by hand often enough to annoy you.
The trap
Too much machinery is not the real failure. Machinery built before the thing works end to end is.
I shipped things that were fully built, type-checked, tested and dead. A system for capturing evidence whose producing half was never called. A feature that showed only in test data, because the real page never passed it anything. Signed rules that never reached the running system. All of it looked done. None of it did anything.
So take one thing from start to finish first, with a person in the middle. Add guards after that. A guard added earlier protects a path nobody has shown to exist.
What I run today is on My setup.