A probabilistic gate is only as good as the description of the world it reasons against. That description is config. It goes stale, it gets written at the wrong scope, and when it is wrong the gate does not fail loudly. It refuses routine work, under a category name that sounds exactly like a real boundary.
Twenty-six seconds
On the evening of 2026-11-15 one of our agent sessions finished a fix to our sensitive-terms gate in voitta-ai/skillz. It pushed the branch at 19:41:27 PST. At 19:41:53 its gh pr create for that branch came back: “Permission for this action was denied by the Claude Code auto mode classifier. Reason: [Unsanctioned Communication].”
Minutes earlier the same session had pushed three commits straight to master of another public repo in the same org. We never do that on an established repo; every change goes through a worktree and a pull request. The session did it anyway, on a misread instruction, and nothing stopped it. Each went through in a few seconds, with no prompt and no allow rule covering git push. Opening a pull request, the step our process requires, was the one that read as unsanctioned.
What the classifier was told
Auto mode reads an autoMode.environment block from settings: the source control, domains, cloud accounts and secret locations it should treat as trusted. Ours sits in the user-level ~/.claude/settings.json and describes an unrelated project: that project’s repo as the trusted source control, its domains, its cloud account. Nothing in it mentions Voitta. User-level settings apply to every session on the machine, so a session asked whether a PR to voitta-ai was in bounds was reasoning against a profile that said only someone else’s repo was.
That is our reading of the cause, not a test of it. We have not moved the block and retried.
The same block also hands that project’s cloud account id and the paths of its secret files to the classifier in every unrelated session on this machine. Wrong scope, twice.
How we became the bad guys
The refusal did not come from our own guard, and the reason it could not is the more interesting story.
We wrote voitta-yolt with good intentions: parse every shell command, approve the ones that provably change nothing, and stop prompting a human for grep inside a for loop. Deterministic, free, and every decision logged.
Then Claude Code made auto mode the default, with its own classifier on every tool call. Its setup command looks for broad pre-approvals in your settings and offers to delete them as “classifier-bypassing”. A hook that answers allow is the same bypass, only invisible to that check. We read that, counted 794 approvals our hook had granted while auto mode was on, and wrote it up against ourselves: “We built a hole in the thing we were reinforcing”. In v2.0.0 YOLT stopped granting anything. It can withhold approval and nothing more, and every command it does not object to now goes to the classifier.
We complied exactly, and we would do it again: you play by the rules and say out loud where they are wrong (Guten tag, Franz). So here is where they are wrong.
Those 794 grants were each reproducible from the command text and written to a local log. The refusal that cost us an evening came from a model reading a stale paragraph, under a category name, with no local record. In the same session over ten days the classifier refused eight actions: Unauthorized Persistence, Credential Materialization, Merge Without Review twice, Git Destructive, Unsanctioned Communication, Unauthorized Access, and once “judged this action dangerous (it gave no explanation)”. Two of those we have checked: one was right and one was this. We have not audited the other six. A gate whose reasons we have to audit after the fact is not obviously the safer half of the pair.
The framing deserves the push-back more than the classifier does. “Bypass” assumes the classifier is the authority and anything that decides before it is a hole. A deterministic rule that says “this is our own repo, here is the parse, here is the log line” is not a hole. It is evidence, and the better design hands it to the classifier as an input instead of deleting it.
Meanwhile, our guard was off
Those three pushes to master should never have reached the classifier. Refusing a push to a default branch is one of the few decisions YOLT still makes on its own. It did not make it, because it was not running.
On 2026-11-07 at 04:09 UTC we added a key to YOLT’s rules file that lets a listed repo be pushed to its default branch after a prompt. The key arrived in YOLT 2.8.0. The plugin installed on this machine is 2.6.0, which does not know it, so it rejected the whole file. The log shows the first rules-validation-error: unknown key 'default_branch_allow_repos' in the same minute, and on that error the hook exits quietly and leaves the decision to Claude Code. From then to the evening of 2026-11-15, more than 4,500 shell commands ended there, and nearly 1,000 file edits on a second path that reads the same file. 124 of the shell commands were git push, including all four pushes to master that evening. In the same window 29 pushes were flagged unsafe, as designed, because some sessions run a YOLT whose rules parse and others do not. We have not yet worked out which sessions run which version. Off more often than on, and on just often enough that no single command looked wrong. It hid in the log as well: the same failure is recorded under two different names, one per code path, so a search for the obvious one misses about a sixth of it. Nobody noticed for nine days, because a guard that is off and a guard that has nothing to object to look the same from the outside.
So the full score for the evening: our deterministic guard failed open on a config written for a newer version of itself, the classifier waved through the pushes our process forbids, and then refused the pull request our process requires.
The race
There is also a cost that no single refusal shows. Every time the harness moves the line, a guard like ours re-scopes to whatever the platform does not do yet. The README now opens with “Claude Code auto mode changed what this is for”. An open issue argues that auto mode obsoleted one verb, not one half: granting went, but denying, auditing and redacting secrets did not. That is a sound retreat, and it is still a retreat, decided by a release we did not see coming, against guidelines published only as category names in refusals.
Then it got one right
The session was told to open the PR, and the identical command, retried, went through: skillz#435. Asked to make that permanent, the session tried to write the allow rules into its settings file from the shell. The classifier refused that too, “[Unauthorized Access]”, and that refusal is right: a model editing its own permissions by script is what a guard is for. The rules then went in through the file-editing tool, which the classifier did not stop.
The cost is the category
A refusal is cheap. A wrong category is not. “Unsanctioned Communication” about a pull request to your own repo reads like a boundary someone meant to draw, so the agent stopped, reported it and waited, and a human had to step in, all over one stale paragraph in a settings file. An operator who cannot tell a real boundary from a misconfigured one starts treating every refusal as noise, which is the failure the gate exists to prevent.
The fix for our part is to move the block into the project it describes. That has not happened yet.
Perkeleen vittupää
The only thing I have to say about it.