We pushed the branch. Twenty-six seconds later, the PR was “Unsanctioned Communication”.

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.

Twice, the bug was the error message

An agent reads your error messages more carefully than any user ever has, and then acts on them. Give it a code and it guesses. Give it the cause and it reasons. Tell it what to do next and it tells the user. We learned this twice in one afternoon, on one page.

The page that said no

On 2026-11-13 I was helping a friend with a project built on Lovable. The question had nothing to do with Voitta. Partway through, mostly out of frustration, I clicked the Voitta bookmarklet on the project’s page.

The widget loaded. Chat worked. Every script the assistant tried to run on the page failed, even return 1+1, and the model told me it could confirm the page title and nothing else.

Error one: a code without a cause

What the model saw was {"ok": false, "error": "primitive_error", "message": "eval_threw"}. Our backend had the page’s full error in hand, message, stack and console logs, and reduced it to a code on the way to the model. Given “it threw”, the model could only give up.

Once browser_eval passed the whole error through, the model named the cause on its next try: the page’s Content-Security-Policy forbids eval, and retrying will not help. Same model, same page, same question. Only the error text changed.

The policy is script-src 'nonce-…' 'strict-dynamic' 'wasm-unsafe-eval' 'self' 'report-sample', with no 'unsafe-eval'. That is ordinary hardening, and the page was right to have it. The assumption was ours: every page tool we had ran through eval.

Reading a page needs no eval. read_page is a DOM read with a selector and a size cap. It was proposed, built and shipped the same afternoon, after 23 end-to-end checks against a local page served with the same policy.

Error two: a cause without a next step

On the first live try the model picked read_page on its own. The call failed, and the model told me the site was blocking that too: “a hard block from the site”.

It was not. The backend had been upgraded, but the tab still ran the widget it had loaded before the tool existed. That widget answered unknown browser tool read_page. Clicking the bookmarklet again would not have helped either, because the widget does not mount twice on one page. The error said none of this, so the model filled the gap with the most plausible story it had.

The fix is again a message, and this time it carries the next step: the site is not blocking anything; reload the page and click the bookmarklet again. In a later test turn the model relayed it as written: “The Voitta widget in your tab is outdated and doesn’t support reading the page. Please reload the page and click the Voitta bookmarklet again, then ask me to try again.” No blame on the site.

After a reload, the assistant read the whole page as text, about 8,400 characters. It was the first time it could read that page at all.

The rule

An error an agent will read has three parts: what happened, why, and what to do now. The first error had only the first part, so the model gave up. The second had the first two, so the model reasoned its way to a wrong answer. A wrong diagnosis said confidently to a user costs more than “I don’t know”, because the user acts on it.

What else real use found

The afternoon took seven pull requests and six releases (v0.2.16 to v0.2.21). Three of the faults appeared only because the tool was in real use rather than in a test:

  • A fresh clone would not build on Python 3.15: onnxruntime, which chromadb needs, has no wheel for it.
  • I pasted a screenshot into the chat with no text, and the turn failed with text blocks cannot have empty text. Images were supported; the message builder always added a text block, even an empty one.
  • Five releases in one afternoon meant five overlapping image builds, and an older one finished after a newer one and moved the :latest tag back to its own version. Now only the newest release moves :latest.

What the assistant still cannot do on a page like this is act on it. Clicking and typing go through eval. Asked where a setting was, it said it could not click around for me and gave me the steps instead. That was the right answer, given the rule above.