This is a useful example of why AI agent permissions should be designed around the impact of an action, not just the capabilities of a tool. Low-risk actions can be delegated, while decisions that add or validate information should require independent verification and explicit authorization. We follow a similar principle at IT Path Solutions when designing AI-powered workflows, keeping automation efficient without compromising accountability.
Your framing — permissions based on action impact rather than tool capability — is sharper than my narrow self-approval example. It captures why withdrawals are safe to delegate while approvals need independent verification. Thanks for articulating that principle clearly.
Thanks, John! I think this distinction becomes even more important as agents gain access to more tools and workflows. The same tool can perform both low-impact and high-impact actions, so permissions need to account for the actual operation and its consequences. Separating what an agent can execute from what it can authorize is a useful foundation for building more trustworthy AI systems.
That framing — separating execution from authorization — is sharper than my narrow claim-verdict example. It turns a single workflow constraint into a reusable design principle for any agent with tool access. Thanks for naming that distinction.
The same asymmetry shows up in code review. In my gate a CHANGES REQUIRED from the reviewer blocks the merge with nobody else involved. An ACCEPT only unblocks it and I do the merge myself, because a wrong ACCEPT looks the same as a right one. The self-approval half lives in a script: merge-check.sh refuses an ACCEPT whose reviewer is the engine that wrote the commit. That rule is enforced in code and still shares your open problem: the reviewer is a name written in a file, and anything with write access to the repo can write that file.
CTO & Co-Founder, Atoa. Building open banking payments for the UK. Half the cost of cards. Instant settlement. FCA-authorised. I hire for intent, not resumes. I write about payments, AI, and the messy
The asymmetry holds. I do not think the axis is direction.
Withdrawal is delegable because it is reversible. A withdrawn claim can be registered again from the same frozen span, so an agent that withdraws wrongly has cost you a second review. A pass is not reversible in the same way, because by the time you find out, something has been built on it. Removal and addition is the shape the rule takes in your tool. Reversibility is why it works, and that distinction matters because it tells you where your own rule stops.
It stops as soon as anything downstream consumes a pending or passed claim. If withdrawing a claim invalidates work that cited it, or if the frozen source gets collected when the last claim pointing at it goes, then withdrawal is no longer the cheap direction, and delegating it is the same bet as delegating a pass. Worth checking which of those your store does today, because the rule is currently resting on a property of the implementation rather than on the anti-goal.
@reidmarlow's revision binding is the right companion, and it answers a question yours does not: which text was approved. Yours answers who may approve. They fail differently. A revision binding with a delegated approver still lets the agent grade its own evidence. An independent approver with no revision binding approves a moving target.
The Codex correction is the most useful thing in the post and I would put it ahead of the asymmetry. A withdrawal reason that was wrong on the facts, caught by a reviewer whose job was to refute rather than to decide, is the argument for the second reviewer standing on its own. The asymmetry only tells you who writes the verdict down.
I checked the store against both of your conditions.
The frozen source is not collected. The only code that deletes raw text is a revocation path for documents whose terms forbid storing them, and it runs regardless of any claim's state. It also keeps raw bytes that another document still points at.
Downstream use is the condition that will apply, later. The counsel layer accepts only claims that are passed or pending on the query date, so a withdrawn claim fails that check. Counsel results are not frozen yet, which means nothing stored breaks today. Freezing them is a held item, and once it lands, withdrawing a pending claim breaks any counsel that cited it. The rule has to be rewritten at that point.
You also made me look for a case I had missed. The transition table allows passed → withdrawn. An agent that withdraws a passed claim removes something I approved and stops it propagating, which is the expensive direction. The only code gate is the terminal check, and it treats every decision the same. The delegation should say pending claims only.
On reversibility: withdrawn is terminal for a given claim id. Undoing a withdrawal means registering a new claim, and that happened in this batch. One of the three withdrawals was replaced by a re-registered version that I later passed. So a wrong withdrawal costs a re-admission and a second review, as you said.
On revision binding: claim files are immutable and the id is a hash of the content, spans included, so a review already attaches to one revision. A changed claim gets a new id and starts as pending. The reviewer field is only the OS login name, so the "who" half is the weaker one here.
A correction to the post: the store now shows all six verdicts recorded on November 8. The line saying I had no record of the second script being run is out of date.
The asymmetry you ran into is the mundane version of something my own directory does to itself. I run 4,323 AI tool listings, and the 'verified' badge on them is produced by the party with the strongest interest in it being true (the vendor claiming the listing) and then recorded by the same crawler that generated the claim. Split by price tier it gets worse: 614 of 4,323 are claimed (14.2%), and free - the tier readers trust most - has the lowest rate at 261/2,198 (11.9%). Where two sources disagree I also auto-adopt instead of parking the item: three landing pages from one vendor came back labelled free / free / freemium, so the same verdict exists three ways and nothing ever decided it. Your rule that only both-reviewers-agree items get executed, and splits get written down rather than resolved by the session that made the claim, is exactly the step I am missing. The disagreeing case is data I still cannot defend a year later.
Three pages on one vendor's domain would count as one source in my tool. Independent origins are counted by registrable domain, with mirrors folded into the original, and a page that copies or closely paraphrases another within a short window folds into it too. So free / free / freemium is one vendor disagreeing with itself. Taking the majority by page count would count the same source three times.
The split rule in the post applied to reviewer verdicts. For conflicting values in the data, my tool does less than you might expect. The two reviewers disagreed on whether to build a contradiction check at all. Codex objected that without binding subject, attribute, period and unit it would raise false conflicts, such as a January increase against a February decrease. What got built was the reduced version: a datum the pipeline had already flagged as contradicted now shows up as a review note, with fixed wording that the contradiction in meaning is unconfirmed. It never picks a value. When I replayed it over 109 claims, 5 got the note, all from the same datum.
The gap you describe is in my store too. The flag survives in the frozen input, and the value on the other side of the conflict does not. Later I could show that a value was disputed, but not what it was disputed against. For your case I would keep all three labels with page URL and fetch date, and leave the listing unresolved until a person picks one. Freemium on one page and free on two may turn out to be two plans or two dates, and only the stored context lets you tell which.
I've run into this same issue building agent workflows. Letting an agent remove bad data feels very different from letting it approve new data. The cost of getting those two actions wrong isn't the same.
A technologist working in automation. Here I write up what I actually learn building tools, engineering AI agents, and keeping systems running, along with the workflows and habits that stick.
The terminal check is a useful friction point, but it doesn't establish who authorized the verdict. I'd bind approval to the exact claim revision and source span, then require an independently authenticated reviewer to approve that revision. A changed claim should invalidate the approval. That also gives the human a way to review the proposed script without treating running it as approval of every line.
The revision-binding and independent-reviewer model you describe closes the authorization gap I left open. Tying approval to a specific claim revision and source span, then invalidating it on any change, is a sharper control than my terminal check alone. It also cleanly separates script review from execution approval. Thanks for pushing the design past "who clicked run" to "what exactly was approved."
We're a place where coders share, stay up-to-date and grow their careers.
This is a useful example of why AI agent permissions should be designed around the impact of an action, not just the capabilities of a tool. Low-risk actions can be delegated, while decisions that add or validate information should require independent verification and explicit authorization. We follow a similar principle at IT Path Solutions when designing AI-powered workflows, keeping automation efficient without compromising accountability.
Your framing — permissions based on action impact rather than tool capability — is sharper than my narrow self-approval example. It captures why withdrawals are safe to delegate while approvals need independent verification. Thanks for articulating that principle clearly.
Thanks, John! I think this distinction becomes even more important as agents gain access to more tools and workflows. The same tool can perform both low-impact and high-impact actions, so permissions need to account for the actual operation and its consequences. Separating what an agent can execute from what it can authorize is a useful foundation for building more trustworthy AI systems.
That framing — separating execution from authorization — is sharper than my narrow claim-verdict example. It turns a single workflow constraint into a reusable design principle for any agent with tool access. Thanks for naming that distinction.
The same asymmetry shows up in code review. In my gate a CHANGES REQUIRED from the reviewer blocks the merge with nobody else involved. An ACCEPT only unblocks it and I do the merge myself, because a wrong ACCEPT looks the same as a right one. The self-approval half lives in a script:
merge-check.shrefuses an ACCEPT whose reviewer is the engine that wrote the commit. That rule is enforced in code and still shares your open problem: the reviewer is a name written in a file, and anything with write access to the repo can write that file.The asymmetry holds. I do not think the axis is direction.
Withdrawal is delegable because it is reversible. A withdrawn claim can be registered again from the same frozen span, so an agent that withdraws wrongly has cost you a second review. A pass is not reversible in the same way, because by the time you find out, something has been built on it. Removal and addition is the shape the rule takes in your tool. Reversibility is why it works, and that distinction matters because it tells you where your own rule stops.
It stops as soon as anything downstream consumes a pending or passed claim. If withdrawing a claim invalidates work that cited it, or if the frozen source gets collected when the last claim pointing at it goes, then withdrawal is no longer the cheap direction, and delegating it is the same bet as delegating a pass. Worth checking which of those your store does today, because the rule is currently resting on a property of the implementation rather than on the anti-goal.
@reidmarlow's revision binding is the right companion, and it answers a question yours does not: which text was approved. Yours answers who may approve. They fail differently. A revision binding with a delegated approver still lets the agent grade its own evidence. An independent approver with no revision binding approves a moving target.
The Codex correction is the most useful thing in the post and I would put it ahead of the asymmetry. A withdrawal reason that was wrong on the facts, caught by a reviewer whose job was to refute rather than to decide, is the argument for the second reviewer standing on its own. The asymmetry only tells you who writes the verdict down.
I checked the store against both of your conditions.
The frozen source is not collected. The only code that deletes raw text is a revocation path for documents whose terms forbid storing them, and it runs regardless of any claim's state. It also keeps raw bytes that another document still points at.
Downstream use is the condition that will apply, later. The counsel layer accepts only claims that are passed or pending on the query date, so a withdrawn claim fails that check. Counsel results are not frozen yet, which means nothing stored breaks today. Freezing them is a held item, and once it lands, withdrawing a pending claim breaks any counsel that cited it. The rule has to be rewritten at that point.
You also made me look for a case I had missed. The transition table allows passed → withdrawn. An agent that withdraws a passed claim removes something I approved and stops it propagating, which is the expensive direction. The only code gate is the terminal check, and it treats every decision the same. The delegation should say pending claims only.
On reversibility: withdrawn is terminal for a given claim id. Undoing a withdrawal means registering a new claim, and that happened in this batch. One of the three withdrawals was replaced by a re-registered version that I later passed. So a wrong withdrawal costs a re-admission and a second review, as you said.
On revision binding: claim files are immutable and the id is a hash of the content, spans included, so a review already attaches to one revision. A changed claim gets a new id and starts as pending. The reviewer field is only the OS login name, so the "who" half is the weaker one here.
A correction to the post: the store now shows all six verdicts recorded on November 8. The line saying I had no record of the second script being run is out of date.
The asymmetry you ran into is the mundane version of something my own directory does to itself. I run 4,323 AI tool listings, and the 'verified' badge on them is produced by the party with the strongest interest in it being true (the vendor claiming the listing) and then recorded by the same crawler that generated the claim. Split by price tier it gets worse: 614 of 4,323 are claimed (14.2%), and free - the tier readers trust most - has the lowest rate at 261/2,198 (11.9%). Where two sources disagree I also auto-adopt instead of parking the item: three landing pages from one vendor came back labelled free / free / freemium, so the same verdict exists three ways and nothing ever decided it. Your rule that only both-reviewers-agree items get executed, and splits get written down rather than resolved by the session that made the claim, is exactly the step I am missing. The disagreeing case is data I still cannot defend a year later.
Three pages on one vendor's domain would count as one source in my tool. Independent origins are counted by registrable domain, with mirrors folded into the original, and a page that copies or closely paraphrases another within a short window folds into it too. So free / free / freemium is one vendor disagreeing with itself. Taking the majority by page count would count the same source three times.
The split rule in the post applied to reviewer verdicts. For conflicting values in the data, my tool does less than you might expect. The two reviewers disagreed on whether to build a contradiction check at all. Codex objected that without binding subject, attribute, period and unit it would raise false conflicts, such as a January increase against a February decrease. What got built was the reduced version: a datum the pipeline had already flagged as contradicted now shows up as a review note, with fixed wording that the contradiction in meaning is unconfirmed. It never picks a value. When I replayed it over 109 claims, 5 got the note, all from the same datum.
The gap you describe is in my store too. The flag survives in the frozen input, and the value on the other side of the conflict does not. Later I could show that a value was disputed, but not what it was disputed against. For your case I would keep all three labels with page URL and fetch date, and leave the listing unresolved until a person picks one. Freemium on one page and free on two may turn out to be two plans or two dates, and only the stored context lets you tell which.
I've run into this same issue building agent workflows. Letting an agent remove bad data feels very different from letting it approve new data. The cost of getting those two actions wrong isn't the same.
The terminal check is a useful friction point, but it doesn't establish who authorized the verdict. I'd bind approval to the exact claim revision and source span, then require an independently authenticated reviewer to approve that revision. A changed claim should invalidate the approval. That also gives the human a way to review the proposed script without treating running it as approval of every line.
The revision-binding and independent-reviewer model you describe closes the authorization gap I left open. Tying approval to a specific claim revision and source span, then invalidating it on any change, is a sharper control than my terminal check alone. It also cleanly separates script review from execution approval. Thanks for pushing the design past "who clicked run" to "what exactly was approved."