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

With no annotations provided, the description carries full burden and discloses key behavioral traits: it writes a file (.cantrip.json), establishes a persistent connection affecting future commands, and allows checking current state. However, it doesn't mention potential errors (e.g., invalid project name), permissions, or file overwrite behavior, leaving some gaps.

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

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

The description is front-loaded with the primary purpose, followed by usage notes, all in three concise sentences. Every sentence earns its place: the first explains the action, the second the impact, and the third the no-argument use case, with zero wasted words.

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

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

Given 1 parameter with full schema coverage and no output schema, the description is mostly complete for a connection tool. It covers purpose, usage, and parameter semantics adequately. However, it lacks details on return values or error handling, which could be useful since there's no output schema, leaving minor gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the semantic meaning of omitting the parameter ('to check the current connection'), which clarifies the optional nature beyond the schema's technical description. This compensates well, but doesn't provide additional format or validation details.

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

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

The description clearly states the specific action ('connect this workspace to a Cantrip project by writing a .cantrip.json file') and distinguishes it from siblings like cantrip_init (initialization) or cantrip_project (project operations). It explicitly mentions the verb 'connect' and resource 'workspace to a Cantrip project', avoiding tautology.

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

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

It provides explicit guidance on when to use this tool: 'Start here' indicates it's the entry point, and 'All subsequent commands will target this project automatically' explains the cascading effect. It also distinguishes usage from alternatives by stating 'Call without arguments to check the current connection', clarifying when not to provide parameters.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: automatic 'accepted' marking, field variations by entity type, storage of extra fields in extensions, the pause-and-confirm workflow after adding, and the project override capability. It doesn't mention error conditions, rate limits, or authentication requirements, but provides substantial operational context.

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

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

The description is appropriately front-loaded with the core purpose, but becomes quite lengthy with detailed field listings for 7 entity types. While all information appears relevant, the bulleted lists make it dense. Some information could potentially be streamlined while maintaining clarity.

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

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

For a 5-parameter tool with no annotations and no output schema, the description provides substantial context about entity creation, field mappings, and workflow considerations. It covers the core functionality comprehensively but doesn't describe return values or error responses. Given the complexity of supporting 7 entity types with different field requirements, the description does a good job of providing necessary context.

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

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

With 100% schema description coverage, the baseline is 3. The description adds significant value by explaining how 'name' maps to 'framing' for value_prop and 'title' for experiment, clarifying that 'description' maps to 'notes' for channels, and detailing which fields are required for specific entity types. It provides concrete examples of field structures that go beyond the schema's generic descriptions.

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

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

The description clearly states the verb ('Create') and resource ('new entity'), specifying it's automatically marked as 'accepted'. It distinguishes from siblings like cantrip_entity_edit (edit vs create) and cantrip_review_accept (automatic vs manual acceptance). The description provides specific details about entity creation that differentiate it from other tools.

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

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

The description provides clear context about when to use this tool (creating new entities) and includes guidance about pausing after adding entities. It mentions using the 'project' parameter to override .cantrip.json in cloud-hosted contexts. However, it doesn't explicitly state when NOT to use this tool versus alternatives like cantrip_entity_edit for existing entities.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It usefully explains that extra fields are stored in extensions and that 'project' overrides configuration files, adding important context beyond basic editing. However, it doesn't address permissions, error conditions, or what constitutes a successful edit, leaving gaps for a mutation tool.

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

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

The description is efficiently structured in three sentences: the core purpose, parameter guidance, and special context for the 'project' parameter. Each sentence adds distinct value without redundancy, making it easy to parse and front-loading the essential information about editing entities.

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

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

For a mutation tool with no annotations and no output schema, the description provides adequate but incomplete context. It covers the editing mechanism and some behavioral aspects but lacks information about return values, error handling, or side effects. Given the complexity of editing multiple entity types with field variations, more comprehensive guidance would be beneficial.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds meaningful context by explaining field variations by type, the 'fields' object purpose for additional fields, and the specific use case for the 'project' parameter. This provides valuable semantic understanding beyond the schema's technical specifications.

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

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

The description clearly states the action ('Edit an existing entity') and resource ('entity'), making the purpose immediately understandable. It distinguishes from sibling 'cantrip_entity_add' by specifying 'existing' rather than new creation, though it doesn't explicitly contrast with other entity-related tools like 'cantrip_history' or 'cantrip_review' operations.

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

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

The description implies usage context by referencing 'same as cantrip_entity_add' for field variations and mentioning cloud-hosted/multi-project contexts for the 'project' parameter. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'cantrip_entity_add' for creation or other entity management tools, leaving the agent to infer appropriate scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds some context: it describes the audit trail as 'append-only' (implying read-only, historical data) and mentions filesystem constraints for the 'project' parameter. However, it lacks details on permissions, rate limits, error handling, or the return format (especially critical since there's no output schema). For a query tool with no annotations, this leaves significant behavioral gaps.

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

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

The description is highly concise and well-structured: two sentences that efficiently convey the tool's purpose and key parameter usage. Every word earns its place, with no redundancy or fluff. It's front-loaded with the core functionality, making it easy to scan and understand quickly.

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

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

Given the tool's complexity (a query with 5 parameters, no annotations, and no output schema), the description is incomplete. It adequately explains what the tool does and gives some parameter context, but fails to describe the return format or behavioral constraints (e.g., pagination, error cases). For a query tool without output schema, the description should ideally hint at the response structure to be fully helpful.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value beyond the schema: it clarifies the 'project' parameter's purpose ('overrides .cantrip.json') and contextual use case ('cloud-hosted or multi-project contexts'), but doesn't provide additional semantics for other parameters. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Query the append-only audit trail of all actions taken on the project.' It specifies the verb ('query') and resource ('audit trail'), and mentions the 'append-only' nature, which adds useful context. However, it doesn't explicitly differentiate this audit trail query from sibling tools like cantrip_meter_history or cantrip_snapshot, which might also involve historical data retrieval.

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

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

The description provides some usage guidance: it explains when to use the 'project' parameter ('useful in cloud-hosted or multi-project contexts') and hints at a default behavior ('.cantrip.json'). However, it doesn't offer explicit when-to-use vs. when-not-to-use advice, nor does it mention alternatives among the many sibling tools (e.g., cantrip_meter_history for meter-specific history). The guidance is implied rather than comprehensive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: credit costs (5 credits for brief_text), file system impact (writes .cantrip.json automatically), workflow implications (need to add entities manually if no brief), and post-creation recommendations. It doesn't mention error conditions, rate limits, or authentication requirements, but provides substantial operational context beyond basic functionality.

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

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

The description is appropriately sized with three sentences that each serve distinct purposes: first explains core functionality and parameter options, second describes the automatic file writing, third provides workflow guidance. It's front-loaded with the most critical information. Minor improvement could be made by tightening the third sentence, but overall it's efficient with zero wasted text.

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

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

Given no annotations and no output schema, the description provides substantial context for a creation tool with 4 parameters. It covers the main functionality, parameter semantics, cost implications, file system impact, and workflow recommendations. The main gap is lack of information about return values or error conditions, but for a tool with good parameter documentation and behavioral transparency, this is reasonably complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining the semantic differences between brief_text and brief_path parameters, including cost implications (5 credits for brief_text), preference guidance ('preferred' for brief_text), and behavioral differences (file reading locally for brief_path). It also clarifies that name and description are required while brief parameters are optional, which goes beyond the schema's required field listing.

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

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

The description clearly states the tool creates a new project and connects the workspace to it, specifying the verb 'create' and resource 'project'. It distinguishes from siblings like cantrip_connect (which likely connects to existing projects) and cantrip_entity_add (which adds entities after creation). The description also mentions automatic .cantrip.json file writing, which is a specific implementation detail.

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

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

The description provides clear context on when to use different parameter combinations (with brief_text for auto-extraction costing credits, with brief_path for file reading, or without brief for free empty creation). It also mentions the workflow after creation ('add a few entities and confirm them with the user before going deeper'). However, it doesn't explicitly state when NOT to use this tool or name specific alternatives among the sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the return values (available, reserved, total credits) and hints at the tool's read-only nature through 'Check', but it does not detail potential errors, rate limits, authentication needs, or how 'reserved credits' are calculated. The description adds some context but leaves gaps in behavioral traits.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by parameter guidance in the second. Both sentences earn their place by providing essential information without redundancy, making it efficient and well-structured for quick understanding.

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

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

Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is mostly complete: it covers the purpose, return values, and parameter usage. However, it lacks details on error handling or edge cases (e.g., what happens if credits are negative), which would enhance completeness for a financial tool.

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

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

The input schema has 100% description coverage for the single parameter 'project', so the baseline is 3. The description adds value by explaining the parameter's purpose ('overrides .cantrip.json') and when it's required ('Required in environments where cantrip_connect cannot write to the filesystem'), providing practical context beyond the schema's technical definition.

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

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

The description clearly states the specific action ('Check remaining credits') and the resource ('credits'), distinguishing it from sibling tools like cantrip_meter_history or cantrip_meter_tiers by focusing on current balance rather than historical data or pricing tiers. It explicitly lists the three return values (available, reserved, and total credits), making the purpose unambiguous.

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

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

The description provides clear context for when to use the optional 'project' parameter ('useful in cloud-hosted or multi-project contexts'), but it does not explicitly state when to use this tool versus alternatives like cantrip_meter_history or cantrip_status. It implies usage for checking credit balances but lacks explicit exclusions or comparisons to siblings.

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

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

With no annotations provided, the description carries full burden. It discloses that this is a read operation ('View'), implies it returns historical data ('recent', 'history'), and mentions filesystem constraints for the project parameter. However, it doesn't specify pagination behavior, rate limits, authentication requirements, or error conditions, leaving some behavioral aspects unclear.

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

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

The description is efficiently structured in two sentences: the first states the core purpose and data included, the second provides specific usage guidance for the optional parameter. Every sentence adds value with zero wasted words, and it's appropriately front-loaded with the main functionality.

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

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

For a read-only tool with 2 parameters (both well-documented in schema) and no output schema, the description provides good context about what data is returned and when to use the optional parameter. However, without annotations or output schema, it could better explain the return format (e.g., structure of transactions, balance presentation) and any limitations (e.g., how 'recent' is defined).

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description adds marginal value by explaining the 'project' parameter's purpose ('override .cantrip.json') and when it's useful ('cloud-hosted or multi-project contexts'), but doesn't provide additional syntax or format details beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('View recent credit transactions') and resource ('credit transactions'), distinguishing it from siblings like cantrip_meter_balance (which likely shows current balance only) and cantrip_history (which might be more general). It specifies what data is included: 'usage debits, purchases, and running balance'.

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

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

The description explicitly provides when-to-use guidance: 'Pass `project` to override `.cantrip.json` — useful in cloud-hosted or multi-project contexts.' This gives clear context for using the optional parameter versus relying on default configuration, addressing a specific use case scenario.

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

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

No annotations are provided, so the description carries full burden. It states this is a read operation ('View'), implying it's non-destructive, but doesn't disclose any behavioral traits such as authentication requirements, rate limits, error conditions, or what happens if no credit packs are available. For a tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core action ('View available credit packs') and adds specific details about what's shown. There's no wasted language, and it's appropriately sized for a simple tool with no parameters.

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

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

Given the tool's low complexity (0 parameters, no annotations, no output schema), the description is minimally adequate. It explains what the tool does and what information it returns, but lacks context on usage, behavioral traits, or how it fits with siblings. With no output schema, it should ideally describe the return format more explicitly, but it does mention key output fields.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, but it does mention the output content (tier name, credits, price), which is helpful since there's no output schema. This slightly exceeds the baseline of 3 for zero-parameter tools.

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

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

The description clearly states the verb ('View') and resource ('available credit packs'), specifying what information is shown (tier name, credits, price). It distinguishes from siblings like 'cantrip_meter_balance' (which likely shows current balance) and 'cantrip_meter_history' (which likely shows usage history). However, it doesn't explicitly contrast with these siblings, keeping it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to be authenticated), when it's appropriate (e.g., before purchasing credits), or what other tools might be better for related tasks (like checking current balance with 'cantrip_meter_balance').

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

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

With no annotations provided, the description carries the full burden and adds valuable behavioral context: opportunities persist across calls, re-running updates rather than replaces them, and UUIDs are stable for follow-up actions. It also hints at filesystem dependencies with the project parameter override. While it doesn't cover rate limits or error handling, it provides meaningful operational insights beyond basic functionality.

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

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

The description is efficiently structured with four sentences, each adding distinct value: purpose, UUID usage, persistence behavior, and parameter guidance. It is front-loaded with the core function and avoids redundancy, making every sentence earn its place without wasted words.

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

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

Given 1 parameter with full schema coverage, no output schema, and no annotations, the description does well by covering purpose, behavior, and parameter context. It addresses complexity around opportunity persistence and project overrides. However, it lacks details on output format or error cases, leaving minor gaps for a tool with no structured output documentation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining the project parameter's purpose: 'overrides .cantrip.json — useful in cloud-hosted or multi-project contexts' and ties it to filesystem constraints. This contextualizes the parameter beyond the schema's technical description, justifying a higher score.

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

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

The description clearly states the tool's purpose: 'List gap-analysis opportunities — things that would move the project closer to ideal state.' It specifies the verb ('List') and resource ('gap-analysis opportunities'), and distinguishes it from siblings by mentioning UUIDs for cantrip_next_prompt/run. However, it doesn't explicitly differentiate from other listing tools like cantrip_history or cantrip_snapshot, preventing a perfect score.

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

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

The description provides clear context for usage: 'Review the project snapshot with the user before running opportunities' and explains when to use the project parameter ('useful in cloud-hosted or multi-project contexts'). It also implies alternatives by referencing cantrip_next_prompt/run for acting on opportunities. However, it lacks explicit exclusions or comparisons to other sibling tools like cantrip_snapshot for project review.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it generates prompts (implying a read/creation operation), specifies zero credit cost (important for cost management), and mentions the 'project' parameter's override functionality. However, it lacks details on potential errors, rate limits, or authentication needs, leaving some behavioral aspects unclear.

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

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

The description is highly concise and well-structured in two sentences. The first sentence states the core purpose and key features (context-rich, ontology-baked, zero cost), while the second provides specific usage guidance for the 'project' parameter. Every word earns its place with no redundancy or fluff.

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

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

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is mostly complete. It covers the purpose, key behavioral traits (zero cost, override functionality), and usage context. However, without an output schema, it does not describe the return value (e.g., prompt format or structure), which is a minor gap for a tool that generates outputs.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description adds minimal value beyond the schema by briefly explaining the 'project' parameter's purpose (to override '.cantrip.json' in specific environments), but does not provide additional syntax, format, or usage details for either parameter. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose with a specific verb ('Generate') and resource ('context-rich LLM prompt for an opportunity'), and distinguishes it from siblings by specifying it returns a ready-to-use prompt with ontology context baked in. It explicitly mentions zero credit cost, which further differentiates it from potential cost-incurring tools.

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

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

The description provides clear context for when to use the tool (to generate prompts for opportunities) and includes a specific usage note about the 'project' parameter overriding '.cantrip.json' in cloud-hosted or multi-project contexts. However, it does not explicitly state when NOT to use this tool or name alternatives among the sibling tools, which prevents a perfect score.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool runs inline, returns a summary upon completion, and has parallelism constraints (blocks concurrent runs of the same loop type). However, it lacks details on permissions, rate limits, error handling, or what 'enrichment' entails beyond AI usage, leaving behavioral gaps.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose. Sentences are efficient, but the parallelism explanation could be slightly condensed. Overall, it avoids unnecessary repetition and earns its place with useful information.

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

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

Given no annotations and no output schema, the description provides moderate completeness. It covers purpose, usage, and some behavioral traits, but lacks details on return values (only mentions a summary), error cases, or specific enrichment examples. For a tool with AI execution and potential side effects, more context would be beneficial.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (id and project). The description adds value by explaining that 'project' overrides .cantrip.json and is useful in cloud-hosted or multi-project contexts, but does not provide additional syntax or format details beyond the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool executes an enrichment opportunity with AI, specifying it can update existing entities' missing fields (targeted) or generate new entities (bulk). It distinguishes from siblings by focusing on AI-powered enrichment execution, unlike tools like cantrip_connect or cantrip_history that handle connections or history.

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

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

The description provides clear context on when to use this tool: for AI-driven enrichment, with parallelism rules (different loop types concurrently, same type blocked). It mentions using the 'project' parameter to override .cantrip.json in cloud-hosted or multi-project contexts. However, it does not explicitly state when not to use it or name specific alternatives among siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly describes the three actions and their effects (e.g., delete removes 'all its data'), which is helpful. However, it lacks details on permissions needed, rate limits, error handling, or what happens to dependent data beyond 'all its data'. For a tool with destructive operations and no annotations, this leaves significant behavioral gaps.

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

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

The description is efficiently structured with a brief opening statement followed by bullet points for each action, each explaining purpose and default behavior. Every sentence earns its place with no redundant information, making it easy to scan and understand.

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

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

Given the tool's complexity (multiple actions including destructive operations), no annotations, and no output schema, the description is moderately complete. It covers the basic actions and defaults but lacks details on permissions, error responses, or return formats. For a tool with delete functionality and no structured safety hints, more behavioral context would be beneficial.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by mentioning the default action and connected project behavior, but doesn't provide additional syntax, format details, or constraints. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool manages projects with three specific actions (list, update, delete), providing a verb+resource combination. It distinguishes from siblings by focusing on project management, unlike tools like cantrip_connect or cantrip_history. However, it doesn't explicitly differentiate from all siblings (e.g., cantrip_entity_edit might overlap in editing functionality).

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

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

The description provides clear context for when to use each action (list for listing all projects, update for modifying name/description, delete for removing projects). It also specifies default behaviors (connected project unless slug provided). However, it doesn't explicitly state when NOT to use this tool versus alternatives like cantrip_entity_edit for editing entities, or provide explicit alternatives for project management tasks.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool lists items but doesn't describe return format, pagination behavior, authentication requirements, rate limits, or whether this is a read-only operation. The description adds some context about filesystem environments but lacks comprehensive behavioral information.

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

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

The description is perfectly concise with two sentences that each earn their place. The first sentence states the core purpose, and the second provides parameter guidance. There is zero wasted text and it's well-structured with front-loaded information.

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

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

For a single-parameter tool with 100% schema coverage but no annotations and no output schema, the description provides adequate basic information about purpose and parameter usage. However, it lacks details about return values, error conditions, and behavioral characteristics that would be helpful given the absence of annotations and output schema.

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

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

Schema description coverage is 100%, so the schema already fully documents the single 'project' parameter. The description adds marginal value by explaining when to use the parameter ('cloud-hosted or multi-project contexts') and mentioning '.cantrip.json' override, but doesn't provide additional syntax or format details beyond what the schema provides.

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

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

The description clearly states the verb ('List') and resource ('all items pending review') with specific scope ('inferred entities and open escalations'). It distinguishes from some siblings like cantrip_review_accept/dismiss/reject/resolve which perform actions on reviews, but doesn't explicitly differentiate from other list tools like cantrip_history or cantrip_status.

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

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

The description provides clear context about when to use the 'project' parameter ('useful in cloud-hosted or multi-project contexts') and mentions overriding '.cantrip.json'. However, it doesn't explicitly state when to use this tool versus alternatives like cantrip_history or cantrip_status, nor does it provide exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden. It mentions that accepting marks an entity as 'verified ground truth,' which implies a write/mutation operation, but it does not disclose behavioral traits such as permissions required, whether the action is reversible, rate limits, or what happens to the entity post-acceptance. This leaves significant gaps for a mutation tool.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a concise second sentence about the 'project' parameter. Both sentences earn their place by adding value without waste, making it appropriately sized and well-structured.

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

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

Given that this is a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., permissions, reversibility), does not explain return values or errors, and while it covers parameter context, it does not compensate for the absence of structured safety or output information.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('id' and 'project') fully. The description adds minimal value by explaining that 'project' overrides '.cantrip.json' and is useful in specific contexts, but it does not provide additional syntax or format details beyond the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the specific action ('accept an inferred entity') and the outcome ('marking it as verified ground truth'), distinguishing it from sibling tools like cantrip_review_dismiss, cantrip_review_reject, and cantrip_review_resolve. The verb 'accept' paired with the resource 'inferred entity' provides precise purpose.

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

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

The description provides clear context for when to use the 'project' parameter ('useful in cloud-hosted or multi-project contexts'), but it does not explicitly state when to use this tool versus alternatives like cantrip_review_dismiss or cantrip_review_reject. It implies usage in review workflows but lacks explicit exclusions or comparisons.

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

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

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it explains what happens to dismissed entities (kept for history), clarifies that escalations close without resolving, and mentions the filesystem context for the project parameter. It doesn't cover error conditions or response format, but provides substantial operational context.

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

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

Three well-structured sentences with zero waste: first states core purpose, second explains two distinct use cases, third provides important parameter context. Every sentence adds value and the description is appropriately sized for a tool with two parameters and no annotations.

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

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

For a mutation tool with no annotations and no output schema, the description provides good coverage of what the tool does and its behavioral implications. It explains the two distinct use cases and provides important context about the project parameter. The main gap is lack of information about return values or error conditions, but otherwise it's quite complete.

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

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

Schema description coverage is 100%, providing solid baseline documentation for both parameters. The description adds useful context about the 'project' parameter overriding '.cantrip.json' and being required in cloud-hosted/multi-project contexts, but doesn't significantly enhance understanding of the 'id' parameter beyond what the schema already states.

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

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

The description clearly states the verb 'dismiss' and specifies two distinct resources: 'inferred entity' and 'open escalation'. It differentiates from siblings like cantrip_review_accept, cantrip_review_reject, and cantrip_review_resolve by explaining what dismissal does NOT do (not accepting/rejecting entities, not resolving escalations).

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

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

The description provides clear context for when to use this tool: to remove items from review queues without accepting/rejecting (entities) or closing without resolving (escalations). It mentions the 'project' parameter override use case. However, it doesn't explicitly state when NOT to use it or directly compare to alternatives like cantrip_review_accept or cantrip_review_resolve.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: the action is a 'soft-delete' (not permanent deletion) and entities are 'kept for history'. It also hints at environmental constraints ('cloud-hosted or multi-project contexts'), though it doesn't cover permissions, rate limits, or error handling.

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

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

The description is two concise sentences with zero waste. The first sentence states the purpose and key behavior, and the second explains the optional parameter's use case. It's front-loaded and efficiently structured.

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

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

For a mutation tool with no annotations and no output schema, the description is adequate but has gaps. It covers the soft-delete behavior and parameter context, but doesn't explain what happens after rejection (e.g., state changes, notifications) or potential side effects. Given the complexity, it's minimally viable.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds some context for the 'project' parameter (overrides .cantrip.json, useful in specific environments), but doesn't provide additional meaning for 'id' or beyond what the schema offers. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('reject') and resource ('inferred entity'), and explains it's a 'soft-delete, kept for history'. It doesn't explicitly differentiate from siblings like 'cantrip_review_accept' or 'cantrip_review_dismiss', but the 'reject' verb is specific enough to imply distinction.

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

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

The description provides clear context on when to use the 'project' parameter ('to override .cantrip.json — useful in cloud-hosted or multi-project contexts'), but doesn't specify when to use this tool versus alternatives like 'cantrip_review_accept' or 'cantrip_review_dismiss'. The guidance is helpful but incomplete for sibling differentiation.

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

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

No annotations are provided, so the description carries the full burden. It mentions that 'project' is 'Required in environments where cantrip_connect cannot write to the filesystem,' adding some behavioral context about system dependencies. However, it lacks details on permissions, side effects (e.g., if resolution closes the escalation), or error handling, which are critical for a mutation tool.

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

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

The description is two sentences, front-loaded with the core purpose and followed by a specific parameter guideline. Every sentence earns its place by providing essential information without waste, making it efficient and well-structured.

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

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

Given no annotations and no output schema, the description is moderately complete. It covers the tool's purpose and a key parameter nuance, but as a mutation tool, it should include more about behavioral traits (e.g., what 'resolve' entails, any side effects). The context is adequate but has clear gaps for safe agent use.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal value by explaining that 'project' overrides '.cantrip.json' and is useful in specific contexts, but it doesn't provide additional semantics beyond what the schema offers. Baseline 3 is appropriate as the schema handles most documentation.

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

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

The description clearly states the verb ('Resolve') and resource ('an open escalation'), specifying the action and target. It distinguishes from siblings like cantrip_review_accept/reject/dismiss by focusing on resolution with a message, though it doesn't explicitly contrast them. The purpose is specific but could be more distinct from similar tools.

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

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

It provides clear context for when to use the 'project' parameter ('to override .cantrip.json — useful in cloud-hosted or multi-project contexts'), which helps guide usage in specific environments. However, it doesn't explicitly state when to use this tool versus alternatives like cantrip_review_accept or cantrip_review_dismiss, missing sibling differentiation.

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

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

No annotations are provided, so the description carries the full burden. It describes the tool's behavior at three zoom levels and mentions the 'project' parameter's override functionality, which is useful context. However, it lacks details on permissions, rate limits, or error handling, leaving gaps in behavioral disclosure for a tool with multiple operational modes.

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

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

The description is well-structured and front-loaded, starting with the core functionality ('Browse project data at three zoom levels') and efficiently detailing each mode in a logical flow. Every sentence adds essential information without redundancy, making it easy to parse quickly.

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

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

Given the tool's complexity (three operational modes) and no annotations or output schema, the description does a good job covering usage scenarios and parameter interactions. However, it lacks details on output formats or error cases, which could be important for an agent invoking this tool without structured output guidance.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the semantics of parameter combinations: it clarifies how 'entity_type' and 'entity_id' interact (e.g., 'entity_type only: list all entities... entity_type + entity_id: show full detail') and provides examples like 'icps', 'pain-points', which enhance understanding beyond the schema's generic descriptions.

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

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

The description clearly states the tool's purpose: 'Browse project data at three zoom levels' with specific details about what each level provides (project overview, list entities by type, show full detail for one entity). It distinguishes from siblings by stating 'This is the primary tool for listing and inspecting entities,' differentiating it from tools like cantrip_entity_add or cantrip_review.

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

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

The description provides explicit guidance on when to use this tool: 'No args: project overview... entity_type only: list all entities... entity_type + entity_id: show full detail.' It also specifies when to use the 'project' parameter: 'Pass `project` to override `.cantrip.json` — useful in cloud-hosted or multi-project contexts,' offering clear context for alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's a read-only diagnostic tool (implied by 'Check' and 'Returns'), handles authentication states, provides setup instructions for missing API keys, and sources data from '.cantrip.json'. However, it lacks details on error handling or rate limits, keeping it from a perfect score.

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

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

The description is front-loaded with the core purpose, followed by return details and edge-case handling. Both sentences earn their place: the first defines the tool's function, and the second adds critical context for setup scenarios. There is zero waste or redundancy.

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

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

Given the tool's complexity (diagnostic with conditional outputs), no annotations, and no output schema, the description does well by explaining what it returns and handling missing API keys. However, it doesn't detail the exact structure of returned data (e.g., JSON format), which could be useful for an agent, preventing a perfect score.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on behavior and output without redundant param info. It earns a 4 for not adding unnecessary details, though a 5 would require exceptional clarity beyond this baseline.

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

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

The description clearly states the tool's purpose with specific verbs ('Check', 'Returns') and resources ('daemon health, authentication, and current project'), distinguishing it from siblings like cantrip_connect (connection setup) or cantrip_project (project management). It explicitly lists what gets checked and returned, avoiding tautology with the name.

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

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

The description provides explicit usage guidance: it states when to use this tool ('Check daemon health, authentication, and current project') and includes an alternative scenario ('When CANTRIP_API_KEY is missing, returns setup instructions'), which helps differentiate it from tools like cantrip_connect for initial setup or cantrip_project for project-specific actions.

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