Skip to main content
skill CX Codex

council · zaxbyhub — Claude Code skill: three-agent advisory panel, install steps

Brings the COUNCIL mode of opencode-swarm into your session: three agents weigh a question and the architect returns one answer.

MIT ★ 539 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add ZaxbyHub/opencode-swarm --skill council -a claude-code
Open on GitHub

What council does

The skill carries the COUNCIL mode of opencode-swarm; the architect runtime loads it from disk when the mode is called. Trigger it with /swarm council <question>, or add --spec-review to have the same panel look at a spec draft.

Work starts with a short web_search pass: 1-3 keyword queries, packed into a RESEARCH CONTEXT block with title, URL, snippet and freshness notes. Three roles then run in parallel (generalist, skeptic, domain expert), all fed the same block. Disagreements get one reconciliation round, and the architect writes the final answer. Nothing in your code, plan or spec is edited. Claims the agent could not check against current source this round are tagged confidence: LOW.

Config gates the whole thing. council.general.enabled has to be true and a search key must exist, either council.general.searchApiKey or the TAVILY_API_KEY / BRAVE_SEARCH_API_KEY env var. Settings are read from ~/.config/opencode/opencode-swarm.json first, then .opencode/opencode-swarm.json. Without them the run stops and tells you what to set. If a time-sensitive question returns nothing from search, dispatch halts there too.

What it helps with

  • run a question past three agents before a plan is saved
  • pull fresh sources into the discussion instead of model memory
  • settle role disagreements in a single reconciliation round
  • review a spec draft as a separate pass
  • mark claims that were not checked against current source

Example prompts for the agent

  • /swarm council Should we move the job queue to its own worker?
  • /swarm council --spec-review Check the draft in specs/auth.md before we start.
  • /swarm council Which license fits if we embed this library in a closed product?

How to install council

1Skills CLI (Vercel)

npx skills add ZaxbyHub/opencode-swarm --skill council -a claude-code

2Manually: put the files in place

~/.claude/skills/council/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/council/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about council

How do I install council in Claude Code?

Run npx skills add ZaxbyHub/opencode-swarm --skill council -a claude-code; the skill file lands at ~/.claude/skills/council/SKILL.md.

What does council do?

It supplies the COUNCIL mode of opencode-swarm: after a short web research pass, a generalist, a skeptic and a domain expert deliberate in parallel, and the architect writes the answer.

What has to be configured before the mode runs?

council.general.enabled set to true plus a search key: council.general.searchApiKey, TAVILY_API_KEY or BRAVE_SEARCH_API_KEY. The global file is ~/.config/opencode/opencode-swarm.json, and a project can override it with .opencode/opencode-swarm.json.

Source text

SKILL.md · MIT
---
name: council
description: >
  Full execution protocol for MODE: COUNCIL -- General Council research,
  parallel member dispatch, disagreement handling, and synthesis.
metadata:
  audience: swarm-plugin
---

# Council Protocol

This protocol is loaded on demand by the architect runtime.
The architect prompt keeps only activation, action, and hard safety constraints;
the full execution details live here.

### MODE: COUNCIL

Activates when: user invokes `/swarm council <question>` (optionally with
`--spec-review`).

Purpose: convene a fixed three-agent multi-model General Council
(generalist / skeptic / domain expert) for an advisory deliberation. The
architect runs a curated web research pass upfront, dispatches the three agents
in parallel with the gathered RESEARCH CONTEXT, routes any disagreements back
for one targeted reconciliation round, and synthesizes the final user-facing
answer directly.

This mode is ADVISORY. It does not block any other workflow and does not modify
code, plans, or specs. The output is for the user (general mode) or for the spec
being drafted (spec_review mode is available via `/swarm council --spec-review`
for manual spec review). General Council advisory input is offered as an early
workflow option in MODE: BRAINSTORM (Phase 1b) and MODE: PLAN before
`save_plan`.

#### Pre-flight (always run first)

1. Read `council.general` from the resolved opencode-swarm config. Resolution
   is global first (`~/.config/opencode/opencode-swarm.json`), then project
   override (`.opencode/opencode-swarm.json`). A global config is valid and must
   be used when no project override is present; do not fail after checking only
   the project file. If `council.general.enabled` is not true OR no search API
   key is configured (neither `council.general.searchApiKey` nor the
   corresponding env var `TAVILY_API_KEY` / `BRAVE_SEARCH_API_KEY`),
   surface to the user: "General Council is not enabled. Set
   council.general.enabled: true and configure a search API key in
   global ~/.config/opencode/opencode-swarm.json or project
   .opencode/opencode-swarm.json." Then STOP.

#### Research Phase (always run before dispatching council agents)

2. Formulate 1-3 targeted `web_search` queries that best capture the
   information needed to answer the question. Prefer specific, keyword-focused
   queries over broad ones.

   Hard grounding rules:
   - Do not append a model training-cutoff year to searches.
   - Use `web_search` with its default `freshness: "auto"` behavior for
     current queries unless the user explicitly asked for a historical window.
   - Preserve each `web_search` result's normalized `query`, `temporalIntent`,
     `freshness`, and `removedStaleYears` metadata in RESEARCH CONTEXT audit
     notes.
   - For current, latest, today, now, state-of-the-art, pricing, release-status,
     legal/regulatory, financial, security, or otherwise time-sensitive
     questions, the Research Phase must produce usable current sources before
     council dispatch.
   - If `web_search` returns no results or an error for a time-sensitive
     question, stop and surface the failed search result to the user instead of
     dispatching ungrounded members.
   - For stable/non-current questions, if `web_search` returns no results or an
     error, note this in the dispatch message and proceed without a context
     block. In that degraded mode, members may use stable background knowledge
     only and must not make current-fact claims.

   Compile all successful results into a RESEARCH CONTEXT block in this format:

```text
RESEARCH CONTEXT
================
[1] <title> - <url>
    <snippet>
    query: <normalized query>; temporalIntent: <current|historical|unspecified>; freshness: <day|week|month|year|none>; removedStaleYears: <comma-separated years or none>

[2] <title> - <url>
    <snippet>
...
```

#### Read-before-cite discipline

When citing source code, API behavior, CLI flags, file paths, or line ranges, the synthesizing agent MUST read the actual file or tool output first. Search snippets, file globs, conversation history, and prior-round memory are not sufficient evidence. Specific anti-patterns to refuse in synthesized output:

- Quoting a line range (e.g. `src/foo.ts:123-145`) without reading those lines in the current revision.
- Restating an API signature, error message, or option flag from prior context after the source has been edited.
- Citing `bunSpawnSync` / `child_process.spawnSync` behavior from documentation that pre-dates the current version.

The synthesized answer's `sources` array should reference URLs and tool outputs the agent actually retrieved during the current session, not sources inherited from prior rounds. Mark `confidence: LOW` for any claim the agent could not verify against current source this round.

#### Round 1 - Parallel Independent Analysis

3. Dispatch `the active swarm's council_generalist agent`,
   `the active swarm's council_skeptic agent`, and
   `the active swarm's council_domain_expert agent` with `dispatch_lanes_async`
   when available -- one lane per agent. Before the first dispatch, verify from
   the session's actual tool list whether the controller's lane tools are
   present; when they are absent, use the native parallel subagent path from
   the start rather than discovering the gap on first failure. Record the returned `batch_id`, then
   continue only non-dependent architect work: prepare the synthesis outline,
   normalize the RESEARCH CONTEXT citations, and draft disagreement categories.
   Do not call `convene_general_council` or present conclusions from running
   lanes. Dispatch promptly — do not accumulate extensive planning prose before the
   call, or output truncation may swallow the tool call itself. Keep each lane `prompt`
   compact: send shared context ONCE via the `common_prompt` field, or have lanes read
   it from a file by absolute path, instead of inlining the same large blob into every
   lane prompt. Each dispatch message must
   include:
   - The question
   - Round number: 1
   - The CURRENT DATE in ISO `YYYY-MM-DD` form
   - The full RESEARCH CONTEXT block from step 2
   - Instruction: "Cite from the RESEARCH CONTEXT for external evidence. Your
     memberId and role are hardcoded in your system prompt."

Do NOT share other agents' responses at this stage.

4. While council lanes are running, poll with `collect_lane_results` (without
   `wait` or `wait: false`) to check progress and process any settled member
   responses as they complete — extract the JSON, verify `output_ref`, and
   pre-validate structure — while continuing independent architect work
   (synthesis outline, citation normalization, disagreement categories). Only
   use `wait: true` if lanes are still pending and no more independent work
   remains. All three lanes must be settled before proceeding to synthesis.
   If `dispatch_lanes_async` is unavailable, use blocking `dispatch_lanes`
   as the first fallback and record that async advisory lanes were unavailable.
   This changes only when the architect waits, not whether all council lanes
   must settle. Do not substitute Task-tool dispatch unless lane tools are
   unavailable; when they are unavailable, Task is the final fallback and must be
   verified as equivalent by agent type, prompt, scope, and isolation. The
   `round1Responses` array will contain entries with `memberId` of
   `council_generalist`, `council_skeptic`, and `council_domain_expert` and
   `role` of `generalist`, `skeptic`, and `domain_expert` respectively. If
   any lane result has `output_ref`, call `retrieve_lane_output` and parse
   the full artifact rather than the preview. If a lane is degraded,
   incomplete, truncated without a usable ref, missing, stale, cancelled, or
   failed, treat the council round as blocked or incomplete; do not synthesize
   from partial member JSON. These come from the agents' JSON output; no
   manual construction is needed.

#### Synthesis and Deliberation (when council.general.deliberate is true; default true)

5. Call `convene_general_council` with mode set from the command (`general` or
   `spec_review`), `question`, and the collected `round1Responses` only (omit
   `round2Responses`). Inspect the returned `disagreementsCount`.

6. If `disagreementsCount > 0`:
   a. For each disagreement in the tool's response, identify the disputing
      agents (the agents listed in the disagreement's positions, identified by
      memberId: `council_generalist`, `council_skeptic`, or
      `council_domain_expert`).
   b. Re-delegate ONLY to the disputing agents -- one message per agent --
      passing: their Round 1 response, the disagreement topic, the opposing
      position(s), round number 2, and the same RESEARCH CONTEXT block.
   c. Collect the Round 2 responses.
   d. Call `convene_general_council` AGAIN with both `round1Responses` AND
      `round2Responses` populated.

#### Output

7. Present the final answer to the user from the `synthesis` returned by
   `convene_general_council`. Apply these output rules directly:
   - LEAD WITH CONSENSUS: open with the strongest consensus position.
     Confidence-weighted: higher-confidence claims from multiple agents rank
     first, but evidence quality outranks raw confidence. Never elevate a
     single confident voice over a well-evidenced contrary majority.
   - ACKNOWLEDGE DISAGREEMENT HONESTLY: for each persisting disagreement, write
     "experts disagree on X because..." and present the strongest version of
     each side. Do not pretend disagreements are resolved. Do not silently pick
     a winner.
   - CITE THE STRONGEST SOURCES: link key claims with `[title](url)` format from
     the source list in the synthesis. Pick the most reputable source per claim;
     do not cite duplicates.
   - BE CONCISE: a few short paragraphs plus a bulleted summary. Expand only
     when the question genuinely requires it.
   - HARD CONSTRAINTS: You MUST NOT invent claims not present in the council's
     responses. You MUST NOT add new web research. You MUST NOT favor a position
     based on confidence alone.

Preface the answer with one line listing the participating models (reviewer
model as generalist, critic model as skeptic, SME model as domain expert). Do
NOT present raw per-member JSON.

© ZaxbyHub · MIT · ZaxbyHub/opencode-swarm

Similar skills

All skills for Agent setup: memory, context, orchestration →

council by other authors comes first.

council affaan-m council is a Claude Code skill that gathers four views on an ambiguous decision and lays out disagreements before a verdict. It runs when several options seem credible. CX Codex +1 6,400installs council t3dotgg The council skill triggers a simultaneous code review by three different AI models to gather independent feedback. The agent summarizes the findings and assists in applying necessary fixes. CX Codex +1 1,500installs council boshu2 council — a skill for Claude Code gathers independent views and synthesizes their agreements and disagreements. Use it to compare plans, discuss options, or summarize several reviews. CX Codex +1 3,100installs council Samarth Gupta council launches parallel personas to deliberate on technical questions, examine codebase files, and formulate an opinionated verdict. CX Codex +1 ★ 276repo stars llm-council aiwithremy llm-council is a Claude Code skill that launches five advisor sub-agents with distinct thinking styles to analyze a question independently, review each other's answers, and produce a final verdict. CX Codex +1 1,600installs benchmark-due-diligence daymade benchmark-due-diligence — a skill for Claude Code, Codex, Cursor and other AI coding platforms that tears down a competitor's success — founder, company, product — separating real results from marketing. CX Codex +1 547installs agent-exploration Pedro Nauck agent-exploration — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode that splits a broad research question into independent slices and dispatches each to a separate explorer. CX Codex +1 259installs LLM Council shuntacurosu LLM Council coordinates multiple LLMs across three stages: independent responses, anonymized peer grading, and chairman synthesis. CX Codex +1 5installs council-method LihFolk council-method is a Claude Code skill that gathers blind agent reviews of consequential Roblox decisions. It activates for launch-readiness checks and requests for an objective second opinion. CX Codex +1 ★ 98repo stars agent-council Parth Sangani agent-council is a GitHub Copilot plugin that has five LLM reviewers assess a draft and return SHIP, REVISE or HOLD. It is used before publishing text that cannot be pulled back. ★ 14repo stars

From the same set121

The whole set →
bundle-safety The bundle-safety skill guides bundle minification checks, identifier preservation, and namespace re-export coverage. Use it before build changes that could rename or remove code. CX Codex +1 ★ 539repo stars swarm-implement swarm-implement runs feature work, bug fixes and refactors through a swarm workflow: parallel exploration, a scoped plan, then reviewer and critic passes on the diff. CX Codex +1 ★ 539repo stars safe-rename safe-rename is a Claude Code skill that guides the renaming of exported symbols and files without breaking dependents, imports, or tests. CX Codex +1 ★ 539repo stars subprocess-safety The subprocess-safety skill sets requirements for child-process calls. Use it when adding, changing, or reviewing code that invokes spawn, spawnSync, or child_process. CX Codex +1 ★ 539repo stars safe-extraction safe-extraction guides the safe refactoring of monolithic files into submodules. Keeps test mocks working through _internals proxies, preserves public APIs, and updates CI path allowlists. CX Codex +1 ★ 539repo stars critic-gate The critic-gate skill sends a plan to a critic agent and blocks execution until approval is recorded. Use it to review a plan before implementation starts. CX Codex +1 ★ 539repo stars tech-debt-ci-review tech-debt-ci-review audits a repository for technical debt and CI stability: tests that prove nothing, flakes and brittle build steps that keep pull requests from going green. CX Codex +1 ★ 539repo stars deep-research deep-research runs a multi-step fact-checked research loop with live web search, parallel worker synthesis, and strict claim citation. CX Codex +1 ★ 539repo stars

Project sponsors

Companies that keep this analytics open