I Turned Notion Into a Shared Brain for AI Agents (and it actually made sense)

The thing that bugged me

Every "AI + Notion" demo I've seen does roughly the same thing: you prompt a model, it generates text, the text gets dumped into a Notion page. Done.

It works. It's fine. But it's basically a fancy copy-paste.

The agent writes to Notion, but Notion doesn't do anything. It's a filing cabinet, not a workspace.

And that felt like a waste. Because Notion already has databases, relations, statuses, filters — all the building blocks of a workflow engine. We just... never let the agents use them.

So I had this thought: what if Notion wasn't the destination, but the coordination layer?

👉 github.com/CommonLayer/notion-blackboard

What if multiple agents could read and write to shared Notion databases, and that's how they'd collaborate — not through function calls or message queues, but through structured state that a human can see and touch at any point?

Meet Notion Blackboard

The idea is dead simple.

You write an objective in a Notion database. Something like "Prepare a competitive analysis of the AI code editor market."

Then a pipeline kicks in:

1. A manager agent reads your objective and breaks it into 3-7 concrete tasks (stored in a Task Queue database)
2. A worker agent picks up each task and produces a result (stored in a Results database)
3. A reviewer agent checks every result, scores it, approves or rejects it (logged in an Audit Log database)
4. The system compiles everything into one clean final report, published back to Notion

The punchline: none of these agents talk to each other directly. They coordinate entirely through Notion. The manager writes tasks, the worker reads them. The worker writes results, the reviewer reads them. It's asynchronous, inspectable, and weirdly elegant.

I call it a blackboard architecture — an old AI pattern from the 80s where agents share a common workspace instead of passing messages. Notion just happens to be a very nice blackboard.

Why this actually matters

Here's the thing about most multi-agent setups: they're black boxes.

You fire off a pipeline, stuff happens in memory, logs scroll by in a terminal, and eventually you get an output. If something goes wrong, good luck figuring out where. If you want to tweak the plan mid-run, too bad — the agents already moved on.

With Notion as the backbone, you get something different:

• The state is visible. Every task, every result, every review sits in a database you can browse.
• You can intervene. Don't like a task the manager created? Edit it. Think a result is garbage? Change its status before the reviewer gets to it.
• The audit trail is real. Not buried in a log file — it's right there in a database, filterable, sortable, shareable.
• The output lives where you already work. No "export to PDF" step. The final report is a Notion page your team can read.

It's not about making agents smarter. It's about making their work legible.

The tech under the hood

The stack is intentionally minimal:

• Python — because it's the lingua franca for this kind of thing
• Notion API — direct REST calls, no SDK wrapper needed
• OpenRouter — one API to call Claude, GPT-4o, Gemini, whatever you want
• Each agent uses a different model by default (Claude for planning, GPT-4o for execution, Gemini for review), but you can swap them freely

The repo comes with some quality-of-life stuff:

# Bootstrap the full Notion workspace (creates 6 databases)
python3 main.py --bootstrap --parent-page-id <PAGE_ID>

# Check that everything is wired correctly
python3 main.py --doctor

# Run the pipeline on all pending objectives
python3 main.py --process-objectives

# Try it without any API calls
python3 main.py "Your objective here" --dry-run

The dry-run mode is particularly nice for poking around — it simulates the full pipeline locally with fake data, so you can see the flow without spending tokens or setting up Notion.

What the Notion workspace looks like

The workspace has two layers, and the split is intentional.

What you see as a user:

• Objectives — where you write what you want done
• Final Reports — where you read the result
• Start Here — a guide page the system auto-generates

What's running backstage:

• Task Queue — the manager's work breakdown
• Results — the worker's intermediate outputs
• Audit Log — every agent action, timestamped
• Agent Registry — which agents are active and what model they're running

I had everything in one flat view at first. It was technically correct and completely overwhelming. The two-layer split made it click — you get the clean "objectives in, reports out" experience, with full transparency one click away if you want it.

What I'd build next

This is a working prototype, not a SaaS product. But the pattern has legs.

Things I'm thinking about:

• Retry loops — when the reviewer rejects a result, send it back to the worker automatically
• Parallel workers — right now tasks run sequentially, but Notion can handle concurrent writes
• Web research — let the worker agent pull in external sources, with citations
• A small web UI — so you don't need a terminal to trigger a run
• Better templates — richer formatting for the final reports

But honestly, the core loop already works and it's satisfying to watch. Write an objective, go make coffee, come back to a structured report with full traceability.

The bigger picture

I think there's a real gap between "AI can generate text" and "AI can get work done in a way humans can follow."

Most agent frameworks optimize for autonomy — let the agents figure it out, minimize human intervention. That's exciting, but it also means you're trusting a pipeline you can't see.

Notion Blackboard takes the opposite bet: make the process the product. Every step is visible, editable, and stored in a tool people already use daily. The agents aren't hidden behind an API — they're collaborators in a shared workspace.

That's the idea, anyway. It's a small project, but I think the pattern is worth exploring.

Check it out

The code is open source:

👉 github.com/CommonLayer/notion-blackboard

If you're into multi-agent workflows, Notion hacks, or just want to see what happens when you treat a productivity app as an AI coordination protocol — have a look, break things, and let me know what you think.