From Notion Idea Graveyard to Founder OS: Run Plan Review (with MCP)

This is a submission for the Notion MCP Challenge

What I Built

I built AI Founder OS — a human-in-the-loop, MCP-native workflow engine that turns Notion into an AI-powered Founder Control Plane.

The story (why I built this)

I used to have a “graveyard” in Notion.

Not a horror-movie graveyard — a founder graveyard:

• pages titled “Idea v12 FINAL”
• half-written docs called “MVP plan (draft)”
• scattered competitor notes copied from random tabs
• marketing bullet points that always ended with “TBD”

Every time I got excited about an idea, I’d do the same ritual:
1) I’d open Notion.
2) I’d write a passionate paragraph about the idea.
3) I’d promise myself I’d “do the research tomorrow.”
4) Tomorrow would come, and I’d avoid it… because the first planning pass is painful.

Not because it’s hard. Because it’s friction:

• researching competitors is repetitive
• writing the first roadmap is cognitively expensive
• marketing plans are blank-page torture
• and even when AI helps, outputs are messy, not structured, and hard to trust

So I built an OS that makes Notion behave like a control panel:

If an idea is real, it should survive a button press.

What it does (Notion as the Control Plane)

AI Founder OS keeps Notion as the single source of truth, but makes it executable.

You keep four Notion databases:

• Startup Ideas (the control plane)
• Competitors (generated + curated)
• Roadmap (generated + curated)
• Marketing (generated + curated)

Then the workflow is:

1) You add an idea to Startup Ideas
2) You set Status = Run
3) AI Founder OS generates a structured “first pass” and writes it back into Notion:

• competitor research rows
• prioritized roadmap items
• marketing tactics/campaign ideas

Now the idea is no longer a paragraph — it becomes a set of actionable artifacts.

The part that makes it “real”: Human-in-the-Loop Corrections

Here’s the thing: AI drafts fast, but humans own the truth.

So I built a correction loop directly into Notion:

Each generated output row can have:

• Needs Review ✅ (checkbox)
• Correction Notes 📝 (rich text)

When you flag a row and write your correction, AI Founder OS:

• finds the flagged rows
• reads your correction notes
• regenerates only those rows (not the whole plan)
• updates the row by page_id
• unflags it and clears notes

That loop turns AI Founder OS from “generator” into “system”:

Draft fast → review in Notion → patch precisely.

Why this isn’t just a hackathon demo

Under the hood, it’s built to behave like a workflow engine, not a toy:

• schema checks (fail fast if Notion DB properties don’t match)
• claim/lock + idempotency (no duplicate runs)
• resilient JSON generation (Gemini JSON + repair + fallback)
• MCP tools are stable and demo-friendly

Latest Release: v0.2.1-human-in-loop

Repo: https://github.com/Sherman95/ai-founder-os

---

Video Demo

Video link: <PASTE_YOUR_VIDEO_LINK_HERE>

What to record (30–45 seconds, dramatic + clear)

1) Show Notion “Startup Ideas” with an idea called something like:

“I swear this one will ship”
2) Set Status = Run
3) In VS Code, call founder.run_idea
4) Flip back to Notion: Competitors/Roadmap/Marketing rows appear
5) Pick one row that looks slightly wrong, mark:

• Needs Review = true
• add a sharp correction in Correction Notes (e.g. “This competitor isn’t direct. Replace with X and focus on Y.”) 6) In VS Code call:
• founder.list_reviews
• founder.apply_corrections 7) Show the row updated + unflagged

That’s the “wow” moment: Notion is the cockpit, MCP is the wiring, AI is the engine, human is the pilot.

---

Show us the code

GitHub repo: https://github.com/Sherman95/ai-founder-os

Latest release/tag: v0.2.1-human-in-loop

Quickstart (local)

git clone https://github.com/Sherman95/ai-founder-os.git
cd ai-founder-os
git checkout v0.2.1-human-in-loop
npm install
cp .env.example .env

Fill .env with:

• GEMINI_API_KEY=...
• Notion DB IDs:
  • NOTION_STARTUP_IDEAS_DB_ID
  • NOTION_COMPETITORS_DB_ID
  • NOTION_ROADMAP_DB_ID
  • NOTION_MARKETING_DB_ID

Start the Founder OS MCP server:

npm run mcp

Run the guided challenge demo:

npm run demo:challenge -- <ideaPageId>

---

How I Used Notion MCP

Notion MCP is the “superpower layer” in this build: instead of writing fragile wrappers around a rigid API, I treat Notion like a tool-enabled workspace.

1) Notion MCP hosted server (OAuth-based workspace access)

VS Code connects to Notion via the hosted MCP endpoint:

• https://mcp.notion.com/mcp

This gives secure OAuth access and exposes Notion operations through an MCP tool interface.

2) AI Founder OS as an MCP Server (workflow-level tools)

AI Founder OS runs as its own MCP server and exposes workflow tools that orchestrate the pipeline from VS Code:

• founder.health
  
  Verify status and version.

• founder.run_idea
  
  Runs the full pipeline (analysis → competitors → roadmap → marketing) and writes structured rows into Notion.

• founder.list_reviews
  
  Lists any output rows flagged with Needs Review = true.

• founder.apply_corrections
  
  Reads Correction Notes, regenerates only flagged rows, updates them by page_id, and unflags them.

What MCP unlocked (why it matters)

• Notion becomes executable: statuses + review flags in Notion drive the system.
• The workflow becomes inspectable: every step writes artifacts back into Notion databases.
• Human-in-the-loop is natural: the correction UI is Notion itself — no extra frontend needed.
• It’s judge-friendly: everything is reproducible via MCP tool calls from VS Code.

If you’ve ever had a Notion idea graveyard… this is my attempt to build the opposite: a system that forces ideas to become plans, and plans to become reality.