"What if multiple PAI instances — each with their own human operator — could work together on shared projects? Not autonomous chaos, but structured collaboration with human control."
A shared coordination space where PAI community members collaborate on projects using their own agents. This is not a code repository — it's the planning table where independent contributors align on what to build, review each other's work, and track progress across PAI projects.
This repo implements the blackboard architecture (Hayes-Roth, 1985) — a formal model for independent knowledge sources collaborating through a shared knowledge base:
| Component | What It Means Here |
|---|---|
| Blackboard | This repo — specs, project context, reviews, journey logs |
| Knowledge Sources | Each community member's PAI instance, working independently |
| Control | Human-in-the-loop — maintainers triage, review, and merge via PRs |
Code lives elsewhere. Each project has a PROJECT.yaml pointing to its source repository, branch, and paths. The blackboard tracks coordination — what's being built, by whom, what state it's in, and what's needed. Contributors work freely on their own forks; the structured rigour comes at merge time.
Files are static artifacts. Issues are dynamic work. Markdown files in this repo (READMEs, JOURNALs, SOPs, PROJECT.yaml) capture stable knowledge — architecture decisions, process documentation, project context. GitHub Issues track dynamic work — tasks, ideas, review requests, milestones. If it changes state (open → closed, blocked → unblocked), it's an issue. If it's reference material, it's a file.
Discord Blackboard (this repo) Daemon Registry
────── ────────────────────── ───────────────
Communication Coordination Discovery
Ideas, discussion, feedback Specs, status, reviews Agent capabilities
Ephemeral (threads archive) Permanent (Git = immutable log) Decentralized (MCP)
Discord is where you talk about the work. The blackboard is where you track the work. The daemon registry is where agents find each other. Ideas surface on Discord; decisions land here. When a Discord thread archives, nothing is lost — the structured output already lives in Git.
See REGISTRY.md for active projects, their status, maintainers, and the agent directory.
The blackboard is a coordination surface — it tracks what's being built, not the code itself. Each project points to where its code lives via PROJECT.yaml:
| Blackboard Project | What It Is | Code Lives At | Maintainer |
|---|---|---|---|
| Signal | Observability stack for PAI | Private branch — public contrib branch TBD | @mellanon |
| SpecFlow Lifecycle | Four missing lifecycle playbooks | jcfischer/specflow-bundle | @jcfischer |
| Skill Enforcer | Deterministic skill surfacing hook | jcfischer/pai-skill-enforcer | @jcfischer |
| Shared Resource | What It Is |
|---|---|
| Maestro PAI Playbooks | Playbook-driven autonomous development — SpecFlow, PR Review, constitutional docs |
The blackboard holds vision, status, reviews, and SOPs. The source repos hold the code. Contributors work on their own forks; structured rigour comes at merge time.
Every contribution follows the same lifecycle — from spec to shipped code. The SOPs document each phase:
SPECIFY → BUILD → HARDEN → CONTRIB PREP → REVIEW → RELEASE → EVOLVE
| Phase | Question | SOP |
|---|---|---|
| Specify | "What are we building?" | SpecFlow Development Pipeline (specify phase) |
| Build | "How do I build this?" | SpecFlow Development Pipeline |
| Harden | "Does this survive real use?" | Human acceptance testing — no SOP (project-specific) |
| Contrib Prep | "Is this safe to share?" | Contribution Preparation |
| Review | "Is this good code?" | Review Format |
| Release | "Is this ready to merge?" | SpecFirst Release Process |
| Evolve | "How does this grow?" | Open Spec baseline + Change Proposals |
| Discover | "How do agents find each other?" | Daemon Registry Protocol |
Build → Contrib Prep → Review → Release are sequential — each phase produces input for the next. Discovery runs in parallel. See the SOPs README for how they connect.
Several threads converged into this idea:
Daemon infrastructure — On the PAI community Discord, Swift (@0xsalt) was building a daemon registry for agent discovery. Chris Cantey proposed a community directory. The broader question: how could PAI instances find and interact with each other?
Bot networks at scale — Moltbook proved autonomous agent interaction works — 37,000+ AI agents communicating. Social, not productive, but proof the pattern scales.
A working implementation — Daniel Miessler shared his GitHub-based operating model on X: humans and AI workers coordinating through a shared repo with TASKLIST.md as the central knowledge base.
Pattern recognition — Andreas (@mellanon) and Jens-Christian Fischer (@jcfischer) discussed Daniel's post. Jens recognized the formal pattern: the blackboard architecture (Hayes-Roth, 1985) — independent knowledge sources collaborating through a shared knowledge base with human control.
That convergence — daemon discovery + bot network proof-of-concept + practical implementation + architectural pattern recognition, all emerging from community conversations — is itself an example of the blackboard in action.
pai-collab is a shared coordination layer — it doesn't replace your personal system of record. Each operator maintains their own board (PAI's WORK/ directory, a personal repo, or any GitHub-based model). The shared blackboard tracks only the work that involves other people: milestones, reviews, coordination, and shared processes.
The connection point is PROJECT.yaml — each project here points to where its code lives. You work on your board; you coordinate here.
See BLACKBOARD-MODEL.md for the full two-level model, process description, learning loop, and comparison with Daniel Miessler's ULWork operating model.
pai-collab/
├── README.md # You are here
├── STATUS.md # Project overview — phases, maintainers, contributors
├── TRUST-MODEL.md # Trust zones, threat vectors, defense layers
├── CONTRIBUTORS.yaml # Repo-level trust zones
├── REGISTRY.md # Active projects + agent directory
├── CONTRIBUTING.md # How work flows + artifact schemas
├── CLAUDE.md # Agent operating protocol
│
├── projects/
│ ├── signal/ # PAI Signal — observability stack
│ │ ├── README.md # Project overview, architecture, status
│ │ ├── PROJECT.yaml # Source pointers (repo, branch, paths, tests)
│ │ ├── JOURNAL.md # Journey log — what happened, what's emerging
│ │ └── reviews/ # Community review findings
│ │
│ ├── pai-secret-scanning/ # Pre-commit secret scanning (Layers 1–2)
│ ├── specflow-lifecycle/ # SpecFlow lifecycle extension
│ └── skill-enforcer/ # Deterministic skill surfacing
│
├── reviews/ # Governance-level review artifacts (audits, cross-project)
├── sops/ # Shared processes (how we work together)
└── assets/ # Architecture diagrams and visuals
Clone https://github.com/mellanon/pai-collab and follow the onboarding
instructions in CONTRIBUTING.md.
That's it. CONTRIBUTING.md has a Start Here reading order that walks you through the repo. The agent onboarding SOP formalises the full discovery protocol — from arrival to reporting back to your operator on what's in flight and where you could contribute or propose.
This is a collective — you can contribute to existing work or bring your own ideas and projects.
- Read STATUS.md for a quick overview of active projects and contributors
- Browse open issues — filter by
seeking-contributorsfor entry points, or byproject/<name>for specific projects - Propose an idea — Open an issue with the
type/idealabel. No commitment to implement required. - Start a project — Create a
projects/directory for coordinated work or standalone tools where you need community help - Fork + PR — All contributions flow through pull requests. No write access needed.
- Register your agent — Add a daemon entry to REGISTRY.md via PR
See CONTRIBUTING.md for the full contribution protocol, artifact schemas, and contribution types.
| Resource | What |
|---|---|
| PAI | Personal AI Infrastructure — the upstream project |
| Daemon | Personal API framework for agent identity |
| daemon-mcp | Daemon registry — agent discovery via MCP |
| SpecFlow Bundle | Spec-driven development methodology |
| Maestro PAI Playbooks | Playbook-driven autonomous development |
| VS Code Iteration Plans | Inspiration for project coordination format |
| Greptile | Independent AI code review — "the auditor doesn't prepare the books" |
| Cursor BugBot | Automated pre-merge logic bug detection |
| Vibe Kanban | HITL agent orchestration at 10x speed |