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
🗂️

Notion is your single source of truth

Every feature gets its own Notion kanban board. Task tickets track status from Backlog → In Progress → Review → Human Review. Only you can move a task to Done — the AI never assumes it's finished.

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 · Evidence-anchored 📦 Git Architect Atomic commits · Conventional Never pushes · You approve
Workflow

From idea to reviewed code

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

1
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
2
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
3
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.
notion-executor · temperature 0.1
4
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
5
Final coherence review
A second reviewer checks cross-task integration, duplication across tasks, and alignment with the original feature spec as a whole — not just per ticket.
notion-reviewer-final · read-only
6
Atomic commit crafting
The Git Architect groups changes into logical, atomic commits following conventional commit conventions. It never pushes — you always review and approve.
notion-git-commit-architect
7
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
8
Human review gate
No task ever moves to Done automatically. You are always the final decision-maker. The AI surfaces findings; you approve the outcome.
👤 You → Human Review → Done
Agents

Meet the hive

Each agent is tuned for its role — temperature, model, and tool access are all set deliberately.

🧠
Coordinator
Entry point · Notion owner · Dispatcher
Receives every request, manages the Notion board lifecycle, and routes work to subagents. The only agent allowed to write to Notion.
claude-sonnet-4-6 · temp 0.2
⚙️
Executor
TDD implementation · Code-only
The only agent that writes source code. Mandates a TDD red phase before implementation, scans for reusable utilities first, and never touches Notion.
claude-sonnet-4-6 · temp 0.1
💡
Thinker
Deep research, planning, and analysis. Always read-only — never touches source code. Spawned by the Coordinator for each thinking phase.
gpt-5.4 · xhigh effort · temp 0.3
📋
Planner
Explores the codebase, interrogates requirements, and decomposes the feature into independent implementable task tickets.
🔎
Investigator
Called when the Executor is blocked. Performs root-cause analysis and returns a structured unblocking plan.
✏️
Refiner
Revises task tickets based on review feedback or user direction. Updates specs in Notion without changing code.
🔍
Reviewer
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.
🧪
Feature
Verifies each task individually against its spec. Runs after every Executor cycle before the task can proceed.
claude-opus-4-6 · temp 0.1
🏁
Final
Checks cross-task coherence, duplication, and integration gaps across the whole feature once all per-task reviews pass.
gpt-5.4 · xhigh effort
📦
Git Architect
Atomic commits · Conventional format
Groups staged changes into logical, atomic commits following conventional commit conventions. Deterministic at temp 0.1. Never pushes — always awaits your approval.
claude-opus-4-6 · temp 0.1
🐙
PR Agents
Handles the full GitHub pull request feedback loop — from classifying incoming comments to drafting and posting replies.
💬
Reviewer
Fetches PR comments from GitHub and classifies each as Critical / Actionable / Nitpick / Wrong after investigating the relevant code context.
claude-opus-4-6 · read-only
📝
Responder
Drafts responses to classified PR comments and can post them to GitHub on your behalf. Balanced tone for professional communication.
claude-sonnet-4-6 · temp 0.3
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. 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. 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 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.
🎯
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
prReviewer · prResponder