Bucky

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

The description adds meaningful behavioral detail beyond the annotations: it explicitly enumerates what the tool does NOT do, including not calling a database, geocoder, AI model, or third-party API. This granularity is more informative than the readOnlyHint and idempotentHint annotations alone, and it accurately reinforces the static, safe nature of the operation.

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 compact and front-loaded: purpose first, then behavior, then admissible inputs. The enumerated status list is somewhat redundant with the schema enum, but the overall structure is efficient and every sentence contributes to correct tool selection and invocation.

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 static lookup tool, the description covers purpose, behavioral boundaries, and accepted inputs. It does not describe the return format or how the 'safe next action' is presented, but given the small parameter count and rich schema/annotations, the tool is sufficiently specified for correct invocation.

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 applies. The description repeats the list of accepted statuses, which the schema already provides via the enum and status description. It adds the constraint 'Accepts exactly one of' and the verbatim-copy guidance, but these are already effectively covered by the schema.

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 states a specific verb and resource: 'Explain one Bucky coverage or per-fact provenance status and the safe next action.' It clearly distinguishes this from dynamic analysis tools by emphasizing that it is a 'pure static lookup' that does not inspect addresses or retrieve property data. This is not a tautology and gives the agent a precise understanding of the tool's role.

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 gives clear context: this is a static lookup with no external calls, which tells the agent when not to use it for data retrieval or analysis. However, it does not explicitly name sibling alternatives or state direct when-to-use versus when-not-to-use conditions, leaving some inference to the agent.

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?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description explicitly states it 'Makes no database, geocoding, AI, or third-party API call' and calls itself static. This adds concrete behavioral specificity about side-effect-freedom and the absence of external dependencies.

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?

Two tight sentences with no filler. The first sentence front-loads the verb and resource, then lists the guide's contents; the second adds a meaningful behavioral guarantee. Every clause earns its place.

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 static read-only guide tool, the description is complete: it specifies the topics covered, confirms no external calls, and all parameter semantics live in the schema. No output schema exists, but the nature of a guide makes its return format secondary.

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%; the required 'context' parameter is fully documented in the schema with length, perspective, and privacy guidance. The tool description adds no parameter-level detail, so the baseline score of 3 is appropriate.

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 opens with a specific verb and resource: 'Return a static guide to the Bucky MCP surface.' It then enumerates the guide's content areas, which clearly distinguishes it from the feasibility and project-analysis sibling 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 makes the intended use clear by listing what the guide covers (sign-in behavior, OAuth, Cursor/CLI connection, safety rules). It does not explicitly name sibling alternatives or exclusion conditions, but the tool's unique guide purpose is evident enough that an agent can route to it correctly.

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?

Annotations already signal readOnly, idempotent, and non-destructive behavior, so the description's job is to add operational nuance. It does so extensively by explaining the `status` field on envelope values and how to interpret nulls (`no_limit_in_bylaw`, `not_extracted`, `site_specific_schedule`), including a critical warning not to misreport those values. This is valuable behavior not visible in the schema.

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 unknowable, then returns structure, then usage guidance, then nuanced status semantics. It is relatively long but every sentence earns its place, especially the status interpretation rules and the 'Never report' warning.

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?

With no output schema provided, the description compensates by detailing what is returned and how to interpret `status` values. It also covers tool limitations (one address, no search/compare) and explicit usage boundaries, making it sufficient an agent needs to call the tool correctly.

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 schema already documents all three parameters at 100% coverage, so the baseline is 3. The description adds meaningful semantic context beyond the schema by constraining the address to Canada or the US and emphasizing that the tool resolves one address per call, which directly affects parameter usage.

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 opens with a specific verb and resource ('Look up what can be built at a specific street address in Canada or the US') and enumerates the exact returned data groups: lot dimensions, zone and permitted uses, and building envelope metrics. It also distinguishes itself from search/compare tools by explicitly stating it resolves one address at a time.

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 gives concrete 'Use when' triggers ('what they can build, how tall, how close to the property line, how big their lot is, or what their property is zoned for') and explicit exclusions ('Do not use for questions that are not about a specific address'). This leaves little ambiguity about when to select this tool.

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?

Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by specifying the returned bundle's composition and noting that external_ref appears only when the project was imported. Auth or response-size details are absent, but they are secondary given the strong annotations.

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 entire description is two sentences: one front-loaded, dense list of returned contents and one usage-timing sentence. There is no filler or repeated schema 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 read-only fetch with no output schema, this description gives the agent the essential expectations: one project, a defined set of envelope pieces, compact status, and the conditional external_ref. It also connects the call to a workflow point. It could add response shape or ordering, but the existing detail is sufficient for correct selection and invocation.

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 schema documents context and projectId in detail, leaving documentsLimit and evidenceLimit with only min/max/default values. The description compensates by naming 'document summaries' and 'evidence summaries' in the output, which lets the agent infer what those limits control. No parameter meaning is left entirely unexplained.

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 opens with the specific verb 'Load one project' and enumerates the exact bundle contents: analysis envelope, compact agentStatus, document summaries, evidence summaries, memory digest, and conditional external_ref. This is far more specific than sibling names like getFeasibilitySnapshot or produceProjectReport, making the tool's scope unmistakable.

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 tells an agent when to invoke it: 'Use before composing reports or after scheduling analysis.' It does not name alternative tools or give when-not cases, but the stated timing provides solid selection context.

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?

The description adds valuable behavior (meter spend, irreversibility, signed URL, receipt), but it contradicts the `idempotentHint: true` annotation: a confirm call that spends records.exports and is irreversible is not idempotent on repeat. Because of this contradiction, the annotation-contradiction rule applies.

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?

A single dense sentence front-loads the main purpose and then layers the conditional modes and consequences without waste. Every clause carries operational meaning.

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 output schema, it usefully specifies the return shape (signed URL + receipt, not PDF bytes) and the irreversible spend. The main gap is the idempotency contradiction and some unelaborated parameters, but those are mostly inferable from names/enums.

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 coverage is only 38%, so the description must compensate. It clarifies the two most important parameters (`preview` and `confirm`) and their side effects, but does not add meaning for `projectId`, `audience`, `detail`, `request`, or `planName` beyond their names/enums.

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 names a specific action (compose/export), a specific resource (project report PDF), and the operation mode (preview vs confirm). It also explicitly states the result is a download URL, never PDF bytes, which distinguishes it from a generic file-returning tool.

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 gives a clear decision rule: use `preview=true` to avoid meter spend, use `confirm=true` to save/export. It also warns confirm is irreversible, so an agent can choose appropriately. This is explicit conditional guidance.

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?

The description goes well beyond the annotations: it reveals async fire-and-forget behavior ('does not block on completion'), irreversibility ('a queued run cannot be un-queued from MCP'), and a rate-limiting caveat for the follow-up tool. No statement contradicts the annotations.

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 sentences deliver the core action, return behavior, irreversibility, and polling guidance with zero filler. The most important information—what the tool does—is front-loaded.

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 an async action with no output schema, this is complete: it describes the immediate return values (agentStatus and receipt id), non-blocking behavior, irreversibility, and the correct way to check progress. Nothing essential is missing for an agent to invoke it correctly.

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 little parameter-specific meaning beyond noting the project must be 'saved' and that the run is 'fresh'; the schema itself already documents projectId and the context parameter extensively.

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 opens with a precise verb+resource: 'Enqueue a fresh deterministic analysis run for a saved project.' It distinguishes itself from the sibling read/status tools by stating it returns immediately and does not block on completion, and by explicitly saying it is 'not a status endpoint.'

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 gives clear direction on follow-up behavior: 'Re-check with getProjectContext, but no more than once every 15 seconds.' It also tells the agent when not to use this tool for polling ('not a status endpoint') and warns the operation is irreversible, which helps decide whether to call it at all.

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?

Annotations only provide readOnlyHint false, idempotentHint true, and destructiveHint false, but the description goes far beyond: preview writes nothing, writes return a receipt, operations are not reversible via MCP, geocoding behavior (address geocoded server-side, coordinates never re-geocoded), and result flags ('resolved: false', 'coordinateSource: "geocoded"'). This is rich operational context that materially changes how the agent should call and interpret the 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 long, but it needs to be for a tool with three distinct modes and 14 parameters. It front-loads the action taxonomy and then systematically covers input selection, result interpretation, and reversibility. Some repetition of enum values from the schema is present, but each sentence adds operational value; no filler.

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 output schema, the description covers the crucial return behaviors: preview returns a field-level diff, writes return a receipt, and the agent is told to inspect 'geography' flags. It also covers input provenance rules and irreversible-write constraints. The main gap is not describing the full response shape, but the flags and receipt mention give the agent enough to proceed safely.

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 coverage is 71%, so the description must compensate, and it does: it clarifies the address-or-lat/lng relationship, tells the agent to pass lat/lng when already available, explains that coordinates resolve to a city while address alone is geocoded server-side, and gives the semantic purpose of idempotencyKey and externalRef. This goes well beyond the schema's per-field 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 opens by specifying three distinct actions ('create', 'attach_parcels', 'attach_reference') with specific verbs and resources, and names getFeasibilitySnapshot as the source for parcel IDs. This clearly differentiates the tool from siblings like updateProject and getProjectContext without ambiguity.

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 gives explicit conditions for each action mode: create needs address or lat/lng, attach_parcels uses parcelExternalId, attach_reference links a section. It explains preview semantics and the geocoding tradeoff. It does not explicitly contrast with updateProject or setProjectMapListing, but the action-mode selection criteria are strong enough for correct usage.

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?

The description goes far beyond the annotations, disclosing exactly what data is published, that a build-lot centroid is required, that preview writes nothing, and that unlisting does not un-share previously collected data. These are meaningful behavioral traits not visible in annotations or schema.

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?

Every sentence earns its place; the description is dense but logically organized: action, published scope, prerequisite, privacy warning, preview behavior, and unlisting side effects. It front-loads the core purpose and then layers important constraints.

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 privacy-sensitive mutation tool with no output schema, the description fully equips an agent: it states prerequisites, what gets published, how to preview without side effects, and what unlisting does not undo. Nothing critical is missing.

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 coverage is 75%, and the description adds meaning by explaining what 'listed' publishes (centroid, name, zone, typology, lifecycle) and detailing the preview behavior. It does not describe projectId, but the UUID format and pattern already cover its semantics.

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 uses a specific verb phrase, 'List or unlist a project on the public Bucky map,' naming both the resource and the action. It distinguishes itself from sibling tools like updateProject by focusing narrowly on map listing visibility, not general project editing.

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 gives clear when-to-use context: to publish or unpublish a project on the public map, with explicit privacy guidance and the preview mode as a safe way to check. It does not explicitly name alternative tools or when-not-to-use cases, so it misses the top bar for explicit 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?

Annotations already mark the tool as non-read-only and non-destructive, but the description adds valuable behavior: the server asks the MCP client to show a form, and nothing is saved unless the human accepts it. This clarifies the human-in-the-loop nature beyond the structured fields.

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 focused sentences: purpose, trigger conditions, and side-effect gating. The description is front-loaded and every sentence earns its place with no filler.

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?

The description covers when to call, what happens, and the human-acceptance requirement. Combined with the rich schema and annotations, an agent has everything needed to invoke the tool correctly; the lack of an output schema is not a meaningful gap here.

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%, and the schema already documents the context requirements, UUID behavior, and affectedToolName. The description adds no additional parameter-level detail, so the baseline score of 3 is appropriate.

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 states a specific action and resource: 'Open a human-reviewed feedback form and submit it to the Bucky product team.' It clearly differentiates this tool from sibling tools by emphasizing human review and feedback submission.

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 defines when to call: only when the user asks to send feedback, report a problem, suggest an improvement, or praise something. It also gives a clear exclusion: 'Do not use for silent agent self-reporting.'

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the performance trait 'Cheap enough to poll' and the internal context 'Used by the Bucky app view', which are useful behavioral notes beyond the annotation flags. No contradiction exists.

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 short sentences with zero filler. The core purpose is front-loaded, and the alternative guidance is reported efficiently. Every sentence earns its place without 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?

For a simple status-poll tool with read-only annotations, the description covers the essential usage and routing. It does not describe the return format or what `agentStatus` contains, but with no output schema and an intuitive tool name, this gap is minor. The explicit pointer to `getProjectContext` strengthens completeness.

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 only 50%. The `projectId` parameter has only type/format/pattern, no description, and the description text does not explain it. The `context` parameter is described in the schema, but the description adds no parameter information. Since coverage is below 50%, the description should compensate but does not, leaving `projectId` undocumented in both places.

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 returns only the analysis `agentStatus` for a project. The verb 'Return' is specific, the resource is defined (analysis agentStatus), and it explicitly distinguishes itself from `getProjectContext` by saying the model should use that instead for a broader context. No ambiguity remains.

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 context: it is 'Cheap enough to poll' and 'Used by the Bucky app view', then directly instructs to call `getProjectContext` instead when more context is needed. This gives clear when-to-use and when-not-to-use guidance, naming the alternative tool.

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?

The description adds meaningful side-effect context beyond the annotations: preview=true writes nothing, writes return a receipt, undoOperationId restores prior fields, and the tool never archives or deletes. This complements the readOnlyHint=false and destructiveHint=false annotations without contradicting them.

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 compact: four short sentences, each contributing distinct information, with the core purpose front-loaded. No filler or redundant restatement of the title.

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 tool with 7 parameters and no output schema, the description covers the essential semantics: what can be patched, the preview dry-run behavior, the receipt/undo flow, and non-destructive scope. It stops short of fully describing return shapes, but the provided information is sufficient for most correct calls.

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 57%, and the description adds some value by identifying the updatable fields and preview/undo behavior. However, it doesn't explain projectId or lifecycleStatus semantics beyond what the schema provides, and it relies on the schema for context and externalRef 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 uses a specific verb ('Patch') and names the target resource and fields ('project metadata (name, lifecycle status, externalRef)'). It is clear and not a tautology, but it does not differentiate from siblings like saveToProject beyond a brief 'Does not archive or delete.'

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 explains preview and undo mechanics but does not state when to use this tool versus any alternative or sibling. No exclusion conditions or routing guidance are provided, so an agent must infer when this is the right tool.

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