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

Annotations already declare destructiveHint=false and idempotentHint=true; the description earns credit by adding the non-obvious behavioral detail that the partial file and checkpoint survive the cancel. What it still omits is whether the cancelled job can be resumed and whether cancel is reversible, which matters for a non-destructive-but-terminal action.

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 sentence, front-loaded with the action and immediately followed by the constraint that distinguishes it. Nothing is padded or repeated from the schema.

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 action tool with full annotations and an output schema, the definition covers the essential behavioral question (what is preserved). The remaining gap is the relationship to pause/resume, which an agent needs in order to pick the right 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?

Schema description coverage is 0% and the single job_id parameter carries no description anywhere, so the description should compensate but does not explain what a job_id is or where to obtain it. The phrase 'this session's transfer' weakly implies the job is session-scoped, which is the only added semantic signal.

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 a specific verb ('Stop') and resource ('this session's transfer') and immediately scopes the side effect ('without deleting its partial file or checkpoint'). It does not, however, distinguish itself from the sibling pause_transfer, which is the closest source of confusion for an agent choosing between the two.

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?

Usage is only implied: an agent can infer this is the 'give up on the transfer' action because of the preserved-checkpoint clause, but the description never states when to cancel versus when to pause, nor whether a cancelled transfer can be restarted later. No explicit alternative is named despite pause_transfer and resume_transfer being siblings.

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

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

Annotations already declare the mutation profile (readOnly=false, destructive=false, non-idempotent), and the description adds real context beyond them: it refuses existing targets and verifies both the new copy and the retained source. This confirms the non-destructive intent and describes a post-condition check, though it omits permission/space-failure behavior.

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 compact sentences; the core action and destination-format rule come first, followed by the refusal and verification behavior. 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?

Output schema exists so return values need not be explained, and annotations cover the safety profile. The description covers the main failure mode and verification, missing only permission/overwrite edge cases for full completeness.

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

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

Schema coverage is 0%, so the description must carry the burden. It adds critical meaning for destination (must be a complete new path including the file name) but says nothing about the source parameter beyond its obvious name, leaving half the semantics unstated.

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 (copy) and resource (Netdisk file/folder) plus the key scope detail that the destination is a complete new path including the name. It implies differentiation from move/rename by emphasizing a new path with the name, but never names those siblings explicitly.

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?

'Refuses existing targets' gives a useful precondition about when the call will fail, but the description never says when to choose copy over move, rename, or upload. Usage is only implied by the verb.

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 non-read-only, non-destructive, non-idempotent, open-world; the description adds meaningful behavior on top: existing local names are skipped (so re-runs are partially safe), the operation is asynchronous and must be polled, and expected_sha256 covers only a single file. Missing is any mention of auth requirements, concurrency, or what the returned task handle looks like.

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?

Four short sentences, each carrying distinct information (action, skip behavior, checksum option, next step), with the action front-loaded. No filler, though the telegraphic phrasing borders on under-specified rather than merely terse.

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?

Output schema exists, so return values need no explanation, and the async/polling lifecycle is covered. But for a tool with 5 params, 0% schema coverage, and no annotations about where files land, leaving mode and destination-directory semantics unexplained is a real completeness 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?

Schema description coverage is 0%, so the description carries the full burden for five parameters, yet it only illuminates expected_sha256 (scoped to "one downloaded file"). The three-way mode enum, local_dir's default/target semantics, and rate_limit_bps are left entirely undocumented 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?

Opens with a specific verb+resource ("Start downloading one Netdisk file/folder"), which separates it cleanly from upload, list_files, and file_info. The scope word "one" and the async framing ("Start") are precise. Differentiation from siblings is implicit via the obvious download/upload split rather than explicit naming.

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?

"Poll task_status to completion" gives a concrete follow-up action and effectively names the sibling tool to use next, which is real workflow guidance. However, the tool's central usage decision — when to pick mode locate vs pcs vs stream — is not addressed, and there are no stated preconditions or exclusions.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered without the description. The description contributes the useful hint that existence is reported as a result rather than raised as an error, but says nothing about permissions, failures, or latency.

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 zero filler; every clause names a distinct capability of the tool.

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?

An output schema exists, so return fields need not be re-explained, and annotations cover the safety profile. For a one-parameter read tool the only real gap is path syntax and error semantics on a missing file.

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?

Only one parameter exists and schema description coverage is 0%, so the description must explain the path format. It only implies that the path points at a Netdisk file or folder; absolute vs relative form, root syntax, and whether trailing slashes matter are all unstated.

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?

A specific verb and resource ('Read exact Netdisk file/folder metadata') plus an enumeration of the returned fields: existence, size, file ID, modification time. It is clearly distinct from mutation siblings like move/rename, though it does not explicitly contrast with list_files, which also surfaces file information.

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?

Usage is only implied: fetch metadata for a known path. There is no statement of when to prefer this over list_files (bulk enumeration) or status, and no note on prerequisites such as authentication or mounted paths.

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 the read-only, idempotent, non-destructive profile, so the safety bar is covered. The description adds real context beyond that: the 'filenames are data' caveat and the exact-absolute-path/no-wildcards input constraint, which are not visible in structured fields.

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

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

Three terse sentences, front-loaded with the action and followed by the two constraints that matter. 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?

An output schema exists, so return values needn't be explained, and annotations cover safety. However, the description omits what happens on a non-existent path, whether entries are folders/files, and any auth prerequisite for Netdisk access, leaving gaps for a listing 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?

Schema coverage is 0% for the single path parameter, so the description must compensate, and it does: it specifies an exact absolute path and that wildcards are rejected. It leaves the default '/' and the meaning of the parameter as the target folder implicit.

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 ('List one Netdisk folder'), and 'one' signals non-recursive scope that distinguishes it from transfer-listing siblings. It doesn't explicitly name the alternatives (file_info, list_transfers), but an agent can tell what this enumerates.

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, or alternative guidance is given. It does not say to reach for file_info for detail or to use this before download/copy, so the agent must infer routing 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 that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds useful context that results include persisted transfers and paused tasks from a previous session, but it does not mention ordering, pagination behavior, or result scope beyond that.

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 text. It communicates the core scope efficiently.

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 is simple, has an output schema, and carries useful annotations, so the description does not need to explain return values deeply. However, it leaves parameter meaning and when-to-use guidance under-specified for an agent choosing among transfer-related 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 for the two parameters, but it does not explain limit or offset at all. The schema exposes only titles and defaults, leaving pagination semantics largely undocumented.

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: listing persisted transfers, with the additional scope of paused tasks from a previous MCP session. This is clear, though it does not explicitly distinguish the tool from nearby siblings such as task_status or status.

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

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

The description implies usage by explaining that persisted transfers and prior-session paused tasks are included, but it does not say when to use this tool instead of task_status, status, or resume_transfer. No exclusions or alternatives are named.

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 non-read-only, open-world, non-idempotent, and non-destructive behavior, and the description adds important context: interactive phone confirmation, no cookie return, and login reuse unless forced. It does not fully clarify what force=True does to an existing login beyond bypassing reuse.

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 short, front-loaded with the action and platform, and every sentence contributes useful information. There is no redundant or filler text.

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

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

With annotations covering safety traits and an output schema covering return values, the description supplies the key operational details: platform, required user interaction, cookie behavior, and force semantics. Minor gaps remain around exact force behavior and non-macOS alternatives.

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 only parameter, force, has no schema description, but the description compensates by explaining that existing working login is reused unless force=True. This adds meaningful semantics beyond the schema, though the exact side effect of forcing a new login is not detailed.

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

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

The description states a specific action and resource: opening a local QR-login terminal on macOS for Baidu Netdisk. It is clearly distinct from the sibling file and transfer tools, though it does not explicitly differentiate from other possible authentication approaches.

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

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

It gives clear usage context: macOS only, user must scan and confirm in the phone app, and other systems receive a manual login command. It also explains that an existing working login is reused unless force=True, though it does not explicitly state when not to use the tool or name alternative auth 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 declare idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description adds meaningful context beyond those annotations by stating that existing folders are reused, existing files are rejected, and the folder's existence is verified after creation.

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, tightly structured sentence with no filler. The creation behavior is front-loaded, followed by verification and existing-file/folder semantics.

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?

An output schema exists, so return-value details are not needed. The description covers creation, idempotency, existing-folder reuse, file rejection, and verification, though it omits behavior for missing parent directories or permission errors.

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 path parameter. The description compensates partially by requiring an absolute path, but it does not explain path syntax, allowed roots, or other formatting details.

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

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

The description states a specific verb and resource: create a Netdisk folder. It also specifies the absolute-path constraint and the verification behavior, making its purpose clear against siblings like list_files or file_info.

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 clearly indicates when it is used—creating a folder—and gives key conditional behavior: existing folders are reused and existing files are rejected. It does not explicitly name alternatives or when-not-to-use cases, but the context is sufficiently 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 already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavior beyond that: it refuses existing targets (no silent overwrite) and verifies both paths after the operation, which tells the agent what success means and how failures surface.

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

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

Three short sentences, front-loaded with the operation, then the highest-risk parameter clarification, then the behavioral guarantees. No repetition of the tool name and nothing extraneous.

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?

An output schema exists, so return values need not be explained, and the description still notes that paths are verified afterward. Combined with the destination semantics and overwrite refusal, an agent has what it needs to call this correctly; only path-format details are 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 carry the burden, and it does for the critical one: destination is the complete NEW path including the name, not just a parent directory. Source is left unstated but is self-evident; a brief note on path format (absolute vs relative, separators) would close the remaining 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?

States a specific verb+resource (move a Netdisk file/folder), making the operation unambiguous. It does not explicitly distinguish itself from near-siblings like rename or copy, but the verb plus the destination semantics do most of that work 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?

Usage is only implied: an agent infers this is the tool for relocating an item to a new path, but there is no statement of when to prefer it over rename or copy, nor any prerequisite/authentication guidance. Adequate but with clear gaps.

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-read-only, non-idempotent, non-destructive mutation, and the description adds genuinely useful context that the checkpoint survives the pause. It does not disclose behavior on redundant calls (already-paused transfer), whether the pause is immediate or graceful, or what state the transfer transitions 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?

A single front-loaded sentence — verb, resource, and the critical state guarantee — with zero 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?

For a one-parameter mutation with an output schema and full annotation coverage, the description covers purpose and the main side-effect concern (checkpoint retention). Only edge-case behavior and parameter provenance are left unaddressed, which is a minor 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?

Schema coverage is 0% for the single job_id parameter, so the description must carry the burden, and it says nothing about where the id comes from or what form it takes. The name is largely self-explanatory for a one-parameter tool, which limits the harm, but no added meaning is provided.

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 ('Pause a running transfer') and adds the key state consequence ('preserving its checkpoint'), which distinguishes it from cancel_transfer. It references resume_transfer by name, so an agent can place it in the pause/resume pair, though it never explicitly contrasts itself with cancel_transfer.

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 'for resume_transfer' implies the intended workflow — pause only when you plan to resume — but there is no explicit when-to-use/when-not-to-use statement or precondition (e.g. 'only valid on transfers in running state'). Usage must be inferred from the checkpoint hint.

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 destructiveHint=true, idempotentHint=false and openWorldHint=true. The description adds genuinely new behavioral facts: the operation is confined to the current parent, and name collisions are refused rather than overwritten — which materially reframes what "destructive" means here. It stops short of saying what permissions are needed or whether the rename is reversible.

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 action and scope, followed by the single most decision-relevant caveat. No filler or restatement of the title.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. However, for a mutation tool with 0% schema description coverage, the definition leaves the two parameters and the permission/error model under-specified.

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 neither parameter is named or explained. The description never says whether "path" is an absolute path, a relative path, or an ID, nor what characters are legal in "new_name"; "existing target names are refused" only indirectly hints at new_name collision behavior.

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 ("Rename a Netdisk file/folder") plus a scope qualifier ("within its current parent") that implicitly separates it from the move and copy siblings. An agent can tell what this does and what it does not do without opening the schema.

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 clause "within its current parent" implies the boundary against move, but no sibling is named and there is no explicit when-to-use guidance. The refusal rule for existing names is a constraint, not usage routing, so the agent must infer that move should be used for cross-parent relocation.

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 declare the safety profile (readOnly=false, destructive=false, idempotent=false), so the description only needs to add context — which it does: state preconditions, a backend dependency, and rejected mutation categories. It does not say what happens if the resume is issued against an ineligible task or how repeated resumes behave, but the core behavioral picture is solid.

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

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

Two tight sentences, front-loaded with the action and eligible states, followed by caveats. 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?

For a 2-parameter mutation with an output schema and informative annotations, the description covers states, prerequisites, and rejections. The one gap is the origin/format of job_id, which matters because the schema gives it no documentation.

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

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

Schema coverage is 0% and neither parameter has a description, so the description carries the burden. It explains rate_limit_bps in prose ('optionally changing its bandwidth limit') but says nothing about job_id — where it comes from or what form it takes.

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 (resume) and resource (a persisted transfer task), plus exactly which states are eligible (paused/failed/cancelled). An agent can distinguish it from pause_transfer and cancel_transfer without opening a schema.

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?

Gives a clear eligibility condition (task must be persisted and in paused/failed/cancelled state) and explicit exclusions (source changes and account changes are rejected), plus a backend prerequisite for upload block resume. It never names the alternative tools for the non-eligible cases, so it stops short of a 5.

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 readOnly, idempotent, openWorld and non-destructive. The description adds real context by clarifying that the network-touching part is the live quota check against Netdisk, which explains the openWorld hint. It does not say what happens when local auth is missing (error versus status payload) or whether the remote check can fail or be slow.

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 filler, front-loading the local check and qualifying the optional remote step. Nothing to trim.

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, wait — scoring independently: the output schema exists so return values need not be described, but the description still leaves open what an unauthenticated result looks like and what the remote check costs. With one undocumented parameter and an ambiguous name competing with task_status, this is adequate but not complete.

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

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

The single parameter has 0% schema description coverage, so the description must carry its meaning. It does explain the gist of verify_remote as 'verify the account against live Netdisk quota', but omits the default (true per schema) and any cost or failure implications of the live call.

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 concrete operation: checking local authentication and optionally verifying the account against live Netdisk quota. This is clearly distinct from mutation siblings and from task_status in subject matter, though it never names task_status to make the distinction explicit.

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?

Usage is only implied — an agent can infer this is a pre-flight check before file operations, and 'optionally' hints at the verify_remote trade-off. There is no explicit statement of when to call this versus login_qr or task_status, and no guidance on when to skip the remote 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?

The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile needs no further explanation. The description adds genuine context beyond the annotations that the job state is persisted and survives MCP restarts, but it does not cover behavior such as polling, error states, or whether completed results ever expire.

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 two short sentences and front-loads the core action and return values before the persistence note. Every sentence carries information, and there is no filler.

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

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

The output schema exists, so the return values do not need to be spelled out, and the persistence note is a helpful extra. Still, for a tool whose only input is an undocumented required job_id, the description leaves a practical gap: it does not say where that identifier comes from or how the tool relates to its status and transfer 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?

The schema has 0% description coverage: job_id is a bare string with no description. The description never mentions job_id, its format, or how to obtain one (for example, from a transfer start or a list_transfers call), so the meaning of the only parameter is undocumented in both the schema and 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 verb ('Get') and specific resources ('transfer progress, checkpoint state and result'), so the agent knows exactly what this returns. However, it does nothing to separate the tool from the sibling tool 'status' or from 'list_transfers': the agent cannot tell from the text which of these overlapping lookups 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?

It provides no explicit guidance on when to use this tool rather than 'status' or 'list_transfers', and no prerequisite or exclusion is stated. The phrase 'Jobs survive MCP restarts' hints that this is a persistent status lookup, but it never says under what circumstances the agent should call 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 the safety profile (readOnly=false, destructive=false, openWorld=true, idempotent=false), so the description's job is to add context — and it does: asynchronous task model, no-overwrite semantics on name collisions, and SHA-256 returned for file jobs. It doesn't explain partial-upload/resume behavior or what happens with rate limiting, but the core traits are disclosed.

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

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

Three short sentences, front-loaded with the action and scope, then collision behavior, then the required follow-up. 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?

Output schema exists, so return-shape explanation is unnecessary, and annotations cover safety. The async workflow is flagged, which is essential. The only missing piece an agent would want is what rate_limit_bps=0 means, otherwise this is callable and correct.

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 all three parameters. It clarifies 'local' as an absolute path, 'remote_dir' as a Netdisk folder subject to skip-on-collision, but says nothing about rate_limit_bps (default 0), leaving one required-meaning gap unfilled.

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?

Specific verb+resource: 'Start uploading one absolute local file/folder into a Netdisk folder.' It also states the async nature (poll task_status) and the skip-if-exists rule, which lets an agent distinguish it from download, copy, and list_files without reading schema.

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?

'Poll task_status' is an explicit follow-up instruction, and 'Existing remote names are skipped' tells the agent the tool will not overwrite. It lacks an explicit when-not/alternative case (e.g., use copy for remote-to-remote moves), so it stops short of a 5.

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