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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that the tool reports heuristic evidence, confidence, anomalies, and samples, which gives some behavioral context. However, it does not explain what 'adaptive row/column geometry' means, how the heuristic works, or what the output structure looks like. No contradiction with 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 description is a single sentence that is concise and front-loaded with the core action. It lists the key outputs without unnecessary detail. However, it could be slightly more structured by separating the purpose from the output details.

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 tool has a complex input schema with 6 parameters, 0% schema description coverage, and no parameter documentation in the description. The output schema exists, so return values are covered, but the description does not explain the analysis methodology, the meaning of 'adaptive', or how the parameters influence the analysis. An agent would struggle to know what values to provide for tolerance, expected_columns, and expected_items_per_row.

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 0%, so the description must compensate for the 6 parameters. It does not explain the meaning of snapshot_id, selector, tolerance, expected_columns, expected_items_per_row, or global. The description mentions 'adaptive row/column geometry' which hints at expected_columns and expected_items_per_row, but it does not clarify how tolerance or selector work. This is a significant gap.

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 ('Detects') and resource ('adaptive row/column geometry') and lists the outputs (heuristic evidence, confidence, anomalies, samples). It is clear about what the tool does, though it does not explicitly distinguish itself from sibling tools like query_nodes or inspect_figma_file.

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 does not mention that this is a read-only analysis tool, nor does it explain when an agent should prefer analyze_figma_layout over query_nodes or inspect_figma_file. The context is implied by the name and description but not stated.

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 and idempotentHint=true, so the safety profile is covered. The description adds the explicit guarantee 'without returning secrets', which is valuable behavioral context. However, it does not describe any side effects, permissions, or output details beyond that, so it adds only modest value over 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?

The description is a single sentence that immediately states the purpose and the key constraint (no secrets). There is no fluff, and the information is front-loaded. It is an ideal length for a 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?

For a zero-parameter tool with an output schema, the description is reasonably complete. It explains what is checked (configuration and reachability) and a critical guarantee (no secrets). It lacks explicit usage context, but the output schema covers return values, and the low complexity keeps the tool simple enough.

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 zero parameters, and the input schema is empty. Per the baseline for 0-parameter tools, a score of 4 is appropriate. The description does not need to explain parameters, and the schema coverage is trivially complete.

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 clear verb ('Checks') and resource ('configuration and reachability'), and the title names the specific services (Figma, Yandex Disk, state-store). It distinguishes itself as a general connectivity check, though it does not explicitly differentiate from siblings like verify_yandex_upload. The phrase 'without returning secrets' adds a useful boundary.

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?

No guidance is provided on when to use this tool versus alternatives. It does not mention that it should be run before exports, as a diagnostic, or when to prefer it over verify_yandex_upload. The intended usage context is left entirely to the agent's inference.

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 destructive and idempotent behavior; the description adds useful nuance by scoping destruction to 'local temporary data' and by disclosing the safety gate: deletion happens only after verification or explicit risk confirmation. This is meaningful behavioral context beyond the annotation flags.

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 one focused sentence with no filler. It front-loads the action and object, then states the safety condition. Every clause contributes either scope or an important caveat.

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 an output schema present and annotations covering destructiveness/idempotency, the description does not need to describe return values or basic safety. It supplies the key deletion scope and conditional logic. The only minor gap is that 'verification' is left vague and the exact behavior when neither condition is met is not explicitly spelled out.

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 0%, so the description carries some burden. 'Explicit risk confirmation for incomplete jobs' reasonably maps to confirm_partial_cleanup, adding meaning to that flag. However, the description never names job_id or clarifies how it selects the workspace, leaving the agent to infer the obvious mapping.

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 ('Deletes local temporary data') and a clear resource (local data associated with a job workspace). It also distinguishes itself from the export/verification siblings by focusing on cleanup and deletion, so an agent can tell this tool apart without inspecting schemas.

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 a usable precondition: cleanup happens 'only after verification' or with 'explicit risk confirmation for incomplete jobs.' However, it never defines what 'verification' entails, names no alternatives, and does not place the tool in a workflow relative to siblings like verify_yandex_upload or retry_failed_items.

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 (readOnly=false, idempotent=true, destructive=false), the description adds that unlocking is restricted to the exact digest and that the tool validates Figma version consistency. This reveals scoping and validation behavior that annotations alone do not convey.

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 that front-loads the main effect ('Unlocks only the exact digest') and then appends the two key constraints. There is no filler, and 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?

With an output schema present, the description correctly avoids explaining return values. It conveys the operation's purpose, preconditions, and rejection behavior, though it leaves the exact semantics of confirmation_summary to inference. Overall, enough context for an agent to invoke it correctly in a normal workflow.

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 0%, but the description does not explain plan_id, the meaning of the digest beyond the schema regex, or what confirmation_summary must contain. The only implicit hint is that 'digest' appears in the description; this is not enough compensation for the lack of 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 verb 'Unlocks' plus the resource 'the exact digest' names a precise action, and the title 'Confirm a previewed export plan' places it between preview_export_plan and execute_export_plan in the workflow. It clearly distinguishes this approval step from its siblings 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?

The description states the exact precondition ('after explicit user approval') and the exclusions ('rejects unresolved clarifications and changed Figma versions'). It does not explicitly name an alternative tool, but the context makes the expected usage position clear.

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 signal readOnlyHint=false and idempotentHint=false, so the description bears the burden of explaining side effects. It adds the useful negative constraint that the tool does not render or upload, but it does not mention the plan's immutability, persistence, or consequences of repeated calls. 'Immutable draft' appears in the title, not in the description itself.

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 short sentences with no filler, and the core behavior is front-loaded. 'Materializes' is mildly jargon-heavy, but the overall description is tight and readable.

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 schema is extremely complex, yet the description provides only one line of behavioral information. It does not explain the draft-plan workflow, which required fields are essential, or how this tool relates to the preview/confirm/execute sibling tools. Since an output schema exists, return values need not be described, but selection and workflow context are still 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 description coverage is 0%, so the description must compensate for the missing parameter documentation. It names high-level concepts like selection, ordering, variables, names and paths, but never maps them to actual parameters or explains the required snapshot_id and destination fields. This is insufficient for a 13-parameter tool with nested objects and 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 verb 'Materializes' plus the title 'Create immutable draft export plan' make it clear the tool creates a persisted draft plan from export configuration. The clause 'Never renders or uploads' distinguishes it from later pipeline stages, though it does not explicitly separate it from preview/confirm siblings.

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?

There is no explicit when-to-use statement or named alternative. The only guidance is the negative restriction 'Never renders or uploads,' which implies this is not for the execute/upload stage but leaves the agent to infer how it relates to preview_export_plan and confirm_export_plan.

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 'background' and 'quickly returns its job ID', explaining the asynchronous non-blocking behavior that is not captured by the annotations. It repeats idempotentHint but also reinforces it in plain language; 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?

A single front-loaded sentence that immediately states the action, async nature, and return behavior. There is no filler or duplicated boilerplate.

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 output schema, the return value is already specified, and the description covers async behavior and the job concept. However, it omits the workflow precondition that the plan must be confirmed, and it doesn't point to follow-up tools such as get_export_status for monitoring, so agents must infer this from sibling tool names.

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?

Description provides no per-parameter meaning for plan_id, digest, or idempotency_key; with schema description coverage at 0%, this is a real gap. The only hints are indirect: 'idempotent' points to idempotency_key and 'verify' to digest, but the agent cannot tell how to construct or validate these values from the description.

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?

States a specific action ('Starts') on a unique resource type (a confirmed export plan / background export/upload/verify job) and tells the agent it returns a job ID. This clearly separates it from siblings like preview_export_plan, confirm_export_plan, and get_export_status, which describe different phases of the workflow.

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 phrase 'confirmed export plan' in the title and 'Starts ... job' imply this is the execution step after confirmation, but the description itself never states a precondition or names alternatives (e.g., use preview_export_plan to validate, get_export_status to poll). Usage context is implied by the workflow rather than made explicit.

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 and idempotentHint, so the safety profile is covered. The description adds some context about returned data, but not deeper behavioral details like pagination mechanics or error semantics. It does not contradict 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?

The description is a single sentence with no filler and places the key verb and resource upfront. The run-on list of outputs and the slightly unclear term 'safe errors' keep it from being exemplary.

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 output schema covers return structure and annotations cover side-effect safety, reducing the burden on the description. However, the description lacks usage timing, alternative tool routing, and parameter semantics, leaving some gaps for a simple read-only 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 schema has 0% description coverage and the description does not explain job_id, event_cursor, or event_page_size. The phrase 'paginated events' hints at cursor/page-size behavior, but the agent must guess how pagination works and what values are acceptable.

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 ('Returns') and enumerates precise output facets: stage totals, safe errors, retry state, verified paths, and paginated events. This makes the tool's function clear, though it does not explicitly differentiate it from 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?

There is no guidance on when to call this tool, such as after execute_export_plan or while an export is in progress, nor any contrast with sibling tools like retry_failed_items or verify_yandex_upload. The usage context must be inferred entirely from the name and title.

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 and idempotentHint, and the description aligns with these by stating 'read-only snapshot' and 'creates or reuses'. It adds context like 'versioned normalized' and 'compact summary', which are useful. However, it does not disclose behaviors beyond what annotations cover, such as what 'refresh' does or how the snapshot is managed. Given the annotations cover safety and idempotency, a score of 3 is appropriate.

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 sentence that front-loads the primary action ('creates or reuses') and result ('returns a compact summary'). It has zero waste and packs essential information efficiently. This is an example of concise, structured writing.

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 has five parameters (including a nested scope object) and no required parameters, the description is inadequate. It does not explain when to use the tool, how the parameters relate to the snapshot creation, or what the 'compact summary' contains. While an output schema exists, the description does not reference it or clarify the input structure. The overall context is incomplete for an agent to use this 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?

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention any parameter names, types, or purposes. The only hint is that a snapshot is involved, implying parameters like file_key or figma_url locate the file, but this is not explicit. With five parameters including a nested object, the description is far from sufficient.

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 function: it creates or reuses a versioned normalized read-only snapshot and returns a compact summary. This is specific about the verb and resource. However, it does not explicitly distinguish it from sibling tools like analyze_figma_layout or query_nodes, which could also inspect Figma files. Thus it falls short of the top 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 does not mention any conditions for choosing it over siblings like query_nodes or analyze_figma_layout, nor does it exclude any scenarios. The agent is left to infer usage from the name and title alone, which is insufficient.

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 indicate readOnlyHint=true and idempotentHint=true, but the description adds useful behavioral context: it returns stable results, includes warnings, and does not perform a bulk render. It also mentions a 'page of the manifest', implying pagination behavior. This goes beyond the 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 a single sentence that front-loads the key output types and the critical 'without bulk render' qualifier. No wasted words; every phrase adds 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 an output schema exists, the description need not detail return fields. It covers the essential purpose, key outputs, and performance implication. It does not mention error cases or prerequisites, but for a preview tool with a clear plan_id input, this is acceptable.

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 0%, so the description must compensate by explaining the parameters. It does not explicitly mention plan_id, cursor, or page_size, though it hints at pagination via 'page of the manifest' and plan identification via 'plan'. Standard pagination terms are self-explanatory to some agents, but given zero schema documentation, the description is insufficient for fully understanding parameter roles.

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 'Returns' and the resource 'export plan preview' with specific outputs: stable count/order/naming/destination/warnings plus a page of the manifest. It explicitly contrasts with 'without bulk render', distinguishing it from execution tools like execute_export_plan. This is specific and differentiates from siblings.

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 this is a lightweight preview operation ('without bulk render') and is likely used before confirming or executing a plan. However, it does not explicitly name alternative tools (e.g., get_export_status or confirm_export_plan) or state when NOT to use it. The context is clear but not fully explicit.

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 carry the safety profile (readOnlyHint=true, idempotentHint=true), so the bar is lower. The description adds 'without rendering' (a performance/behavior characteristic) and 'paginated evidence set' (output shape), which is genuine added value. It does not contradict the annotations. But it stops there — no mention of cursor mechanics or what an evidence set contains.

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 sentence with zero waste and the core action front-loaded — structurally clean. But for a tool of this complexity it reads as under-specification rather than conciseness; one sentence cannot carry the semantics of a recursive selector schema and a required snapshot context.

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?

Complexity is high and schema coverage is 0%, yet the description leaves critical gaps: it never defines a snapshot or how to obtain one despite snapshot_id being the only required parameter, never clarifies order modes, and never distinguishes query_nodes from inspect_figma_file/analyze_figma_layout. The output schema and annotations help, but the required-parameter and selection-semantics gaps are too large.

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 0% on a deeply complex schema — a recursive all/any/not selector, roughly twenty filter fields, and an order object with six modes. The description adds only 'declarative logical selectors,' leaving the required snapshot_id, the order modes, cursor/page_size pagination, and cryptic filters (hierarchyPath, dimensionsSimilarToPeers, blockIndex, siblingIndex) entirely unexplained. With 0% coverage the description was required to compensate and barely does.

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 verb-resource pair — 'Applies declarative logical selectors... returns a paginated evidence set' over 'normalized Figma nodes' (from the title). This makes the read/query nature clear. However, it does not differentiate from siblings that also touch the Figma structure, notably inspect_figma_file and analyze_figma_layout, so the agent must infer where query_nodes sits among them.

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?

No when/when-not guidance is provided. The description never explains that snapshot_id is required or where a snapshot comes from, nor does it route the agent to an alternative (e.g., use analyze_figma_layout for layout analysis, inspect_figma_file for file structure). The 'without rendering' clause is the only implicit usage context and is too weak to count as 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?

Annotations already indicate readOnly=false, idempotentHint=true, and destructive=false. The description adds valuable behavioral context beyond annotations: it explicitly states that verified items are never reuploaded, and that only failed/retryable items are touched. This safety constraint is not derivable from annotations alone, so it adds transparency.

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 sentence that is front-loaded with the core behavior and adds a safety constraint without any fluff. Every word earns its place; no unnecessary details or repetition.

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 retry operation with two required parameters and no schema descriptions, the description fails to provide essential context. It does not explain what job_id refers to, how idempotency_key should be generated or used, whether there are prerequisites (e.g., checking export status first), or what the output schema contains. An agent cannot confidently call this tool based on the description alone.

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 0%, so the description must compensate for explaining job_id and idempotency_key. It does not mention either parameter, leaving their meaning, format, or relationship to the retry operation entirely undefined. The names are self-explanatory to a human but not to an agent needing precise semantics (e.g., how to obtain job_id, idempotency_key generation rules).

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: retry only failed/retryable items, and explicitly excludes verified items. This is a specific verb-resource pair that distinguishes it from sibling tools like execute_export_plan or get_export_status. The phrase 'never reuploads verified items' adds a precise scope.

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 it should be used when there are failed items to retry, but it does not explicitly say when to call it (e.g., after checking status) or when not to use it (e.g., if all items succeeded). No alternatives are named, leaving the agent to infer the appropriate workflow from sibling tool names.

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 provide readOnlyHint and idempotentHint. The description adds useful behavioral context by listing what is verified (path, size, comparable checksum) and explicitly saying no upload occurs. This aligns with the annotations and does not contradict 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 one concise, front-loaded sentence. It starts with the action verb and immediately communicates the object and the non-uploading behavior, with no filler or redundant material.

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 an output schema and read-only annotations, the description is largely complete. The main missing piece is clarification of where job_id comes from and that this should be run after an upload or execution step, but the output schema covers return value expectations.

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 0%, and the description does not explain what job_id represents or how it relates to the verification. The parameter name is somewhat self-explanatory, but the tool definition leaves the semantics entirely to the developer.

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 explicitly states a specific verb and resource: 'Rechecks every expected path, size and comparable checksum.' It distinguishes the tool from sibling upload/export/status tools by emphasizing that it is a verification action and does not upload.

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 when to use this tool: after files are expected to be uploaded, to recheck path, size, and checksum. However, it does not explicitly outline when not to use it or name sibling alternatives such as get_export_status or retry_failed_items.

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