CoCo Super Intelligence: an advisory board of 495 personas that runs inside your existing coding agent

The problem it names and the shape of the answer

CoCo Super Intelligence is described as an orchestration layer that turns Claude Code, Cursor or Codex into an engineering department: a routed advisory board, skills, commands and persistent state. The project states plainly that it is not a new model and not a new harness, and that it installs into the one you already run.

The problem statement is specific. A hard call in a coding session usually gets one model's opinion, with no name on it and no record of who disagreed. CoCo's answer is to seat a cross-team board of personas, each modelled on the public writing of a named expert, answering from cited public stances, and return one pick plus the dissent. The README is careful to add that they are not those people's views or endorsement, and there is a persona disclaimer and a takedown document for requesting removal or correction of a persona.

The catalogue numbers are in the top line: 495 personas across 13 departments, 228 skills and 387 commands in the full catalog. The badges repeat 228 skills, 387 commands and 495 personas.

The stated features are that you get one clear pick on a hard call with the disagreement named and each stance cited, that you ask in one line, that decisions survive a /clear because the phase state and progress stay on disk, that it installs into Claude Code, Cursor, Codex, VS Code or another adapter with your model and your keys staying yours, and that the verdict carries into the work through planning, review, verification, PRDs and a pull request with gates that have real exit codes.

The install path and the pin to a release tag

The prerequisites are git, bash, Node.js 14 or newer for npx, and python3, which generates the /SI- commands. The quick start is one command:

npx cocosuperintelligence

What it does is worth understanding, because the detail matters. It clones the pinned release tag, currently v1.8.0 and explicitly not floating main, into a ./coco directory of the current directory, then runs install.sh. The README asks you to run it from your home folder so the clone is ~/coco and not a folder inside another project. On a fresh machine it took about three minutes including the download.

The pin to a release tag rather than main is the kind of decision that ages well. A tool that installs itself into your editor and writes files into your home directory should be versioned, and the release-please tooling in the repository suggests releases are cut automatically.

If you want the newest main, which is ahead of that pin, the alternative is a clone plus install.sh:

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

From a checkout you already have, bash install.sh auto-detects the editor, and you can narrow it with --adapter cursor or --systems gsd,brain. The --core-only flag skips bundles, and reverse-skill stays opt-in through --systems reverse-skill.

Then in Claude Code you run one command:

/SI-Decide "Should a 10-person startup move its public REST API to GraphQL this quarter?"

How the routing and the debate work

You type a question, and then the orchestrator scores all 495 personas across the 13 departments on three things: domain fit, cell coverage and productive conflict. It then seats 16 to 32 of them.

Each seated persona is modelled on the public writing of a named expert, answers from cited public stances, and is not that person's views or endorsement. The --debate flag adds reaction rounds before the tally, and the decision that comes back is one pick, with the dissents named, and a stance check that flags anything which does not trace to a source.

That last mechanism is the most interesting detail in the whole design, because the README demonstrates it with an example that admits a failure. The illustration is built from a real /SI-Decide run, and the note about it says what it admits: the embedding router was offline, so it fell back to keywords, and stances applied beyond their source are marked extrapolated. There is also a terminal recording of a local meta_select.py Stage-A run where the embedding endpoint was unavailable, with the connection refused message, showing the keyword-fallback routing path with method: keyword and degraded: true, explicitly not the embed cosine path.

So the tool ships its own failure modes as documentation, which is rare and useful. A routing system that silently falls back to a different algorithm would be a correctness problem, and marking degraded: true makes the difference visible in the output.

The reference for how the router scores teams is the Super Intelligence system README, and a separate adapters document explains what each editor actually receives.

Open core, proprietary system, and what a default install gives you

The licensing arrangement is stated in one line in the README and it is the first thing to understand. The core is MIT, and Super Intelligence is proprietary, with a separate LICENSE file in the systems/superintelligence directory. The npm package metadata says the same thing: MIT core, proprietary Super Intelligence, with the licence field reading SEE LICENSE IN LICENSE.

The repository is large and the directory structure shows what is included: a skills directory, a commands directory, an agents directory, an adapters directory, systems for each bundle, workflows, rules, templates, evals, examples, mcps, an arch directory, a coco directory, a bin directory with coco.js as the entry point, plus data, docs, scripts and tests. There is a .claude-plugin.json, which is how a Claude Code plugin is declared, and a CNAME and an index.html, so the repository is also the source of a documentation site.

The delivered counts are given as measured on main: a default Claude Code install delivers 190 of the 228 skills, with the rest being the opt-in security pack and Cursor-only skills, plus 387 commands and 34 agents, with the exact numbers recorded in a delivered-counts.json file.

So the headline 228 skills is a catalogue total, and what you actually get depends on your editor. There is also a known gap: most of the GSD skills need the upstream GSD toolkit installed at ~/.claude/get-shit-done, which is a dependency outside the project.

On privacy, the claim is that files stay on your machine with no telemetry, and that a version check may contact GitHub once a day, which you can turn off by setting COCO_NO_UPDATE_CHECK=1.

What the repository layout reveals about the engineering

The npm package is deliberately small. The files array lists only bin/, README.md and LICENSE, and the bin entry points at bin/coco.js. The test script is node bin/coco.js --help, which tells you the package is an installer rather than a runtime library, and that its own test is a smoke check on the help output.

Everything else lives in the git repository that the installer clones, and the top-level directories map to the feature set. The adapters directory is where the editor integrations live, with an INDEX.md documenting what each editor receives, and the systems directory holds the bundles, including the proprietary superintelligence one, the gsd one and the opt-in reverse-skill one. The skills and commands directories are the catalogue, the agents directory holds the agent definitions, and the workflows directory is where the end-to-end flows live, which matches the claim that the verdict carries into planning, review, verification and pull requests.

There is a data directory and an evals directory, an examples directory with walkthroughs and sample PRDs, a templates directory, a rules directory, a bin directory and an install.sh at the root. There is also a CREDITS.md, a CODE_OF_CONDUCT.md, a SECURITY.md, a CONTRIBUTING.md, an AGENTS.md, a .claude-plugin.json and a .metagpt directory.

The presence of a sbom directory and a licenses directory is worth a mention, since both are things that appeared in more projects after supply chain scrutiny became standard, and they suggest the project takes the distribution of a tool that writes into your home directory seriously.

Where CoCo is the wrong choice

The first limitation is that the personas are simulations, and the README is careful not to oversell them. A persona is modelled on the public writing of a named expert, and the tool asks them to answer from cited public stances. That gives you a wide spread of framing and a record of disagreement, and it does not give you the expert's opinion, because a real expert would answer differently and might not agree with their own published position on your particular case.

So the value is a structured argument, not authority. For a team that wants a documented reasoning trail, that is real. For a team that wants the right answer, the quality depends on the model doing the answering, and CoCo is explicitly not a new model.

The second limitation is the installation shape. The tool clones itself into your home directory, writes into your editor's configuration, delivers 190 of the 228 skills and 387 commands on a default Claude Code install, and creates files that persist across sessions. That is a large footprint of generated files to review before you trust it, and the per-editor adapter and the delivered-counts file help, but the review burden is real.

The third is the licensing asymmetry. The core is MIT, so the parts you can read and modify are open. The system that does the seating, which is the interesting part, is proprietary, which means you can install it and depend on it but not study it or change it. A team with a policy about proprietary components in the development toolchain has to make that call, and the README also notes that the official animated explainers from Claude overlap with much of what this does and may be the better choice for token efficiency, which the author says plainly.

The comparison to just asking your model is straightforward: CoCo costs tokens, adds a large installed surface and buys you structure and a record. Whether that is worth it depends on how often you make calls that are genuinely hard and how much you would otherwise have argued about them with a colleague.

Editorial conclusion

CoCo fits a developer who wants a second opinion on a hard call with the reasoning on the record, and who wants it to install into the coding agent they already run rather than replace it. It does not fit a team that needs decisions reproducible from a fixed model, since the personas are simulated voices and the output depends on the model answering. Before installing, read the open-core split, since the Super Intelligence system that does the seating is proprietary while the core is MIT, check the delivered counts for your editor because a default Claude Code install gets 190 of the 228 skills, and set COCO_NO_UPDATE_CHECK=1 if you do not want the daily GitHub version check.

Frequently asked questions

Official sources

1. coco-research/coco on GitHub
2. Issues
3. Project website
4. README
5. Releases