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

Annotations declare readOnlyHint=false and destructiveHint=false, so the safety profile is partly covered. The description adds useful context that add_missing appends rows, but it does not explain what prefill does, whether the append is reversible, or what the check returns.

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?

Only two short sentences, so it is not verbose, but the question phrasing and undefined 'area' and 'describe' terms make it cryptic rather than efficient. Every sentence earns its place, yet clarity is sacrificed for brevity.

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 and no annotation coverage of return values, the description should clarify what the check produces, what catalog_file should point to, and what happens when files are missing. It leaves all of these open for a tool that can both report and mutate.

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% across three parameters, so the description must compensate. It only explains add_missing; the required catalog_file parameter and the prefill parameter (default true) are left entirely undocumented, which is insufficient for a tool with a required file input.

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 question form ('Is every file of an area in its catalog?') conveys a verification purpose against a catalog, and 'add_missing appends rows' hints at an optional mutation. However, 'area' is never defined, the required catalog_file parameter is not mentioned, and the distinction from sibling catalog_describe is left implicit.

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 versus catalog_describe, verify, inventory, or storage_check. The only usage-adjacent statement is that add_missing appends rows, which hints at a mutating mode but does not say when that mode is appropriate or what prerequisites exist.

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 this is a non-destructive write (readOnlyHint=false, destructiveHint=false). The description adds that it targets a single catalog row and lists the fields, but it doesn't clarify overwrite behavior, prerequisites, or whether the document must be read first. The annotations carry most of the safety profile.

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 with no filler. It is efficient, though the terse '⚠ to describe' jargon slightly reduces immediate comprehension for an agent unfamiliar with the marker.

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 five-parameter write tool with no output schema and zero schema descriptions, the definition is thin. It omits how catalog_file and file are specified, what happens if the row already has a description, and how this tool fits with catalog_check or the plan_* siblings.

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. It gives meaning to three of five parameters (content, search_terms, date) but leaves catalog_file and file completely unexplained, even though those identifiers are essential for targeting the correct row.

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 has a specific verb ('Fill') and resource ('catalog row') and names the fields involved. It doesn't explicitly differentiate from siblings like catalog_check or suggest_names, and the '⚠ to describe' marker is jargon that assumes prior context, but the core action is clear.

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 'Fill one ⚠ to describe catalog row' implies the tool is used for rows flagged as needing a description, but it never explains where that flag comes from or when not to use it. No alternatives are named, leaving the agent to infer the workflow from 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?

Annotations already declare this is a non-destructive read operation, so the description need not restate safety. It adds useful comparison semantics: byte-identical matching, new items versus a target area, and duplicates among the new items themselves. It does not describe traversal behavior, performance characteristics, or result shape.

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 single sentence is front-loaded and has no filler. However, it reads as an overly terse fragment, and its brevity leaves important parameter meaning under-specified rather than efficiently conveyed.

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 two required parameters, 0% schema description coverage, and no output schema, the description should do more to explain inputs and expected behavior. It gives a conceptual comparison model but leaves the agent without enough detail to call the tool confidently.

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 0%, so the description must carry the burden of explaining paths and area. It hints that 'new items' maps to paths and 'target area' maps to area, but it does not clarify acceptable path formats, whether paths are files or directories, or what area denotes operationally.

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 identifies the resource and criterion clearly: byte-identical files, compared between new items and a target area and among themselves. It implicitly distinguishes exact-duplicate finding from the sibling find_similar, though it does not name that sibling.

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 does not say when to use this tool versus find_similar or search, nor does it give prerequisites or exclusions. The byte-identical criterion implies exact matching, but the agent must infer when this is the right choice.

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 destructiveHint=false, so the safety profile is covered, but the description adds almost nothing beyond that: it does not say whether matching is fuzzy/similarity-based, what corpus is scanned, whether results are returned as groups or pairs, or anything about cost or limits. For a read tool with annotations this could have earned a 3 with one extra clause, but it supplies none.

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?

It is a single short fragment with no filler, so nothing is wasteful, but the terseness crosses into under-specification: the core claim is packed into a parenthetical rather than a front-loaded sentence stating what the tool does and on what inputs.

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 three parameters at 0% schema coverage, no output schema, and a closely related sibling (find_duplicates), the description leaves key questions unanswered: threshold semantics, area scoping, required paths, and how results are shaped. It is far short of what an agent needs to invoke this 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 and it does not. 'By text' slightly implies the comparison basis, but 'paths' (the only required parameter), 'area', and 'threshold' (default 0.8, clearly a similarity cutoff) are entirely unexplained — an agent cannot infer what a threshold of 0.8 means or what area scopes.

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 phrase 'Near-duplicates by text' does identify the resource being matched (near-duplicate documents) and the basis of matching (text content), with a parenthetical example. However, it is a noun fragment rather than a verb+resource statement, and it never contrasts itself with the sibling find_duplicates, so an agent cannot tell from the description alone which of the two duplicate-finding tools to pick.

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 guidance and no exclusions. The parenthetical '(new scan or re-download of the same document)' hints at a motivating scenario but does not say when to prefer this over find_duplicates or search, both of which appear in the sibling list.

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 destructiveHint=false, so safety is covered and the bar is lower. The description adds only that the rules belong to "the person" (per-user scoping) and that reading precedes other work; it says nothing about payload size, freshness, or whether the rules can be empty.

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 fragments, zero waste, with the identifying information first and the actionable ordering hint second. It is arguably over-compressed rather than padded, but every word present 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?

There is no output schema, so the description carries the full burden of explaining what comes back — and it does not, beyond the vague noun "rules." For a prerequisite tool that the agent is told to call before everything else, the absence of any return-value or format guidance is a real gap.

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 takes zero parameters with 100% schema coverage, so there is nothing for the description to disambiguate. Baseline 4 applies; the description could only improve by confirming that no input is needed, which is a minor omission.

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 person's filing rules" identifies the resource but supplies no verb — an agent must infer that this retrieves/reads them. It is distinguishable from siblings like structure_advice or naming_examples by topic, but only weakly, since nothing states what a "rule" is or how the payload differs from those siblings' outputs.

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?

"Read first" is a genuine ordering directive that tells the agent to consult this before acting, which is more than most siblings get. However, it names no alternatives and gives no condition for when rules are irrelevant or when to re-read them.

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 destructiveHint=false, so safety is covered. The description adds stateful behavior — comparison against the 'last run' baseline and manual moves — but leaves undefined what a 'run' is or how that baseline is determined, which is important for a tool whose main differentiator is this delta.

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?

It is very short with no filler, but the brevity comes at the cost of clarity — the semicolon clause about 'areas' is left unexplained, so terseness here reads as under-specification rather than precision.

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, no parameter documentation, and a stateful 'since last run' behavior, the description should explain the return shape and baseline concept. Neither is present, leaving key details for an agent to guess.

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 0% for the single required 'path' parameter, and the description only weakly implies it is a folder. It never clarifies whether path may point to a file vs. a folder, or what an 'area' is in path terms.

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 says it returns files in a folder and, for 'areas', also changes/moves since the last run, which conveys the resource. But it lacks a clear verb, and the parenthetical phrase 'for areas' is undefined, so an agent cannot cleanly distinguish it from sibling list_folder.

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 indication of when to choose inventory over list_folder, survey, or search, and no prerequisites or exclusions are mentioned. The agent must infer the choice from name alone.

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 destructiveHint=false, so safety is covered. The description does add real behavioral value by disclosing the 100-entry cap and that a 'total' count is returned, which an agent would otherwise not know. It still omits whether entries include both files and subfolders and how to reach entries beyond the first 100.

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 compact sentence with no filler, and the most decision-relevant fact (the 100-entry limit) is present. It is terse to the point of being telegraphic, but nothing is wasted.

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 read-only listing tool with one parameter and no output schema, the description gives the essentials of scope and result size. However, the path format and the entry contents (files vs. folders, ordering) are gaps an agent would need in order to call and interpret it confidently.

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 carry the burden for the single 'path' parameter — but it never mentions path at all. Whether the path is absolute, root-relative, or accepts URI/traversal forms is left entirely unspecified.

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?

Names the resource (folder entries) and implies a listing operation, but the verb is elided into a noun phrase ('Entries of a folder'), so it reads as a fragment rather than a stated action. It is distinguishable from siblings like search or read_document, but only implicitly.

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 use this versus search, inventory, or read_document, and no stated prerequisites (e.g., whether the folder must exist or be accessible). The agent must infer usage entirely from the name and one-param schema.

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 destructiveHint=false, so the safety profile is covered. The description adds that the tool surfaces historical naming behavior for style matching, which is useful context beyond the annotations, but it does not disclose return format, how many examples are provided, or whether the examples are scoped to the required 'area' parameter.

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 extremely short and front-loaded, with no wasted words. However, its fragmentary style ('How the person named files before – match this style') sacrifices clarity for brevity, and the core behavioral detail is underspecified rather than concisely communicated.

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 one required, undocumented parameter and no output schema, the description leaves critical gaps: it does not explain what 'area' means, what the tool returns, or how its output should be used alongside siblings like suggest_name or get_rules. It provides only a high-level hint about historical naming style, which is insufficient for reliable 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 sole required parameter, 'area', has no schema description (0% coverage), and the tool description does not mention or explain it at all. With low schema coverage, the description must compensate by clarifying what 'area' means and how it affects the examples returned, but it provides no parameter semantics whatsoever.

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 restates the tool name with a vague phrase, 'How the person named files before,' and does not specify what the tool actually returns (e.g., a list of prior filenames) or what action it performs. It gives a hint about style matching but lacks a clear verb and resource scope, leaving it indistinguishable in purpose from siblings like suggest_name or get_rules without inference.

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 'match this style' implies a use case for naming files consistently with prior behavior, but there is no explicit when-to-use guidance, no mention of prerequisites, and no comparison to alternatives such as suggest_name or get_rules. The agent must infer both the trigger and the relationship to 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?

Annotations already establish this is a non-read-only, non-destructive mutation, so the safety profile is set. The description does add one genuinely useful behavioral detail not in the schema: the target may be the literal TRASH. It says nothing about validation, whether the row is persisted immediately, or what happens on a nonexistent plan.

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 with no filler, and the parameter list is easy to scan. It is arguably too terse for a 4-parameter tool with zero schema documentation, but nothing it includes is wasted.

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 output schema, no parameter descriptions, and a clustered sibling set of plan_* tools, the description omits the plan_name parameter, the return value, and any lifecycle context (e.g., that rows are later reviewed and applied). An agent could call it, but only by guessing at plan_name and path semantics.

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 the full burden. It gives meaning to source, target and reason (including the TRASH sentinel), but never mentions the plan_name parameter at all despite its "current" default, and gives no path format, relative-vs-absolute, or reason conventions.

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?

Uses a specific verb ("Add") with the resource ("one plan row") and lists the three values a row carries, so the operation is unambiguous. It does not distinguish itself from siblings like plan_show or plan_check, but the add-a-row scope is still clear.

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 on when to add a row versus using another plan tool, no prerequisite that a plan must exist first, and no mention of the plan_show/plan_check/plan_apply workflow that surrounds it. The only implied usage is "one row at a time", which the agent has to infer.

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 annotations already declare readOnlyHint=false and destructiveHint=true, so the safety profile is partly covered. The description adds meaningful behavioral context: execution is logged and undoable, and folder creation is gated on explicit approval. It still does not spell out the exact scope of what may be changed.

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 short sentences, front-loads the core action, and has no filler. Both sentences add useful information: undoability/logging and the approval condition for folder creation.

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 destructive mutation tool with no output schema, the description is adequate but incomplete. Annotations cover the destructive/read-only profile and the description adds logged/undoable context, but it does not explain plan_name, what rows are executed, or what the caller should expect after execution.

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 both parameters. It provides a conditional rule for create_folders, which is useful, but says nothing about plan_name, leaving one of two parameters completely unexplained beyond its name and default.

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: 'Execute approved rows.' Combined with the name plan_apply and the mention of create_folders, an agent can infer this applies an approved plan. It does not explicitly differentiate itself from sibling tools such as plan_approve or plan_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 phrase 'approved rows' implies this should be used only after approval, and 'create_folders only if the person approved them' gives a conditional usage rule for one behavior. However, it does not explicitly say when to use this tool versus plan_approve, plan_review, or plan_check.

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=false and destructiveHint=true. The description contributes a genuine behavioral constraint the annotations cannot convey: approval must follow explicit human consent, and the link is only left when chosen. It does not say what state change approval causes, whether it is reversible, or what happens to rows left out — gaps that matter for a destructive 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?

Two short sentences, front-loaded with the permission gate ahead of the optional flag. The lowercase "leave_link" starting a sentence is sloppy, but nothing is padded and no sentence is wasted.

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?

A destructive, zero-required-parameter tool with no output schema and 0% parameter documentation needs more: which rows are affected by default, what approval changes, and how it differs from plan_apply. As written, an agent cannot safely call this beyond the consent rule.

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 carry the load, but it explains only that leave_link is conditional. It never says what rows selects (all rows when null?), what plan_name "current" means, or what an integer row refers to. Two of three parameters are opaque in both schema and 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?

"Approve plan rows" gives a verb and resource, but what approval actually does (mark ready, commit pending changes, unlock apply) is never stated, and the boundary with close sibling plan_apply is left ambiguous. An agent can guess the general area but cannot state precisely what this call does.

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 hard precondition "ONLY after the person said yes in chat" is an explicit when-to-use rule, and "leave_link only if they chose it" is a conditional-use rule. What's missing is any mention of alternatives such as plan_review or plan_apply, so the routing decision among the plan_* siblings is still 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by naming what the simulation checks (missing folders, closed collections, clashes, program data) and reinforcing that it changes nothing. It does not cover return format, cost, or auth needs, but with annotations present the bar is lower.

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 front-loaded sentence with no wasted words. The core purpose and the non-mutating behavior are stated immediately, and the parenthetical check list is compact.

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 explains the tool's purpose and check categories, but with 0% schema description coverage and no output schema it leaves important invocation details unexplained. In particular, create_folders is completely undocumented, and there is no guidance on how plan_name affects the simulation.

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?

There are two parameters, plan_name and create_folders, and schema description coverage is 0%. The description does not mention either parameter or explain what plan_name selects or what create_folders changes in the simulation. It therefore does not compensate for the schema's lack of parameter 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 states a specific verb and resource: simulate the plan. It also enumerates the check categories (missing folders, closed collections, clashes, program data), which makes the tool's purpose clear. It does not explicitly name sibling alternatives such as plan_apply or plan_show, so it falls short of full sibling differentiation.

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 'Simulate the plan' and 'Changes nothing' imply a dry-run use case, likely before applying a plan. However, the description does not explicitly state when to use this tool versus plan_apply, plan_show, plan_review, program_check, or other sibling tools. Usage is implied rather than clearly guided.

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 annotations already disclose that this is a non-destructive but non-read-only operation, and the description adds useful planning behavior by specifying the destination path shape and that the year comes from the capture date. However, it does not explain what the tool writes, how it treats an existing plan, or what side effects occur, so behavioral disclosure remains limited.

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 compact sentence with the core planning behavior and path pattern front-loaded. Every element contributes to understanding the tool's output convention, 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?

With no output schema and three parameters at 0% schema coverage, the description is too incomplete for an agent to invoke the tool confidently. It gives the destination path pattern but omits the role of inbox, the meaning of plan_name, where planned rows are stored, and how this step relates to plan_review or plan_apply.

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 carry parameter meaning, but it only explains photos_root indirectly through the path pattern and mentions the year rule. It says nothing about the required inbox parameter or the optional plan_name parameter, leaving two of three parameters semantically unclear.

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 gives a specific verb-resource pair ("Plan rows for photos/videos") and clarifies the resulting path pattern, so the agent knows this tool constructs planned destination rows. It does not explicitly distinguish itself from nearby plan lifecycle siblings such as plan_add, plan_review, or plan_apply, which keeps it below a 5.

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 use this tool versus alternatives like plan_add, plan_review, plan_check, or plan_apply. It also omits prerequisites, such as whether an existing plan must exist or when plan_name should be non-default.

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=false and destructiveHint=false, so the safety profile is partly covered. The description usefully adds that this launches an interactive browser UI for a human to tick and approve rows, which annotations cannot convey. But it omits key behavior: whether the call blocks awaiting human action, what it returns, and whether approval mutates plan state.

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 with no filler; the action comes first. It is efficient, though its brevity borders on under-specification rather than true conciseness.

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 that opens an interactive UI and implies human approval of row changes, there is no output schema and no description of what happens after invocation — blocking behavior, return value, or state effects. An agent cannot tell what to expect when this tool returns.

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 single plan_name parameter (default "current") is never mentioned in the description. The text says only "the plan," giving no hint of what plan_name accepts or what "current" means, so the description fails to compensate for the coverage 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 gives a verb ("Open") and a target ("the plan in the person's browser") plus an intent ("tick and approve rows"), so the basic action is graspable. However, "plan" and "rows" are undefined domain terms and it never distinguishes itself from close siblings such as plan_show, plan_approve, or plan_apply, which an agent could easily confuse with this.

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 or when-not-to-use guidance, nor any named alternative. The human-in-the-loop framing only implies a review-before-approval context, leaving the agent to infer it.

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 destructiveHint=false, so safety is covered. The description adds only that the result is 'rows' of a plan, which hints at a read output but says nothing about format, pagination, or what happens when the plan doesn't exist.

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?

It is short, but that brevity is under-specification rather than conciseness: a single fragment that is not front-loaded with a verb or scope. Nothing would be lost by replacing it with a sentence that actually informs.

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 tool with one optional parameter and no output schema, the description should still explain what is returned and how plan_name selects it. That information is absent, leaving the definition incomplete in every dimension except the annotation-declared safety profile.

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 0%, so the sole parameter plan_name (default 'current') is undocumented anywhere. The description does not clarify what a plan name is, what 'current' means, or whether omitting it is safe.

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 'Rows of a filing plan' restates the tool name rather than stating an action; it never says the tool shows/lists anything, and 'rows' is unexplained. It gives an agent almost nothing to distinguish it from siblings like plan_check, plan_review, or plan_apply.

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 use this versus the many plan_* siblings, no prerequisites, and no exclusions. The agent must guess entirely from the name.

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 destructiveHint=false, so safety is covered. The description adds the useful scope detail that 'depend' includes folders, libraries, links, and open files, but says nothing about scan depth, cost, or whether results are per-path or aggregate — and with no output schema, return shape is left implicit by the question phrasing.

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?

One front-loaded sentence with no filler, and the parenthetical efficiently packs in the dependency categories. It is arguably too terse, but nothing is wasted.

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 read-only, one-parameter check the description is minimally viable: purpose and parameter scope are inferable. Gaps remain around return semantics (no output schema), and against an unusually dense set of similarly named check tools it does not establish its niche.

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 single 'paths' parameter has 0% schema description coverage, so the description must compensate; it partially does by clarifying that entries can be folders, libraries, links, or open files. It still doesn't say whether multiple paths are evaluated independently or as one set, nor what a path string should look like.

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 question form clearly conveys a dependency check on given paths and even enumerates the dependency kinds (program folders, libraries, links, open files), so the resource is identifiable. However, it never distinguishes itself from the many similar '*_check' siblings (plan_check, storage_check, catalog_check), leaving the agent to infer the 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?

There is no statement of when to call this versus plan_check/storage_check/catalog_check, no prerequisite mention (e.g., before deleting or moving files), and no exclusions. The agent must guess the scenario from the tool name alone.

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 destructiveHint=false, so the safety profile is covered; the description adds real value by disclosing the default page scope, local OCR for scans, and the next_offset continuation mechanism. It omits what happens on a missing/unreadable path and gives no sense of output size beyond the max_chars default.

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 clauses, front-loaded with the result and default scope, with zero filler. The telegraphic style costs some readability and makes the pagination note easy to misparse, but nothing is wasted.

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 read tool with annotations covering safety and no output schema, the description covers the default scope and continuation. It is not complete enough about truncation behavior and max_chars, which an agent needs to decide whether one call suffices.

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 carry parameter meaning and it only partially does: 'next_offset continues' effectively explains the offset parameter's role. max_chars is never mentioned at all, and path conveys nothing beyond its name, leaving a real gap on a 3-parameter tool.

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?

It states a specific resource and result — 'Text of a document' — and adds a scope qualifier ('first page by default') plus OCR behavior for scans, so an agent knows what it gets back. It is written as a fragmented noun phrase rather than a verb+resource sentence, and it never distinguishes itself from siblings like search or list_folder.

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?

'first page by default' and 'next_offset continues' imply the pagination workflow, which is genuine usage guidance for continued reading. However, there is no explicit when-to-use-vs-alternatives guidance against siblings such as search or catalog_describe, leaving the agent to infer selection.

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 destructiveHint=false, so the safety profile is partly covered. However, the description mentions archive/delete decisions without clarifying that the tool itself only reports candidates and does not modify records, which leaves an avoidable ambiguity for a read-only 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 a single compact sentence with no wasted text, and it front-loads the retention condition before the per-record instruction. Its brevity is appropriate structurally, even though the content itself remains under-specified.

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 two-parameter tool with no output schema and no parameter descriptions, the description does not explain what is returned, how records are identified, or what 'area' scopes. The annotations cover safety, but the description leaves important operational context 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 both required parameters ('area' and 'years') rely entirely on the description for meaning. The description implies a retention period that loosely maps to 'years', but it says nothing about what 'area' means or how the two parameters scope the query.

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 identifies the retention condition ('Records older than a retention period') and a per-record decision ('archive or delete'), but it does not use a clear action verb for what the tool itself does. It hints at surfacing retention-due records but does not distinguish this from siblings like survey, inventory, or search.

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 'ask per record: archive or delete' gives implied guidance on what to do after invoking it, but there is no explicit when-to-use, when-not-to-use, or alternative tool guidance. The condition 'older than a retention period' implies the context, but alternatives are not addressed.

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 destructiveHint=false, so the safety profile is covered. The description adds only the vague scope phrase 'closed collection' and says nothing about matching semantics, result ordering, pagination, or what 'closed' implies access-wise.

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 short sentence with no wasted words, and the operation is front-loaded. The brevity is efficient, though it reflects under-specification rather than complete precision.

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 two-parameter search tool with no parameter descriptions and no output schema, the description should carry more weight. It does not explain the parameters, expected results, or how 'closed collection' scoping affects the search.

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 both parameters are required. The description does not explain what 'path' refers to (a collection root? a document?) or what query syntax is accepted, leaving a significant gap the schema cannot fill.

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 verb and operation ('full-text search'), so the core purpose is identifiable. However, 'in a closed collection' is undefined, and the description never distinguishes this from search-adjacent siblings such as find_similar, find_duplicates, or survey.

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 use this versus list_folder, read_document, find_similar, or the other search-like siblings. The agent must infer that 'search' is the full-text entry point from the name alone.

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 destructiveHint=false, so safety is covered. The description adds nothing beyond that: it doesn't say what the answer looks like, whether the folder must exist, or what an 'open' versus 'closed' collection implies behaviorally.

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?

It is short, but brevity here comes from under-specification rather than economy. The single question is not front-loaded with a purpose statement, so nothing earns its place as guidance.

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?

No output schema exists and the description never explains what the tool returns, what values it produces, or how to interpret 'open' vs 'closed'. For a one-parameter tool with 0% schema coverage, this leaves an agent unable to call it correctly with confidence.

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 there is a single required parameter, path, which the description never mentions. It doesn't say whether path is a folder path, whether it must exist, or what format it takes, so the description fails to compensate for the schema 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 is a question rather than a statement of what the tool does: 'Is a folder an open or a closed collection?'. It hints at the domain concept (open vs closed collection) but never says the tool returns a folder's status, and it does nothing to distinguish itself from siblings like list_folder, survey, get_rules or verify.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. An agent cannot tell from this sentence whether status should be called before or instead of list_folder, survey or get_rules.

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?

Read-only behavior is already covered by annotations, and the description usefully adds that results include a computed yearly cost which must be reported verbatim rather than fabricated — a real constraint beyond the structured fields. It still omits what happens with a missing/malformed table and gives no sense of the result shape.

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, front-loaded with the core function, with no filler. The closing directive is terse and earns its place, though the whole package is arguably too terse for the ambiguity it leaves.

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 one-parameter read-only tool with annotations covering safety and no output schema, the description covers the broad intent. It falls short on the one thing an agent most needs — what table_file actually accepts — and on how failures are surfaced.

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 0% and table_file has no description at all. The phrase 'from a storage table' weakly implies the parameter is a table file, but nothing clarifies whether it is a path, filename, sheet name, or whether it must pre-exist — so the description does not compensate for the coverage 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 the two outputs — a 3-2-1 backup check and a yearly cost — plus the input source (a storage table), so the gist is graspable. But there is no explicit verb, and it is not distinguished from sibling checks like verify, plan_check, catalog_check, or inventory, which an agent could easily confuse it with.

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 never says when to reach for this versus the other check/verify siblings, nor any preconditions (does the table need to exist already? what format?). 'Never invent prices' is an output-fidelity instruction, not usage guidance, so the agent is left to infer the trigger conditions.

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 state readOnlyHint=true and destructiveHint=false, so the safety profile is covered. Beyond that the description adds essentially nothing: it never says whether the result is a list, a narrative advisory, or a grouped report, nor whether 'to discuss' implies human-in-the-loop follow-up — a meaningful gap for an advice-oriented 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?

It is short but not concise — a sentence fragment with a parenthetical list and an unclear infinitive tail. Brevity here comes from under-specification rather than disciplined editing.

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 diagnostic tool with no output schema and an undocumented parameter, the description should explain the input's meaning and the shape of the result. It explains neither, so an agent must open the schema and guess at output format.

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% for the single required 'area' parameter, so the description must carry the load and does not. 'Of an area' implies scope but never says whether an area is a folder path, an ID, or a domain segment, leaving the only parameter underspecified.

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 fragment 'Structure problems of an area (too deep, empty, by type, duplicate names)' does convey the resource being inspected and enumerates the problem categories, but there is no clear verb — 'to discuss' is ambiguous about whether it detects, reports, or advises. An agent can roughly tell this is diagnostic rather than a mutation, but it cannot confidently separate it from siblings like find_duplicates or survey.

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-to-use, when-not-to-use, or named alternative is given. With overlapping siblings such as find_duplicates, find_similar, survey, and inventory, the description provides no routing signal for choosing this tool over them.

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 destructiveHint=false, so safety is covered. Beyond that the description only telegraphs a confidence flag and a read-it fallback without explaining what confidence means, what is returned, or what 'read it' refers to.

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?

It is short, but brevity here is under-specification rather than conciseness: two fragments with no clear subject, no front-loaded purpose, and a cryptic 'confident=false: read it' clause.

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 and zero parameter documentation, the description must carry the full burden, yet it neither explains the input nor clarifies the output or the confidence behavior. An agent cannot reliably invoke this tool from the definition 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% for the single required parameter 'path', so the schema provides no meaning. The description never mentions the parameter at all, leaving its expected value (file path? folder?) 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 enumerates presumed output fields (date, issuer, kind, summary, keywords, name) but never states the verb or that it operates on a document at the given path. 'suggest_name' plus this fragment implies name suggestion, but it is closer to a field list than a stated purpose, and the plural sibling suggest_names is not distinguished.

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?

'confident=false: read it' gestures at a fallback (read the document when confidence is low) but is too compressed to be actionable. There is no guidance on when to use this versus suggest_names, read_document, survey, or inventory.

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 annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds that the tool processes all files in folders and returns one row per file with specific columns (date, issuer, kind, suggested name), which is useful return-format context, but it does not disclose performance characteristics, recursion behavior, 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 very short and contains no filler. It front-loads the output specification, though 'Start here' is a vague closing sentence that adds little. Overall it is appropriately sized for a one-parameter tool, even if the structure could lead with the action.

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 batch tool with no output schema and a completely undocumented parameter, the description is too thin. It lists output columns but omits essential context such as whether paths are folders or files, recursion behavior, file-type handling, and what happens on invalid paths.

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 never mentions the single 'paths' parameter. The phrase 'For all files in folders' weakly implies that paths refer to folders, but it does not explain format, whether files are accepted, or whether it recurses. The description does little to compensate for the missing schema 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 specifies that it operates 'For all files in folders' and returns 'date, issuer, kind and a suggested name, one row each,' which hints at a batch naming-suggestion tool. However, it never uses an action verb like 'suggests names' and does not explicitly differentiate itself from the sibling 'suggest_name' (singular), leaving the core purpose implied rather than stated.

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 only usage guidance is the vague phrase 'Start here,' which implies it should be run first but gives no context about when to use it, when not to use it, or how it relates to alternatives like 'suggest_name' or 'naming_examples.'

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 destructiveHint=false, so the safety profile is covered. The description adds useful context that this is a broad multi-dimension audit (including 'drive health' and stale-file detection), but it omits cost/scale expectations for what is likely an expensive recursive scan, and does not say whether results are aggregated or per-folder.

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 with no filler; the enumerated audit dimensions are compact. It is slightly telegraphic ('drive health', 'unclear names') but nothing is wasted.

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 two undocumented parameters, no output schema, and no explanation of how the audit results are structured or scoped, the description leaves real gaps. For a read-only survey that likely walks many folders, an agent needs at least scope, cost, and parameter semantics, none of which are present.

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 carry parameter meaning, and it largely does not: 'paths' is never explained (which folders? recursive? multiple roots?) and 'stale_years' is only obliquely hinted at by the phrase 'stale files' with no mention of the 3-year default or what the threshold controls.

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 verb-like action (stock-take) and the resource (folders) plus the dimensions reported: sizes, types, duplicates, unclear names, stale files, drive health. However, 'stock-take' is jargon and the description never distinguishes this aggregate audit from siblings that cover the same ground individually (inventory, find_duplicates, storage_check, suggest_names, retention_due), so an agent cannot tell when this umbrella tool is the right pick.

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, no when-not-to-use, and no named alternative. The agent must infer from the sibling list whether to run survey or compose inventory + find_duplicates + storage_check itself.

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 that this is a safe read-only, non-destructive operation. The description adds the meaningful behavioral context that this compares a collection against a fixity manifest, but it omits what happens on mismatch, what the result looks like, and whether the collection must truly be closed.

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 with no filler. It is efficiently sized, though its terseness leaves important concepts unexplained rather than wasting 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?

For a verification tool with no output schema and no parameter documentation, the description is thin. It does not explain what 'closed collection' or 'fixity manifest' mean in this system, what a successful or failed verification returns, or how the caller should interpret results.

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 never mentions the sole 'path' parameter. The agent can infer that path points at the collection being verified, but the description does not clarify whether it is a collection root, manifest location, or something else.

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 verb and resource: checking a closed collection against its fixity manifest. This is more precise than a tautology, but the jargon 'closed collection' and lack of differentiation from sibling check-oriented tools (catalog_check, program_check) keep it from a 5.

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-to-use guidance, prerequisites, or alternatives are given. The agent must infer that this is an integrity check performed after a collection is closed, and cannot tell when to prefer it over catalog_check or other check tools.

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