Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
CREW_SCOUTNoQuick override for the scout role worker chain (e.g., 'local,chatgpt').
CREW_NUM_CTXNoQuick override for the number of context tokens (e.g., 16384).
CREW_REVIEWERNoQuick override for the reviewer role worker chain (e.g., 'chatgpt').
CREW_WORKSPACENoSet the workspace directory for the server to use instead of the launch directory.
CREW_OLLAMA_URLNoQuick override for the Ollama server URL (e.g., http://localhost:11434).
CREW_OLLAMA_MODELNoQuick 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 paths instead, 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

CapabilityDetails
tools
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
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 workers is given), every member is asked at the same time and each answer comes back separately: compare them yourself.

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

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.9/5.0

Scored across 6 tools

Disambiguation4/5

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'.

Naming Consistency4/5

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.

Tool Count5/5

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.

Completeness4/5

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.

Maintenance

ActivityMaintained
ResponsivenessLimited data