crew-mcp
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| CREW_SCOUT | No | Quick override for the scout role worker chain (e.g., 'local,chatgpt'). | |
| CREW_NUM_CTX | No | Quick override for the number of context tokens (e.g., 16384). | |
| CREW_REVIEWER | No | Quick override for the reviewer role worker chain (e.g., 'chatgpt'). | |
| CREW_WORKSPACE | No | Set the workspace directory for the server to use instead of the launch directory. | |
| CREW_OLLAMA_URL | No | Quick override for the Ollama server URL (e.g., http://localhost:11434). | |
| CREW_OLLAMA_MODEL | No | Quick override for the Ollama model to use (e.g., a model name). |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
crew: a local GPU model and ChatGPT, available as crew_* tools. Use them to save your own context and to get independent checks. Claude stays the lead.
Mapping a flow across more than a few files: call crew_recon first and read only what it points to. It's a cheap first pass, not proof: confirm load-bearing claims.
After changing code, before saying you're done: call crew_review_diff. Fix or explicitly rebut every quote-checked finding. Quote-checked means the quoted code exists where claimed; it doesn't prove the claim. Unverified findings are hints: check the plausible ones, ignore the rest. It is for normal-sized changes. For a new repo, a big refactor or generated code it will say the diff is too large: review the riskiest files via
pathsinstead, or skip it. Don't reach for force.When you run crew_review_diff again after weighing its findings, pass the ones you rebutted or accepted as
acknowledged(each finding's headline file:line plus a few words) so they aren't raised again. They come back collapsed to one line.Risky changes (payments, auth, migrations, concurrency, data deletion): also call crew_second_opinion with includeDiff true and your reasoning. Weigh disagreement on the merits; don't defer just because it disagrees. If a panel is configured, one call asks every member at once and returns each answer separately: compare them, and say where they agree and where they differ. Don't call it once per model. It defaults to depth "deep" with includeDiff and "quick" without; pass depth "quick" for a fast check of a plan or design, "deep" only when the code itself needs a careful review.
Before presenting analysis with file:line references: run crew_check_citations and fix anything invalid.
Crew calls can take 1-2 minutes. That's expected; don't retry or poll. If a crew tool errors, run crew_status once and report what it says.
The local GPU runs one crew call at a time, shared by every Claude session on this machine; other calls wait their turn in a queue. Calls sent in parallel don't finish sooner, they queue: send one call with a broader question rather than several narrow ones at once. A queued call can take several minutes; that's the queue, not a hang. If one fails because the worker is busy, don't resend it straight away.
A crew call blocks your turn until it returns, queue time included. When a recon isn't needed for your very next step, hand it to a background subagent and keep working; use its result when it arrives. Call crew_review_diff directly: it gates "done", and the queue lets it go ahead of waiting recons.
When reporting crew results, keep three things distinct: what the crew claimed, what you verified yourself, and what is still unverified.
Every crew result starts with a "via ..." line naming the worker, model, time and work done. When you report a crew result to the user, quote that line verbatim so they can see what ran and where. crew_stats shows usage totals if they ask.
A repo's .crew.json policy (e.g. cloud:false for PHI) is enforced by crew itself: cloud workers are never used there and there is no fallback. If a tool says it's disabled or unavailable by repo policy, don't work around it; tell the user.
If the project's CLAUDE.md says how crew fits that repo's own tooling, follow it.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": true
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| crew_statusA | Show crew configuration, the workspace it will read, and which workers (local GPU, ChatGPT, API) are available. Run this first if another crew tool errors. |
| crew_reconA | Send a scout (local GPU first, ChatGPT as fallback) to map the code relevant to a question: files, functions, coverage of each stage, and evidence-backed risks. Use it before reading lots of files yourself, to save your context. Results are leads to confirm, not proof. |
| crew_review_diffA | Have a scout review the current working-tree changes (staged, unstaged and new files) for bugs, security, concurrency and data-integrity problems. Findings are split into evidence-checked (the quoted code really exists) and unverified. Run it after making changes and before saying you're done. |
| crew_second_opinionA | Ask an independent reviewer (ChatGPT by default) to critique a plan, a design, or the current diff. Use it for risky work: payments, auth, migrations, concurrency. Expect disagreement; weigh it, don't just accept it. If a panel is configured (or |
| crew_check_citationsA | Deterministically check file:line references in a piece of text against the repository: the file exists, the lines exist, and a backticked identifier on the same line really appears near those lines. No model involved. Use it on your own analysis before presenting it. |
| crew_statsA | Show what the crew did: per worker, calls, time, files and characters read, tokens generated, and findings quote-checked vs unverified. ChatGPT calls show calls and time only. Includes a clearly labeled ESTIMATE of context kept out of Claude. Read from a local metadata-only log (no prompts or code). |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 6 tools
Each tool targets a distinct activity: code mapping (crew_recon), citation verification (crew_check_citations), critique of plans/designs (crew_second_opinion), diff review (crew_review_diff), and two meta tools (crew_stats, crew_status). The only borderline pair is crew_second_opinion vs crew_review_diff, since both can take a diff, but the descriptions clearly separate 'critique a plan/design/diff adversarially' from 'scan working-tree changes for concrete bugs'.
All six share the crew_ prefix and are snake_case, which makes scanning predictable. The second component mixes noun phrases (recon, second_opinion, stats, status) with verb_noun (check_citations, review_diff), a minor deviation rather than a real inconsistency.
Six tools is tightly scoped for an advisory/verification crew, and each one covers a distinct step: map, verify, critique, review, and two observability tools. No tool looks like filler.
The surface covers the full advisory loop: investigate, verify, critique, review changes, and inspect activity/configuration via stats and status. Minor gaps exist (no tool to configure or select workers, and no way to reset/clear the stats log), but agents can work around these via parameters or external config.