Skip to main content
Glama

crew_projects

Lists projects handed to the crew, oldest first, with repos, tickets, open PRs, autonomy, completed tickets, and milestones so an orchestrator can spot projects to start or release.

Instructions

The projects handed to the crew, oldest first: each with its repos (path on this machine, GitHub name) and the tickets and open PRs of each, the autonomy it was handed over at when stricter than the crew's, tickets done of all, and the milestone it is on. The orchestrator works from this list: a project here with no builder is one to start. Projects the person said are done are not in it (finished lists them apart). releasing lists the projects the person took back from the crew (tares factory session <project>) that still wait for the orchestrator to stop their builders (holders) and call release_project; they are no longer the crew's to work on.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "crew_projects"
  }
}

Input Schema

NameRequiredDescriptionDefault

No arguments

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.57.0

TDQS

A3.9/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations supplied, the description carries the full disclosure burden and does most of it: it discloses that the result is a filtered crew-scoped set, that finished projects are deliberately omitted and surfaced only via `finished`, and that `releasing` projects are no longer the crew's to work on but still need a release_project call. It never explicitly labels the operation as a read-only listing or mentions side effects, but the framing is consistently observational. It does not discuss cost, freshness, or refresh cadence for what is effectively a state snapshot.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The core is front-loaded in the opening clause, but the first sentence is a long run-on that stacks nested parentheticals about `path`, `name`, autonomy, and milestone, making it hard to parse on one pass. Phrases like 'the autonomy it was handed over at when stricter than the crew's' are clumsy. There is little outright waste, but restructuring into a short bulleted inventory would materially help.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, yet the description still gives a useful inventory of what comes back plus the two special sub-lists, and it cross-references the concrete follow-up action (release_project) and the CLI command that produces `releasing`. That is sufficient for an agent to call it correctly and act on the result. The only gap is that key domain terms like 'builder' and 'holders' are used without definition.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters and schema coverage is 100%, so there is nothing for the description to disambiguate — this is the baseline 4 case. The description instead spends its space on return semantics, which is the useful place for it here.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names the specific resource (projects handed to the crew) and enumerates exactly what each entry carries: repos with local `path` and GitHub `name`, tickets, open PRs, autonomy level, completed-ticket count, and milestone. It also scopes the set precisely by excluding projects the person marked done (`finished`) and separating `releasing`. It stops short of naming `list_projects` as the contrasting sibling, so the differentiation is implicit rather than explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It states the operative use case concretely: 'The orchestrator works from this list: a project here with no builder is one to start,' and it tells the agent that `releasing` entries exist specifically so it can stop their `holders` and call release_project. That is real when-to-use and what-to-do-next guidance rather than a generic hint. It does not explicitly say when to prefer this over `list_projects`, which keeps it from a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.