CoCo Super Intelligence

Summon an advisory board of 389 world-class minds — right inside your AI coding session.

CoCo Super Intelligence is the orchestration layer that turns Claude Code, Cursor, or Codex into an entire engineering department: routed expert panels that deliberate and decide, then 185 skills, 280 commands, and disk-persistent state that ship what they decided.

Open-core (MIT core · proprietary Super Intelligence) · installs in 90 seconds · 100% local · no telemetry

     Install        The Board        Framework        Skills        Systems        Demos  

git clone https://github.com/coco-research/coco.git && cd coco && bash install.sh

What CoCo Is (and Isn't)

CoCo is not a new AI model, and it is not another agent harness. It doesn't run a model or an agent loop of its own. It's a portable layer of Markdown and YAML that installs into the agent harness you already use — Claude Code, Cursor, Codex CLI, or any AGENTS.md-compatible tool — and upgrades it with an expert advisory board, a skills library, persistent project memory, specialized subagents, and verification gates.

Your model, your tool, your keys, your machine. When you see "parallel subagent waves," those subagents are executed by your host harness's own agent machinery; CoCo supplies the orchestration structure that makes it all behave like a coordinated team. That is exactly why CoCo is vendor-neutral: it's the operating layer, not the engine.

⭐ The Board — CoCo Super Intelligence

A cross-team advisory board of 389 world-class minds

Super Intelligence is CoCo's signature capability. It lets you summon custom, real-world expert panels directly inside your coding session to guide architectural, engineering, risk, finance, and business decisions — each contribution attributed to a named expert, grounded in cited public sources.

/SI-Decide "Should we migrate our database to pgvector?"
/SI-AI-Decide "Which embedding model gives the best cost/performance?"
/SI-Eng-Pre-Mortem "Review our zero-downtime cache migration strategy"
/SI-GRC-Review "Check this customer onboarding flow for GDPR compliance"

389 expert personas, organized across 9 specialized departments:

• 242 generated slash commands. 17 cross-team meta commands (like /SI-Decide or /SI-Tradeoff, routing across domains) plus 225 per-team commands (25 verbs × 9 teams, such as /SI-AI-Decide or /SI-Eng-Pre-Mortem). These are generated locally at install time from the team registries — no command files are transmitted or stored remotely.
• 70 expertise cells. Each department is subdivided into focused cells (e.g. Engineering has 11, AI has 8) so the router can assemble a precise panel rather than a generic crowd.
• Cross-team meta-orchestration. For complex queries spanning domains ("build and sell an AI audit tool"), a local router scores your prompt against team registries and cells, then greedily assembles a proportional 16–32-person panel.
• Citable and grounded. Every stance is verified from public sources and carries a direct evidence URL. Personas are validated against a strict anti-fabrication gate.
• --debate deliberation. Panels can argue in reacting rounds before returning a verdict, surfacing named dissent instead of false consensus.

The selection algorithm (two-stage routing + approval)

The meta-orchestrator uses a staged algorithm so it never has to load the entire persona filesystem at runtime:

1. Stage A — team & cell routing (cheap). Reads the meta-registry (systems/superintelligence/registry.json) and scans only team descriptions and cell definitions, scoring relevance by keyword and domain overlap to select the top 1–4 teams. If one team dominates, it delegates to that team's own orchestrator.
2. Stage B — scoped persona selection. Loads compact persona records (slugs, cells, domains, stances, conflict mappings) for only the selected teams, allocates the 16–32-person budget proportionally, runs the greedy scorer (0.40·domain + 0.30·cell-coverage + 0.30·conflict-pairing), and applies a cross-team tension pass to pair opposing viewpoints (e.g. security vs. growth).
3. Stage C — approval & execution. Presents the roster grouped by team with a one-line rationale. The action verb then consumes the approved roster and returns output with full line-by-line attribution (e.g. "Aswath Damodaran (Finance): …").

Persona build & validation pipeline

The 389-persona roster was compiled with a systematic multi-tier workflow. Candidate generation was evaluated across local Qwen (via LM Studio), a hosted small model, and Gemini Flash, but Claude research agents proved the quality winner for resolving historical data and citing verifiable signal. Personas are checked by an advisory validation gate (validate_persona.py) that enforces five things: every required frontmatter field is present; at least 4 cited URLs resolve live (non-404); every public_stance carries an evidence_url, so no stance is uncited; at least 2 recent signals within 12 months (or 2 persistent signals for historical archetypes); and any pairs_well_with / productive_conflict_with slug refers to a real roster member. Two limits are worth stating plainly: the gate confirms that a stance is cited, not that a quotation is authentic, and home_team is only checked for presence, not validated against the list of real teams. A NEEDS-TOPUP verdict is advisory — it does not currently affect which personas a council selects at runtime.

The Framework Underneath

The board decides. The framework ships. Three pillars turn the verdict into merged, verified code.

Architecture conformance: the gate tests cannot give you

Every test suite in existence shares one blind spot. Tests fail when behaviour breaks — not when your architecture quietly dissolves. A component can be relocated, folded into another module, or deleted outright, and a green build will tell you nothing. Requirements pass. Coverage holds. The design you agreed to is gone.

/team now closes that gap in both directions, and both are enforced by Python scripts with real exit codes — not by instructions an agent can narrate its way around.

Why this works. Path existence cannot be checked at planning time, because nothing is built yet. So the plan is written when the knowledge exists and tested when the evidence exists. Deferring the check rather than weakening it is exactly what makes a forward architecture declaration enforceable.

Use it

/team arch build      # map this repository into a committed, commit-pinned index
/team arch drift      # reconcile an existing index against the current tree
/team arch check      # run the validator alone — no model calls, no writes to the index
/team verify          # now includes failure mode (e): architecture abandoned
/team ship            # declares intended architecture, then proves the build matches
/team ship --no-arch  # opt out entirely; every gate reports DISABLED, never a silent pass

The approval gate now shows you the intended architecture as a table before the build starts. That is the cheapest moment to disagree with it.

What it does not do

A gate that overstates its reach is worse than no gate, so these limits are stated in the artifacts themselves and are not marketing hedges.

• Structural drift only. A component whose datastore was swapped inside its own already-claimed directory produces no drift. Every artifact says "structural drift only" in those words, deliberately.
• Not a work-allocation mechanism. The index sits at C4-Container altitude, so one component can legitimately own thousands of files. Three separate design reviews rejected deriving per-agent file ownership from it.
• Currency is not yet mechanically enforced. Comparing the index pin to HEAD is prose an agent follows, not a script. A stale index degrades every gate to UNVERIFIED rather than to a pass — but instrumenting this is the next piece of work, and it is named as such.
• A clean result licenses no claim about whether the code at those paths does what the component promised. That remains a review judgement.

Requires only Python 3 and git. No new dependencies. Design adapted from lak7/devildev (Apache-2.0); no upstream code was copied — see CREDITS.md.

The CoCo Asset Library

A standard install equips your workspace with a lightweight core; full activation unlocks up to 903 total assets to orchestrate any software-engineering workflow.

Skills Catalog

CoCo ships 185 skills (70 core + 115 across bundles). These are not prompt snippets — each is a full agent instruction set with state management, verification logic, and error handling. A representative slice by category:

Visual design & styling

ui-ux-pro-max (50 styles, 21 palettes, 50 font pairings, 9 stacks) · frontend-design · design-taste-frontend · redesign-existing-projects · axiom-liquid-glass (Apple Liquid Glass, WWDC 2025) · swiftui-liquid-glass · web-design-guidelines · tailwind-patterns (Tailwind v4) · vercel-react-best-practices · clone-website · c4-architecture · arb-review · expo-api-routes · ai-product · scroll-world (scroll-scrubbed, cut-free camera flythrough landing pages, generated end to end via Higgsfield).

Engineering discipline & quality

brainstorming · writing-plans · executing-plans · subagent-driven-development · dispatching-parallel-agents · test-driven-development · systematic-debugging · requesting-code-review · receiving-code-review · verification-before-completion · finishing-a-development-branch · using-git-worktrees · code-verification (7 bug-vector audit) · generate-tests · api-design-principles · cli-anything · workflow-routing.

AI / LLM engineering

openai-agents · openai-api · openai-apps-mcp · openai-whisper · agent-lightning (Microsoft Agent Lightning, RL) · voice-ai · ai-marketing-videos.

Product management & communication

prd-generator · prd-mastery · task-prd-creator · project-docs · pmstudio · nfr-tracker · stakeholder-comms · meeting-notes · change-log.

Operations, safety & recovery

dr-plan (RTO/RPO) · irp (incident response) · recovery-plan.

Media, memory & analysis

coco-ads (launch videos via HyperFrames) · media-memory (multimodal embeddings) · doc-sync · ultra-think · browser-automation.

The CoCo platform itself

coco (conversational router) · coco-cli · coco-loop (compiles a plain-language goal into a confirmed charter, then runs a bounded, propose-only autonomous loop) · skill-creator · writing-skills · find-skills.

System Bundles

Bundles are opt-in packages that extend the workspace with specialized databases, pipelines, and rosters. Enable them with --systems <name>.

1. GSD (Get Shit Done)

An orchestration engine of 68 skills and 24 agents that manages the lifecycle of complex codebases. A disk-backed phase database records goals, decisions, milestones, and blockers; workstreams spin up isolated git checkouts to test refactors without polluting main; forensics performs post-mortem root-cause audits when a phase fails; and autonomous mode runs parallel waves of subagents through plan milestones end-to-end.

2. Brain

A local knowledge-graph engine of 6 skills connecting email, chat, code, and docs. A local SQLite store indexes code entities, business decisions, project terms, and stakeholder feedback; a wiki generator builds hyperlinked articles for every recorded entity; and mail sync links project email threads to related files.

3. Team

A multi-agent product-team pipeline (/team:ship, /team:plan, /team:review, /team:verify, and more). It spawns specialized subagents — Research, Architect, QA — to execute changes, review diffs, and write tests, with deterministic gates that intercept merges to run lints, import audits, reference checks, and verification suites.

4. Super Intelligence

The 389-persona advisory board and its 242 generated /SI-* commands across 9 departments — the hero capability described above.

YOLO Mode: True Autonomy

/coco yolo

Before CoCo vs. After CoCo

High-Impact Command Demos

/SI-Decide --debate "Buy vs. build our vector store"

/code-verification

/clone-website https://stripe.com

/systematic-debugging

/prd-generator

/coco-ads

Power Features

/coco

/media-memory

# Point your host CLI's scheduler at any CoCo command:
/schedule run /team:review every Monday
/loop 5m /team:verify

/email:summary
/email:today

/gsd-workstreams create feature-a
/gsd-new-workspace

bash adapters/codex/install.sh

How CoCo Works

flowchart LR
  U["You<br/>(Slash command, plain English)"] --> AI["Your AI Harness<br/>(Claude Code, Cursor, Codex…)"]
  AI --> A["IDE Adapter"]
  A --> S["CoCo Assets<br/>skills · agents · commands · rules · personas"]
  S -. Read at runtime .-> AI
  AI --> Agents["Parallel Subagents<br/>(executed by your harness)"]
  Agents --> AI

Installation Matrix

git clone https://github.com/coco-research/coco.git
cd coco
bash install.sh

# Authenticate the GitHub Packages registry
echo "@coco-research:registry=https://npm.pkg.github.com" >> ~/.npmrc
echo "//npm.pkg.github.com/:_authToken=YOUR_TOKEN" >> ~/.npmrc

# Install and launch
npm install -g cocosuperintelligence
coco

# Enable GSD, Brain, and Team systems
bash install.sh --systems gsd,brain

# Enable the Super Intelligence board
bash install.sh --systems superintelligence

bash install.sh --adapter claude-code
bash install.sh --adapter cursor
bash install.sh --adapter codex
bash install.sh --adapter generic

bash <(curl -fsSL https://raw.githubusercontent.com/coco-research/coco/main/bin/coco-bootstrap.sh)

The install paths above are deliberately conservative: the remote bootstrap never runs code before you have confirmed the commit it cloned, install.sh only ever reads and symlinks files already inside the repository, the CI workflows that build and publish Coco pin their setup-node and setup-python Actions to commit SHAs rather than mutable tags, and nothing Coco does locally or in CI sends data anywhere. See SECURITY.md for the full policy.

Staying Current

CoCo tells you when a newer version is available — it checks the GitHub repository at most once per day, prints a one-line banner, and sends no telemetry. Disable with COCO_NO_UPDATE_CHECK=1.

# print version + update status
bash scripts/check-update.sh

# apply an update
git pull --ff-only && bash install.sh

# print version + check for updates
npx cocosuperintelligence version

# apply an update
npx cocosuperintelligence update

_{Releases are tracked in CHANGELOG.md and on the GitHub Releases page.}

System Compatibility

Technical Specifications

_{Core install ships 68 skills + 37 commands + 10 agents + 15 rules (130 active assets). The totals above reflect a full install with every bundle (bash install.sh --systems gsd,brain,cognee,hyperframes,superintelligence). Super Intelligence slash commands are generated locally at install time from the team registries — no command files are transmitted or stored remotely.}

Frequently Asked Questions

find ~/.claude ~/.cursor -type l -lname "*$(pwd)*" -delete

Contributing & Community

CoCo is open-core: the core is MIT-licensed and contributions are welcome. The Super Intelligence System (systems/superintelligence/) is proprietary — see systems/superintelligence/LICENSE.

• Start here: CONTRIBUTING.md — how to add a skill, command, agent, or adapter.
• Good first issues: help wanted / good first issue — small, well-scoped tasks for newcomers.
• Report a bug / request a feature: open an issue.
• Security: see SECURITY.md for responsible disclosure.
• Conduct: see CODE_OF_CONDUCT.md.

Before opening a PR, validate locally — CI runs a frontmatter linter, manifest validation, and an install-script syntax check.

Built On

CoCo Super Intelligence stands on the shoulders of excellent open-source work. Special thanks to:

• obra/superpowers (Jesse Vincent) — the foundational engineering-discipline skills (brainstorming, systematic debugging, TDD, plan writing/execution, git worktrees, code-review flows, verification, and skill authoring).
• gsd-build/get-shit-done — the 68-skill / 24-agent GSD project-orchestration bundle.
• heygen-com/hyperframes (HeyGen, Inc., Apache License 2.0) — the 20-skill HyperFrames video/motion bundle vendored under systems/hyperframes/ (composition engine, CLI, animation, creative direction, registry, and the video-authoring suite).
• JCodesMore/ai-website-cloner-template — the site-cloning structure behind clone-website.
• agents.md community — the vendor-neutral agent-context standard CoCo's adapters follow.
• nickwinder/synthteam (Nick Winder) — the multi-agent debate protocol behind --debate deliberation.
• latent-spaces/brag (Shunit Haviv) and HyperFrames (HeyGen) — the launch-video flow and local render engine behind coco-ads.
• leonxlnx/taste-skill (Leon) — the design-taste enforcement behind design-taste-frontend and redesign-existing-projects.
• HKUDS/CLI-Anything — the "wrap any CLI into a structured skill" methodology behind cli-anything.
• Vercel and vercel-labs/web-interface-guidelines — the source material behind vercel-react-best-practices and web-design-guidelines.

Full attributions — including feature-level inspirations, bundled audio (ende.app, Kenney.nl), and licenses — live in CREDITS.md. If something influenced CoCo and isn't listed, that's a bug: open an issue.