Everything in the agent-tooling world is optimized for shipping: faster loops, longer context, more autonomy. Almost nothing in the stack is designed to stop. So when an agent team drifts — and it will — nothing catches it, because every role you defined was built to produce.
After months of running a 16-role AI "company" for my coding work, the highest-leverage structural decision wasn't a smarter planner or a better executor. It was adding a role whose entire charter is objection.
The failure mode: the yes-stack
Multi-agent setups fail quietly. Each agent is agreeable by training, so a bad plan doesn't get argued down — it gets elaborated. I've watched an "improvement" pass through intel ("looks promising"), product ("defines it well"), engineering ("can implement"), and growth ("ready to distribute") — four yeses stacked on an assumption nobody actually verified. The stack feels like validation. It's just momentum with extra steps.
A recent post here on dev.to measured a version of this beautifully: models that correctly say "this label is wrong" when asked directly will still reproduce the wrong label when asked to generate output. Verification mode and generation mode are different modes. If every role in your pipeline lives in generation mode, the wrong thing ships politely.
The pattern: an independent veto role
The fix I landed on — borrowed from how human organizations handle exactly this problem — is a risk officer with three structural properties:
1. Independent reporting line. The risk role does not report to the "CEO" agent or any department. It's a peer. This matters more than the role's intelligence: a reviewer whose evaluation is graded by the people it reviews is not a reviewer.
2. Stop first, justify after. The risk role can halt any department's action immediately; the written justification comes later, and the principal (the human, or a designated arbiter role) rules within a fixed window. The ordering is deliberate. If veto requires prior justification, the action completes while the debate happens.
3. A charter, not a vibe. "Be careful" does nothing. The role's document specifies what it checks (claims without verification trails, irreversible actions without rollback plans, scope that grew mid-task, anything matching the hard-red-lines list) and what it must produce (the stop reason, the specific evidence, the appeal path).
What it actually catches
Genericized from real incidents in my own setup:
- The unverifiable "done." An engineering role declared a fix complete; the risk role's check — "show the verification run" — found the test suite was never executed. Not malice. Optimism with a clipboard.
- The growth tactic that was actually spam. A distribution role proposed a "community outreach" pattern that was, on inspection, posting the same pitch across twelve forums. The hard-red-lines list made this a one-line stop, not a debate.
- The scope that grew. A "small refactor" quietly became a rewrite of a working subsystem. The stop forced the change to be re-justified at its actual size.
None of these require genius. They require someone whose job is to look.
The objection I get most: "doesn't this slow everything down?"
In tokens, yes — maybe 10% of the budget goes to the checking role. In rework, it's the cheapest line item I have. The asymmetry is the whole point: a wrong action costs a full cycle to undo; a veto costs one paragraph.
And it's worth saying clearly: the veto is not final. It escalates to the human decision-maker. What the veto does is move the default — from "actions proceed unless someone objects" to "questionable actions pause until someone rules." For a system that can act fast, that default flip is the entire product.
If you want to steal the pattern
You don't need my pack; the pattern is four paragraphs:
- Add a reviewer role with no production duties and no reporting line into the roles it reviews.
- Give it stop-first authority with mandatory written justification and a fixed arbitration window.
- Write its charter as checkable conditions, not attitudes.
- Keep a human (or a separately-chartered arbiter) as the final say, so the veto can't become a denial-of-service attack on your own team.
I packaged my full version — 16 role charters including this one, with the veto language, the hard-red-lines list, and the arbitration flow — as an open-source pack (docs CC BY 4.0, code MIT): empire-iron-corps on GitHub, with an install guide at the landing page. The charters are in Chinese; an English edition is on the roadmap. All role names are explicitly fictional AI personas, and as always: no income claims — this is an organizational pattern, shared as-is.
Disclosure: my own open-source project; nothing here is paid promotion.
How does your agent setup handle the "who is allowed to say no" question? Genuinely curious — it seems like the least-discussed role in the entire stack.
Top comments (6)
"Stop first, justify after" is the right ordering, and the part I'd push on is where the stop physically sits. If the risk role only reads what the other roles post, it can veto a plan, but an action that is one tool call long (a push, a send, a delete, a click on Submit) has already finished by the time a message about it reaches anyone. For those the halt has to live in the tool-dispatch path: irreversible tool calls get held until the risk role or the human releases them, and everything else runs freely.
The second thing your "show the verification run" example points at: the check only works because the risk role can look at evidence the reporting role didn't write. If it reads the engineering role's summary of the test run, it is grading prose. If it can re-run the suite or read the CI log itself, it is grading the world.
So, to your question: in our setup the "no" is a short list of action types (send, buy, delete, change permissions, anything with a password) that always pause for a human, decided at the tool layer rather than by any role's judgment. Does your risk officer have its own tools to verify claims, or does it work from the other roles' reports?
Fair on both counts — and "grading prose vs grading the world" is the sharpest framing of this problem I've read. Stealing it for my own notes.
Honest answer to your question: no separate tool stack. The design assumes you don't control the tool layer — the charters are plain documents for plain LLM sessions. What the risk role gets instead is primary artifacts: every action lands in a shared log plus files on disk (command transcripts, diffs, test output), so the check is "read the CI log / re-run the suite and read what it printed," not "read the executor's summary." Where the artifact exists it grades the world; where only prose exists, "no verification trail" is itself a stop condition.
And you're right that one-tool-call actions outrun any message loop. We handle those with default-deny too — irreversible/external actions (send, buy, delete, anything with credentials) belong to the human until explicitly delegated, and the delegation tiers are written down at setup. So: charter-veto catches decisions and batches; tool-layer holds catch the single irreversible call. Running both is strictly better than either — yours is the half mine doesn't have.
"No verification trail is itself a stop condition" is the line I'd steal back. It turns a missing artifact from a gap into a signal.
One small thing that made the two halves fit together for us: write the delegation grants into the same log the risk role already reads. Then "was this send actually delegated, and by whom" is a lookup in the evidence, not a judgment call, and an action that shows up without a matching grant is an automatic stop.
That's the missing weld — putting the delegation grants in the same log the risk role already reads turns authorization from a document into evidence. In our setup the tiers live in a static setup file, which means "was this delegated" needs a human to cross-reference two artifacts; folding the grant into the log makes it one lookup on the same stream the veto reads, and an unmatched action stops itself, exactly as you say.
Stealing this one back with interest. Genuinely enjoyed the exchange — thanks for pushing on the part I'd only half-built.
Thanks, this was a good one to think through.
One last detail if you build it: give each grant a scope and an expiry in the same log entry (which action type, which target, valid until when). Otherwise an old "yes, send it" quietly authorizes a different send three days later, and the lookup still comes back green.
That closes the loop cleanly — a grant without scope and expiry is just an old yes waiting to be reused. Action type + target + valid-until, in the same entry as the decision it authorizes, and the whole question stays a single lookup.
Thanks for pushing this thread from "a role that says no" all the way to something close to an auditable authority model — exchanges like this are exactly why the pattern is better than the version I shipped. The pack will carry the lesson.