OpenCode Plugin · v0.3.0

AI coding sessions that
survive anything

Notion Agent Hive is an OpenCode plugin that uses Notion as a persistent memory layer — so your plans, reasoning, and progress survive rate limits, context exhaustion, and session deaths.

Get started View on GitHub
terminal 
# Install in one command
bunx @tesselate-digital/notion-agent-hive install

# Patches your OpenCode config automatically
# Then just open OpenCode and start planning
The Problem

LLM coding sessions are fragile

Every time you start a new session, the AI starts from zero. Plans vanish. Context is lost. Rate limits kill mid-flight tasks.

Without Notion Agent Hive
  • 💀 Plans live in temp folders and disappear between sessions
  • 💀 Models degrade when context approaches capacity mid-feature
  • 💀 Rate limit hits kill in-progress tasks with no recovery
  • 💀 No structured audit trail of decisions and reasoning
  • 💀 Reviews are skipped or self-reported — silent failures slip through
  • 💀 Git operations run unchecked, overwriting uncommitted work
With Notion Agent Hive
  • ✅ Plans and task tickets persist in Notion across all sessions
  • ✅ Subagents with focused contexts — no degradation
  • ✅ Automatic model fallback chains survive rate limits
  • ✅ Every decision, finding, and reasoning step is tracked
  • ✅ Mandatory review gates — evidence-anchored, non-skippable
  • ✅ Hard git guard: no push, stash, or force-operations without you
  • ✅ Released status tracks shipped work — agents skip it automatically
🗂️

Notion is your single source of truth

Every feature gets its own Notion kanban board. Tasks move through Backlog → In Progress → Review → Human Review → Done → Released. Only you can move a task to Done or Released — the AI never assumes it's finished or shipped.

Architecture

A hive of specialized agents

Each agent has a focused role and strict boundaries. Only one agent writes to Notion. Only one writes to your code. Reviewers are always read-only.

👤 You Feature request 🧠 Coordinator Owns Notion board · Routes work · Manages lifecycle 💡 Thinker Plan · Investigate · Refine Read-only · No code writes ⚙️ Executor TDD · Reuse scan · Implement Code writes · No Notion access 🔍 Reviewer Feature · Final · PR Fully read-only · Skips Released tasks 📦 Git Architect Atomic commits · Conventional Never pushes · You approve
Workflow

From idea to reviewed code

Nine deterministic stages. No shortcuts. Every gate must pass before the next begins.

1
Scope assessment (optional)
For features that look cross-cutting, the Scoper quickly triages which repos, services, or layers are affected — and whether to dispatch one planner or several.
notion-thinker-scoper
2
Deep research & interrogation
The Thinker-Planner reads the codebase, asks clarifying questions, and builds a full understanding of the feature scope before writing a single line of spec.
notion-thinker-planner
3
Task decomposition & Notion board creation
Work is broken into independent, implementable tickets. The Coordinator creates a Notion feature page with a full kanban board. This is your persistent record.
coordinator → Notion API
4
Reuse scan + TDD implementation
Before writing code, the Executor scans for existing utilities to avoid duplication. Implementation follows strict TDD: red test first, then make it green. Each task is tagged with its Repo.
notion-executor · temperature 0.1
5
Per-task feature review
An independent reviewer verifies each task against its spec. Every finding must cite file path and line number. No self-reports from the Executor are trusted.
notion-reviewer-feature · read-only
6
Final coherence review
A second reviewer checks cross-task integration, duplication across tasks, and alignment with the original feature spec as a whole. Released tasks are excluded.
notion-reviewer-final · read-only
7
Commit or stack structuring
Choose between atomic conventional commits or stacked PRs via gh stack. The appropriate architect groups changes, proposes a plan, and executes only after your approval.
notion-git-commit-architect / notion-stacked-pr-architect
8
PR review classification
When your PR gets comments, the PR Reviewer fetches them from GitHub and classifies each as Critical / Actionable / Nitpick / Wrong — with investigation and context.
notion-pr-reviewer · Claude Opus 4.6
9
Human review gate
No task ever moves to Done or Released automatically. You are always the final decision-maker. The AI surfaces findings; you approve the outcome and mark tasks as shipped.
👤 You → Human Review → Done → Released
Agents

Meet the hive

Each agent has a focused role with strict boundaries. Models are fully configurable per agent.

🧠
Coordinator
Entry point · Dispatcher
Receives every request, manages the Notion board lifecycle, and routes work to the right subagent. The only agent allowed to write to Notion.
💡
Thinker
Research · Read-only
Deep research, planning, and analysis. Always read-only — never touches source code. Spawned by the Coordinator in four modes depending on the phase.
Scoper Planner Investigator Refiner
⚙️
Executor
TDD · Code-only
The only agent that writes source code. Mandates a TDD red phase before implementation, scans for reusable utilities first, tags each task with its repo, and never touches Notion.
🔍
Reviewer
Quality gates · Read-only
Independent, evidence-anchored quality gates. Every finding must cite a file path and line number. Fully read-only — never trusts the Executor's self-report. Skips Released tasks.
Feature Final
📦
Git Architects
Commits & Stacked PRs
Structures your changes for review. Choose between atomic conventional commits on the current branch, or ordered stacked PRs via gh stack. Never pushes — always awaits your approval.
Commit Stacked PR
🐙
PR Agents
GitHub feedback loop
Handles the full GitHub pull request feedback loop — from classifying incoming review comments to drafting and posting replies on your behalf.
Reviewer Responder
Features

Built for ambitious features

Hard constraints, fallback resilience, and full auditability — for work that can't afford to fail silently.

🔁
Model fallback chains
Configure fallback model sequences per agent. When a rate limit hits, the system automatically retries the next model in the chain — no manual intervention needed.
🧱
Hard enforcement gates
TDD red phase before any implementation. No git stash. No skipping reviews. No task moving to Done or Released. These are non-negotiable rules enforced in every prompt.
📋
Persistent kanban boards
Every feature gets a Notion board. Tasks move through Backlog → In Progress → Review → Human Review → Done → Released. The board survives session restarts, rate limits, and context resets.
🔬
Evidence-anchored reviews
Every review finding must cite a file path and line number. No vague assertions. PASS or FAIL verdicts are always backed by concrete evidence in the code.
♻️
Reuse scanning
Before writing any new code, the Executor scans for existing utilities that could be reused. Prevents duplicate implementations across tasks and keeps the codebase clean.
⚙️
Per-project configuration
Override any agent's model, temperature, or fallback chain at the project level. Settings in ./notion-agent-hive.json take precedence over global config — without wiping other agents.
🏷️
Conventional commits
The Git Commit Architect groups and names commits following the conventional commit specification. Deterministic, atomic, and always awaiting your approval before any push.
🐙
GitHub PR integration
Fetch PR review comments directly from GitHub, classify them by severity, and optionally post drafted responses — all within your OpenCode session.
🥞
Stacked PRs via gh-stack
Choose between normal atomic commits or ordered stacked PRs. The Stacked PR Architect groups changes into layers, each becoming an independently reviewable PR on GitHub.
🏷️
Per-task repo tagging
The Executor tags each task with its repository name. The Coordinator can scope reviews and execution to specific repos — essential for multi-repo features.
🎯
Multi-vertical scope triage
For features spanning multiple repos or services, the Scoper quickly determines whether to dispatch one planner or several — avoiding wasted planning cycles.
🔀
Focused subagent contexts
Each subagent receives only the context it needs. No shared context degradation. Long features are handled through multiple focused sessions, not one bloated one.
Get Started

Up and running in minutes

One command installs the plugin and patches your OpenCode config automatically.

1

Install OpenCode

Notion Agent Hive is an OpenCode plugin. Make sure you have OpenCode installed and set up with your preferred LLM provider.

2

Configure Notion MCP server

Add the Notion MCP server to your OpenCode config and point it to your Notion API token. The plugin uses it for all board operations.

3

Run the installer

The CLI patches opencode.json and creates a starter config at ~/.config/opencode/notion-agent-hive.json.

4

Create a Notion board & start planning

Open OpenCode, tell the coordinator what you want to build, and provide your Notion page ID. The hive takes it from there.

Install 
bunx @tesselate-digital/notion-agent-hive install
notion-agent-hive.json — project config 
{
  "agents": {
    "executor": {
      "model": "claude-sonnet-4-6"
    }
  },
  "fallback": {
    "enabled": true,
    "chains": {
      "thinker": ["gpt-5.4", "claude-opus-4-6"]
    }
  }
}
Supported agent keys 
# Configure any of these per agent:
coordinator · thinker · executor
reviewer · finalReviewer
gitCommitArchitect · stackedPrArchitect
prReviewer · prResponder