Inspected by Pudicus

August 31, 2026

A computer monitor in a professional office displaying lines of code in a dark-theme editor, with a physical paper sticker reading 'INSPECTED BY 247' stuck directly onto the glass.

Agent swarms write a lot of code. They also skip git hooks. --no-verify is right there in the man page, and they've learned it. The hook we actually need is the one that scans for secrets and other sensitive information before the commit. After a key is in git history, you're rotating credentials and rewriting history. That's the expensive part.

Some people call the swarm a software factory0, others a model zoo or a coder agent swarm0. The volume is the same either way: because AI coding costs have collapsed, these things can fill a repo overnight. A human on every diff is already theater. As we've seen when giving our coding agents a boss, the leftover control isn't a person staring at the patch. It's whether the secret scanner ran on this tree, before the commit.

CI will not save you here. By the time a pipeline sees the commit, the secret is already in history.

The produce sticker

Think of a crate of apples leaving a farm. The farm owner doesn't personally bite into every apple before it goes on the truck. The crate gets an "Inspected By #247" sticker. A specific, trusted process checked it on the loading dock. No sticker, the truck doesn't leave.

Here the crate is a git commit. The inspection is a secret scan: Gitleaks, Tactus, whatever you pin. The sticker means that scanner ran on this tree, before the commit. The expensive failure is not "CI went red." It's a key sitting in git log.

Ask this of every cousin that looks like a control: Can you put this in the repo 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, and it's too late: the secret is already committed. Merge-green is not the same as the scan running before the commit.

The inspector is a named, pinned secret scanner — not the LLM that wrote the code. The object is this exact git tree. The mark is cryptographically required so a skipped hook doesn't land in the shared repo.

Later you can show: scanner X, version Y, checked this tree. That's paperwork with a checkable receipt. It's not a human LGTM, and it's not a general CI job.

If the commit can land without that record, or if the record can be yesterday's sticker on this morning's crate, you failed the test.

Catch it before the commit

"Shift-left" usually means finding a bug on a laptop is cheaper than finding it in CI, which is cheaper than finding it in production.0 Secrets are worse than bugs. Once they're committed, the fix is rotation plus history surgery. The check has to run at the moment the agent tries to commit, not after GitHub already has the object.

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. That's how secrets get in.

Treat that the way ITIL treats a change implemented without a ticket:

Never called the scanner. --no-verify, or a side door the hook does not cover.
Copied an old stamp. Last week's receipt pasted onto this tree. If you only check "is some sticker present?" the paperwork is stale.
Nobody looks later. A perfect receipt on the commit is a courtesy if deploy still accepts an unsigned tree.

Pudicus

Pudicus is out. It isn't a general CI tool. It's how we make sure the git hook actually ran and scanned for secrets before the commit.

A commit-msg hook runs a pinned scanner over the staged tree. If the scan is clean, the hook writes an HMAC receipt onto the commit: inspector identity, this git tree, the result, the time, a signature. Later stages check that receipt. No receipt, no deploy. The scanners behind the hook are pluggable: Gitleaks, Tactus, whatever you pin.

Architecture diagram showing the Pudicus Git Hook running scanners, minting a cryptographic signature, and later stages refusing a commit with no receipt.

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 secret scanner. Using it is easier than faking a checkable receipt. 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 hook we run on our own agent factories so secrets don't land in history. Overnight output is cheap. Cleaning a leaked key out of git isn't.

Signature pooling without rewriting history

Git commit hashes change if you modify a commit message, so you can't just add signatures to old commits without rewriting history (e.g., git rebase).

Pudicus ties the signature to the Tree Hash (the exact state of the files) 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. Later stages pool those signatures and check them against the tree you're about to ship.

Diagram showing how an Approval Commit signs previous trees, allowing later stages to pool valid signatures.

We're running Pudicus on all of our agent-written commits. You can view the source and install it from GitHub. If you need help keeping secrets out of agent-written history, talk to us at anth.us.