Inspected by Pudicus
Imagine an entire factory of software developers working around the clock. But instead of human programmers drinking coffee, it's an "agent swarm"—a collection of specialized AI models wired together to write, test, and ship code continuously. Some people call this a software factory0, others call it a model zoo or a coder agent swarm0. Whatever the term, the result is the same: because AI coding costs have collapsed, these swarms can build entire products overnight while you sleep.
In traditional software development, we rely on a strict rule: a human must read and approve every line of code before it goes live. But when an army of AI bots generates thousands of lines of code an hour, human review becomes an impossible bottleneck. The old habit that "a human must review every diff" is on life support. As we've seen when giving our coding agents a boss, the leftover control is no longer a human manually approving every change.
If human review is theater, what stops a rogue or hallucinating agent from shipping broken code to your live servers?
The produce sticker
Think of a crate of apples leaving a farm. The farm owner doesn't personally bite into every single apple before it goes on the truck. Instead, the crate gets an "Inspected By #247" sticker. It means a specific, trusted automated process checked the crate before it left the loading dock. If the crate reaches the truck without that sticker, the truck doesn't leave.
In software, that crate is a batch of code (a git commit), and the truck is the deployment to your live servers.
Ask this of every cousin that looks like a control: Can you put this on the truck without the inspector’s mark? If yes, it is not this idea.
A Signed-off-by line is just a person typing that they certified origin. An AI-Assisted: label is just a costume. A required status check at merge is a merge gate. The truck is deploy. Merge-green is not the same as the crate leaving the dock.
Later you can show: procedure X, validator version Y, checked this tree. That's change-management paperwork with a checkable receipt. It's not a human LGTM, and it's not a provenance bundle for a container image.
If deploy will start without that record, or if the record can be yesterday’s sticker on this morning’s crate, you failed the test.
The ultimate shift-left
For years, the software industry has preached the concept of "shift-left"—moving security, testing, and quality checks as early in the development lifecycle as possible.0 Finding a bug on a developer's laptop is cheaper than finding it in a CI/CD pipeline, which is cheaper than finding it in production.
When you have a coder agent swarm generating thousands of changes an hour, you cannot wait for a central CI server to evaluate every hallucination. The check must be shifted all the way left: to the exact moment the agent attempts to commit the code. By making the deployment system require a cryptographic receipt of that local check, we tightly bind the left-most validation to the right-most delivery. It ensures the automated factory worker is wearing its safety goggles before the code is even allowed onto the conveyor belt.
Skip is the process hole
Git will let you walk around the inspector. Native hooks "can be bypassed with the --no-verify option."0 Agents have learned this. They stash, they quiet the hook, they commit on a runner that never had one.
Treat that the way ITIL treats a change implemented without a ticket:
- Never called the validator.
--no-verify, or a side door the hook does not cover. - Copied an old stamp. Last week’s receipt pasted onto this tree. If deploy only checks “is some sticker present?” the paperwork is stale.
- Deploy never looks. A perfect receipt on the commit is a courtesy if production apply does not fail closed.
Pudicus
Pudicus is out. It's an open-source inspection gate that writes checkable receipts for agent-written code.
A commit-msg hook runs a pinned checker over the staged tree. If the checker is clean, the hook writes an HMAC receipt onto the commit: inspector identity, this git tree, the result, the time, a signature. Deploy checks that receipt against the current validator and won't go without it. The scanners behind the hook are pluggable.
The agent can't mint the sticker. It doesn't hold the secret. So the easy path is letting the hook run.
That's Give an Agent a Tool: give it a business tool and it'll use the tool instead of inventing an answer. Here the tool is the inspector. Using it is easier than faking a checkable receipt, so the receipt is process evidence you can actually verify. In our own swarms, the failure mode is the one git already documented: agents skipping the checker with --no-verify.
Pudicus isn't a whitepaper. It's the gate we run on our own agent factories. Overnight output is cheap. Trust isn't. The leftover control is that the crate can't leave the dock without the mark.
Signature pooling without rewriting history
Because Git commit hashes change if you modify a commit message, you cannot simply add signatures to old commits without rewriting history (e.g., git rebase).
To solve this, Pudicus ties the signature to the Tree Hash (the exact state of the codebase) rather than the Commit Hash.
If an agent bypasses the hook with --no-verify, you don't have to rewrite git history. You can run pudicus approve, which creates an empty "paperwork" commit at the tip of your branch holding the signatures for the older commits. The deploy gate pools these signatures and checks them against the deployed tree.
We're running Pudicus on all of our agent-written commits. You can view the source code and install it from GitHub. If you need help operating agent factories with a gate, talk to us at anth.us.