I Built a Multi-Agent AI Debate Arena Inside Notion Using MCP — Meet The Council

This is a submission for the Notion MCP Challenge

---

What I Built

Engineering teams constantly face difficult technical decisions.

PostgreSQL or MongoDB?

Microservices or monolith?

Offline-first mobile app or web-first architecture?

Usually the process looks like this:

1. Engineers research the problem
2. Everyone has different opinions
3. A decision gets made
4. The reasoning disappears forever

Six months later someone asks:

"Why did we make this decision?"

And nobody remembers.

I wanted to fix that permanently.

So I built The Council — a multi-agent AI debate system that runs directly inside Notion.

Instead of a single AI giving generic advice, four specialized AI agents debate a technical question from completely different perspectives.

Each agent:

• Reads the current Notion page

• Generates an argument

• Counters other agents

• Writes its reasoning back to Notion

After several rounds of debate, an Arbiter AI evaluates the arguments and produces the final decision.

Everything gets documented:

• every argument
• every counter-argument
• the final verdict
• action items

Technical decisions become permanent institutional knowledge.

---

Meet The Council

Each AI agent represents a different engineering priority.

⚔️ SENTINEL — Security & Risk

Focuses on vulnerabilities, worst-case scenarios, and system failures.

⚡ MERCURY — Performance & Speed

Analyzes latency, throughput, and developer velocity.

💰 MIDAS — Cost & Business Value

Translates engineering decisions into ROI and operational cost.

🌍 ATLAS — Scale & Architecture

Focuses on long-term scalability and technical debt.

Instead of balancing perspectives, each agent defends its viewpoint strongly.

That tension produces realistic engineering debates.

---

A Real Debate Example

I asked The Council:

Should we build an offline-first mobile app?

Round 1 — Opening Arguments

Each agent writes its argument directly to the Notion page.

SENTINEL

Offline-first apps store sensitive data locally.

A compromised device could expose user data instantly.

MERCURY

Our web application deploys in seconds and serves requests with low latency.

Mobile build pipelines slow development speed dramatically.

MIDAS

Offline-first development costs significantly more than web-first architecture.

ATLAS

Offline synchronization introduces complexity that becomes dangerous at scale.

---

Round 2 — Counter Arguments

Agents read the Notion page through MCP and challenge each other's claims.

Security challenges performance.

Cost challenges scale assumptions.

Performance challenges cost projections.

The debate evolves dynamically.

---

The Verdict

After two rounds, the Arbiter evaluates every argument and produces the final decision.

DECISION:
Build a web-first architecture with PWA offline support.

REASONING:
This approach maintains centralized security controls,
preserves fast development velocity, minimizes cost,
and avoids large-scale synchronization complexity.

The system automatically generates action items:

• Implement Service Workers
• Add IndexedDB caching
• Build unified CI/CD pipeline
• Audit client-side storage security
• Design scalable backend APIs

Everything is written directly into the Notion page.

---

What Happens When AI Cannot Decide?

Some engineering problems don't have a clear answer.

Instead of pretending certainty, The Council can declare a deadlock.

The Notion page shows:

⚖️ THE COUNCIL IS DEADLOCKED

Cast your deciding vote:

⚔️ SENTINEL — prioritize security
⚡ MERCURY — prioritize speed
💰 MIDAS — prioritize cost
🌍 ATLAS — prioritize scale

The engineer reads the debate and votes using the Vote property in Notion.

This creates a human-in-the-loop decision system.

AI prepares the analysis.

Humans make the final call when needed.

---

Video Demo

This demo shows the full workflow:

1️⃣ Create a Notion page

2️⃣ Set Status = pending

3️⃣ The Council begins debating

4️⃣ Agents write arguments live

5️⃣ The Arbiter publishes a final decision

---

Show us the code

GitHub repository:

TheCoderAdi / the-council

The Council — Multi-Agent AI Debate Arena (Notion MCP)

A Multi-Agent debate system that runs inside Notion using the Model Context Protocol (MCP) Four agents with distinct personas debate a technical question on a Notion page; an arbiter then writes a final decision, reasoning, and action items back to the page. Everything is done via MCP tools—no direct REST calls to Notion.

---

Quick summary

• Input: a Notion database page with the Question title and Status: pending.
• Process: watcher detects pending pages → opens MCP connection → runs 3 rounds (based on your choice) of parallel agent debates → arbiter writes decision.
• Output: Notion page updated with debate callouts, Decision rich text, Status set to completed

Agents: ⚔️ SENTINEL (security), ⚡ MERCURY (performance), 💰 MIDAS (cost), 🌍 ATLAS (scale).

---

What you'll find in this repo

• api/ — Express server and SSE endpoints for streaming debates to the dashboard.
• src/core/mcpClient.js —…

View on GitHub

Run locally:

git clone https://github.com/TheCoderAdi/the-council
cd the-council
npm install
cp .env.example .env
npm run dev

Example .env configuration:

NOTION_API_KEY=secret_xxx
NOTION_DATABASE_ID=xxx

GEMINI_API_KEY=xxx
GROQ_API_KEY=xxx

LLM_MAX_CONCURRENCY=2
LLM_MIN_DELAY_MS=150

---

How I Used Notion MCP

This project is built entirely around Notion MCP (Model Context Protocol).

Traditional integrations use the Notion REST API, where external code pushes data into Notion.

MCP changes the model completely.

With MCP, AI agents can use Notion as native workspace tools.

Agents can:

• read page content
• write blocks
• update properties
• query databases

Example MCP usage:

const context = await mcp.callTool(
  "API-get-block-children",
  { block_id: pageId }
);

Writing an argument block:

await mcp.callTool("API-patch-block-children", {
  block_id: pageId,
  children: [
    {
      type: "callout",
      callout: {
        rich_text: [{ text: { content: response } }],
        icon: { emoji: "⚔️" }
      }
    }
  ]
});

The agents operate inside the Notion workspace just like human collaborators.

---

Architecture

Notion Database
        │
        ▼
Notion Watcher
(detects pending debates)
        │
        ▼
Council Orchestrator
        │
        ├── SENTINEL
        ├── MERCURY
        ├── MIDAS
        └── ATLAS
        │
        ▼
Arbiter
        │
        ▼
Decision written to Notion

A real-time dashboard streams debate progress using Server-Sent Events.

---

Technical Stack

Layer	Technology
MCP Server	@notionhq/notion-mcp-server
MCP SDK	@modelcontextprotocol/sdk
Primary LLM	Gemini 2.0 Flash
Fallback LLM	Groq
Backend	Node.js + Express
Streaming	Server-Sent Events
Frontend	Vanilla JavaScript

---

Why This Matters

Most technical decisions disappear into Slack threads and meetings.

The Council turns engineering debates into structured, searchable knowledge.

Future engineers can see exactly:

• what arguments were made
• which tradeoffs were considered
• why the final decision was chosen

Instead of repeating the same debate every year, teams build decision history.

---

Try It

Drop a technical question in the comments.

I'll run it through The Council and share the full debate output.

---

Built for the Notion MCP Challenge