# claude-cordyceps
[](LICENSE)
[](https://docs.anthropic.com/en/docs/claude-code)
**Cross-model consultation as a Claude Code skill.** When you ask
Claude for a council, a panel, a peer code review, a brainstorm with
multiple LLMs, a critique of a plan, a cross-check of a confident
claim, or any task where input from a non-Claude model would help — this plugin teaches Claude
to drive [`@ellyseum/cordyceps`](https://www.npmjs.com/package/@ellyseum/cordyceps)
to spawn Codex, Gemini, Ollama, and additional Claude variants in
parallel and consume their output. The point is heterogeneity: a panel
from different model families catches blind spots any single family
shares.
The skill is a **capability**, not a single workflow. It teaches Claude
how cordy works and lets the model pick the right shape for whatever
the user actually asks for — code review, plan critique, design
red-teaming, brainstorm, decision exploration, fact-check,
meta-review, etc. New patterns fall out of the same primitives without
the skill needing to enumerate them.
## Why cross-model input matters
Claude is right most of the time and confidently wrong some of the
time. The same is true of every other frontier model — but their
failure modes are uncorrelated. A bug Claude misses is often a bug
Codex catches. A factual claim Gemini gets wrong is often one a local
Ollama model nails. On any task that rewards multiple perspectives,
running a panel from different families is a measurable quality lift.
This plugin makes that lift one phrase or one slash command away.
## Prerequisites
1. **Cordyceps:** install the harness globally.
```bash
npm i -g @ellyseum/cordyceps
```
Tested with `^0.5.2`. Older 0.5.x works (the skill falls back gracefully) but loses the `--no-chair` host-as-chair optimization.
2. **At least one peer driver besides Claude**, for the diversity
benefit. Each is optional; install whichever you want as council
members.
| Driver | Install | Auth |
|---|---|---|
| `claude-code` | already on PATH if Claude Code is installed | inherits Claude Code session auth |
| `codex` | `npm i -g @openai/codex` | `codex login` (one time) |
| `gemini` | [Google's `gemini` CLI](https://github.com/google-gemini/gemini-cli) | export `GEMINI_API_KEY` (or Vertex / GCA) |
| `ollama` | [Ollama](https://ollama.com); run `ollama serve`; `ollama pull qwen2.5-coder:7b` | none — fully local |
Cordyceps probes which of these are reachable on every session
start; the plugin builds whatever council the user asks for from
the available drivers.
## Install (the plugin)
```text
/plugin marketplace add ellyseum/claude-cordyceps
/plugin install claude-cordyceps
```
Reload plugins (or restart your session). On the next session start,
the plugin's preflight runs `cordy doctor` + `cordy --ephemeral
drivers --json` and caches the result. The skill reads that cache
when activated.
For local development:
```bash
git clone https://github.com/ellyseum/claude-cordyceps
cd claude-cordyceps
claude --plugin-dir .
```
## Use
The plugin works two ways. Both are first-class.
### 1. Natural-language activation
Just ask Claude. The skill activates on phrases like:
- "consult peers" / "consult with peers"
- "spawn council" / "convene council" / "ask the panel"
- "code review with peers" / "review this file with peers"
- "brainstorm with peers" / "brainstorm with multiple LLMs"
- "critique my plan with peers"
- "ask Codex / Gemini / Ollama about this"
- "what would <model> think about this"
The skill picks the shape (single peer query, silo'd panel + chair,
adversarial pair, brainstorm panel, tiered escalation, persistent
sidecar, meta-review) that fits the user's actual ask.
Phrases like "second opinion", "peer review", "plan review", and
"red team this" are softer triggers — the skill activates on those
only when there's a clear cross-model signal alongside (a target
artifact and explicit peers/panel framing). Otherwise it asks one
clarifying question first.
### 2. Slash command
Free-form passthrough — describe what you want; the skill handles the
rest:
```text
/cordy review src/core/bus.ts
/cordy brainstorm names for an open-source agent harness
/cordy critique my migration plan: [paste plan]
/cordy cross-check "Postgres is faster than SQLite for embedded use"
/cordy what would Codex and Gemini think of this design?
/cordy diff --staged
/cordy do a peer review on the diff vs main
```
The slash command is especially useful for testing or when the
natural-language triggers feel like overreach.
## How it works
```
┌──────────────────────────┐
SessionStart → │ bin/preflight.mjs │
│ • detect cordy │
│ • cordy drivers --json │
│ • write preflight.json │
└─────────────┬────────────┘
│
additionalContext ────────┘ (only if degraded)
│
▼
┌─────────────────────────────────────────────────┐
│ Claude Code session (with plugin loaded) │
│ │
│ user: "spawn council on this plan: …" │
│ │ │
│ ▼ │
│ cordy skill activates → reads preflight cache │
│ │ │
│ ▼ │
│ picks the right shape: │
│ ▸ council review/diff if a file/diff matches │
│ ▸ otherwise spawn N peers manually with the │
│ same prompt + parallel send + synthesize │
│ │ │
│ ▼ │
│ presents the verdict + minority opinions │
└─────────────────────────────────────────────────┘
```
The plugin owns nothing about agent orchestration — it teaches Claude
to drive `cordy`'s subcommands and primitives. All actual peer
spawning, parallel I/O, chair synthesis, chunking, error handling, and
cleanup live in cordyceps itself, so feature improvements upstream
ship to plugin users for free.
## Configuration
None required for v0.1.0. The plugin reads cordy's own driver probes
on every session start — no plugin-side config to keep in sync.
Future versions may add a config file for default panel preferences,
chair preference, etc. For now the skill picks reasonable defaults
from whatever drivers are available.
## Limitations
- **Cordyceps is pre-1.0**, so cordy CLI surfaces may evolve. The
plugin is pinned to a tested cordy range and warns on mismatch.
- **Driver probe overhead.** The preflight runs
`cordy --ephemeral drivers --json` once per session, which spins a
transient daemon and probes each installed coding CLI. On a warm
machine that's a few seconds; on a cold start with multiple drivers
installed it can take longer. The hook timeout is 30s.
- **No telemetry**, no usage tracking, nothing leaves your machine
except the actual prompts sent to whichever peer LLMs you've
configured.
## Contributing
See [`CONTRIBUTING.md`](CONTRIBUTING.md) for the dev loop (`--plugin-dir`,
`/reload-plugins`, schema validation).
Bug reports and feature requests welcome via
[GitHub Issues](https://github.com/ellyseum/claude-cordyceps/issues).
## License
MIT — see [`LICENSE`](LICENSE).
Built by [Ellyseum](https://github.com/ellyseum).