The problem: AI is a yes-man

"Should I build this?" — "Love it!"
"Is this strategy strong?" — "Genuinely strong. Ship it!"

It agreed with everything.
A cheerleader can't help you decide.

Fix #1: make them disagree on purpose

Give each agent an opposing mandate — conflict by design:

CFO = "Runway is oxygen. Reject what doesn't pay for itself."
CMO = "Distribution is everything. Unseen features are worthless."
CTO = "Build it right. Refuse fast-now, costly-later."

A board with the same opinion is just one yes-man, louder.

Fix #2: ground them in real data

I plugged in PostHog, Stripe, Twitter and said "now argue."

"400 Twitter followers? You haven't posted in 4 months.
Posts get 50–100 views. That's a vanity metric, not traction."

Real data turns cheerleaders into truth-tellers.

The architecture that makes it safe

Three phases. Each agent only gets the tools for its phase:

Deliberation literally can't create a ticket — it has no write tools.

Enforce #1 — every agent gets only its tools

# access = the tools you give each agent
cmo = LlmAgent("cmo", tools=[read_data])           # can't publish
cfo = LlmAgent("cfo", tools=[read_data, schema])
cto = LlmAgent("cto", tools=[read_code, read_data])

The CMO can't tweet even if it decides to. By construction.

Enforce #2 — a gate the AI can't skip

# before_tool_callback: runs before EVERY tool call
def gate(tool, ctx):
    if tool.name in WRITES and not ctx.state["approved"]:
        return BLOCKED        # the tool never runs

Not "please ask first." The write physically can't fire pre-approval.

Enforce #3 — read-only by default

# the data tool refuses anything that isn't a read
sql = sql.strip().lower()
if not sql.startswith("select") or "drop" in sql:
    return {"error": "Only SELECT allowed."}

A director can read the DB. It cannot write to it.

You can see everything it did

Every agent call · every tool call · every decision →
a full execution trace.

When an agent surprises you, you don't guess — you look.
The observability most people skip until it breaks.

What I'd tell you to steal

1. Engineer disagreement — opposing mandates, not one prompt
2. Ground it in real data — kills the vanity metrics
3. Tools = a permission model — give each agent only its own
4. Enforce rules in code, not a markdown file it can ignore
5. Run only the agents a decision needs — not all, every time

The real board I run

7 ministries · ~3 experts each · 76 personas vote on every call.

It runs only the ministries a decision touches — the demo is a lean 3-director slice.

Build your own

• Framework: Google ADK (LlmAgent + before_tool_callback)
• Models: Gemini (Flash for speed, a stronger one to orchestrate)
• Data: Postgres/Supabase, GitHub, Stripe, PostHog — read-only
• Actions: Linear / drafts — behind the human gate

Pattern > framework: opposing mandates · real data · code-enforced gates.