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

No annotations are provided, so the description carries the full disclosure burden and largely fails it: it never says whether an existing target_key is overwritten, whether object metadata/tags are preserved, what permissions or buckets are required, or whether large objects are streamed/copied server-side. Only the same-vs-cross-bucket capability is hinted at, which is really schema territory.

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 short front-loaded phrase with zero padding, which is structurally clean. However the brevity is under-specification rather than efficiency: for a 4-parameter mutation tool, this size leaves essential information out.

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 write operation with no annotations, no output schema, and 4 parameters at 0% schema coverage, the description is not complete enough to call the tool confidently. Return shape is excusable given no output schema, but overwrite behavior, permissions, and parameter defaults are all missing.

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

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

Schema description coverage is 0%, so the description must compensate and does not: it never explains that source_key/target_key are object keys, that source_bucket/target_bucket are optional and default to the current bucket, or what happens when only one bucket is supplied. The single phrase '同桶或跨桶' gestures at the optional bucket parameters but adds no usable semantics.

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

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

States a specific verb+resource ('对象复制' / copy object) and adds a scope qualifier (same-bucket or cross-bucket), so an agent can tell what it does at a glance. It does not differentiate itself from the sibling move_object, which is the main tool an agent could confuse it with, so it stops short of 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 when-to-use guidance and no mention of alternatives, even though move_object, upload_file, and download_file all overlap in intent. The agent must infer that copy is non-destructive and that move_object should be preferred when the source should be removed.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not mention bucket-name global uniqueness, required permissions, whether creation is reversible, or any limits on bucket count — significant omissions for a mutation tool.

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

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

A single short sentence, front-loaded with the verb and resource, with the optional region capability in parentheses. It is efficient, though the terseness borders on under-specification.

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 write operation with no annotations, no output schema, and 0% parameter documentation, the description is too thin. Critical details (name collision behavior, permission requirements, region default, return value) are absent.

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 loosely maps to both parameters, clarifying that 'region' means the deployment region, but adds no naming rules, format, or default behavior for either parameter.

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 ('create a new storage bucket') plus an optional capability (specifying the region). An agent can distinguish it from siblings like delete_bucket, list_buckets, or get_bucket_location, though no sibling is named 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?

The description offers no context on when to create a bucket versus when to use other tools, nor any prerequisites (credentials, permissions, namespace constraints). The only guidance is the parenthetical about region support.

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

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

With no annotations, the description carries full behavioral burden. It usefully discloses the destructive side effect that force purges contained objects before deletion, but says nothing about irreversibility, required permissions, or failure behavior on a non-empty bucket without force.

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 the destructive force behavior given inline. No waste, though the terse parenthetical could be expanded marginally for the missing details.

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

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

For a destructive two-parameter tool with no annotations and no output schema, the description covers purpose and the force side effect but omits permission requirements and error/edge-case behavior, leaving gaps an agent would want before invoking a delete.

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 add meaning. It explains the force parameter's semantics (clear objects then delete), but the required bucket parameter is left entirely to the schema despite bare string typing.

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 (delete bucket) that an agent can distinguish from object-level siblings like delete_object. It does not, however, explicitly name an alternative or note that it operates on the whole bucket rather than its contents.

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 parenthetical implies a use condition — force is needed to remove a non-empty bucket — which hints at when the option applies. There is no explicit when-to-use versus delete_objects_by_prefix or other cleanup alternatives, so guidance remains only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden. Deletion is destructive and irreversible, but the description says nothing about permanence, permission requirements, error behavior for missing objects, or whether the bucket is auto-derived. The single word 删除 implies a write, but no operational 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?

A single short phrase, efficient and front-loaded, but so terse that it under-specifies rather than being a model of concision. It doesn't waste words, but it also doesn't earn its place with useful content.

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 mutation tool with no annotations, no output schema, and zero parameter documentation. The description should carry the behavioral and parameter burden, but it only restates the name. An agent lacks enough information to call 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% and both parameters (key, bucket) are undocumented in the schema. The description mentions neither parameter by name or meaning, leaving the agent to infer that key identifies the object and bucket identifies the target bucket. With 2 params at 0% coverage, the description should compensate but does not.

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 (删除, delete) and resource (对象, object), with the scope qualifier 单个 (single). This distinguishes it from delete_objects_batch and delete_objects_by_prefix. However it doesn't name the bucket/key identity concept that differentiates it from other single-object tools.

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

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

No when-to-use guidance. Given three sibling delete tools (singleton, batch, by-prefix), the description gives no explicit guidance for choosing between them beyond the word 单个, which implies but does not state the alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden for a destructive operation. It discloses only the 1000-object batch cap and says nothing about permissions, reversibility, partial-failure behavior, or how missing/nonexistent keys are handled.

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, front-loaded with the operation and followed by the batch limit. Nothing is wasted, though the 1000 cap duplicates the schema's maxItems constraint.

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 batch tool with no annotations and no output schema, the description is thin: it omits error semantics, partial-success handling, bucket scoping, and any authorization context an agent would need before invoking it.

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 two parameters. The description confirms that 'keys' is a list of object keys and restates the 1000 maxItems already enforced by the schema, but the 'bucket' parameter is never mentioned and no format or syntax detail is added.

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+resource: batch-deleting a supplied list of object keys. This is distinguishable from the single-key delete_object and the delete_objects_by_prefix sibling, since it operates on an explicit key list, though no sibling is named.

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 guidance on when to prefer this over delete_object (one key), delete_objects_by_prefix (prefix sweep), or repeated single deletes. The use case is only weakly implied by '指定的多个对象键列表'.

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

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

With no annotations, the description carries the full behavioral burden, and it only vaguely claims 'triple disaster-prevention circuit breaker guards' without naming thresholds, what is protected, or whether the guards can still allow mass deletion. It never says the operation is irreversible, what permissions are needed, or whether partially-matching trees are affected.

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 sentence, but brevity here comes from under-specification rather than economy: for a destructive recursive delete, the one clause about 'circuit breaker guards' is too abstract to earn its place, and nothing actionable is front-loaded.

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

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

A destructive, recursive bulk-delete tool with no annotations, no output schema, and zero parameter documentation needs far more than one vague sentence. Missing are the confirm flag's meaning, irreversibility, scope of deletion, and failure/partial-success behavior.

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 3 parameters, and the description mentions none of them. It does not define prefix scoping semantics, whether bucket is optional/defaulted, or what setting confirm_recursive_delete=true actually authorizes, so it 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 conveys a recursive bulk cleanup of a virtual directory tree, which implies deletion by prefix, so the verb+resource is inferable. However, it never states the resource is S3 objects, and it does nothing to distinguish this from siblings like delete_object or delete_objects_batch, leaving the agent to guess which delete variant applies.

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 delete_object (single object) or delete_objects_batch (explicit key list), nor on when a recursive prefix delete is appropriate. The required confirm_recursive_delete flag's role is not explained either, so the agent has no routing rationale.

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

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

No annotations are provided, so the description carries the full burden. The sandbox note is genuinely useful context, but it omits whether the file is overwritten, whether directories are created, permission/auth requirements, and streaming/size limits — significant gaps for a tool that writes to disk.

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 appropriately terse, though the brevity is partly under-specification rather than pure economy.

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 annotations, no output schema, and 0% parameter coverage, the description should do far more work. It establishes the action and the sandbox constraint but leaves behavior, parameters, and result handling undocumented.

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 explains none of the three parameters. It does not clarify the relationship between 'key' and the optional 'bucket', or what 'local_path' is relative to (presumably the sandbox root), leaving the agent to guess.

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 clear verb+resource: streaming an S3 object into a local file, with the sandbox qualifier adding scope. It is distinguishable from siblings like upload_file and read_object_text, though it never names them 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?

There is no guidance on when to choose this over read_object_text, read_object_range, or get_presigned_url, nor any stated prerequisites. The agent must infer the use case 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?

No annotations are provided, so the description carries the full behavioral burden. It reveals only that a region is returned; it says nothing about required permissions, behavior for non-existent buckets, and only weakly implies the return shape. That is a thin disclosure for a tool with zero structured safety metadata.

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 filler and the key resource front-loaded. It is appropriately sized, though its brevity borders on under-specification rather than efficient 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?

With no annotations, no output schema, and undocumented parameters, the description should do more: it does not describe the return representation (e.g., a region code string), error conditions, or any usage constraints. For a tool whose structured metadata is entirely absent, this leaves notable gaps.

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

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

The single 'bucket' parameter has 0% schema description coverage, so the schema supplies no meaning at all. The description implies the parameter identifies the bucket to query but does not clarify the expected identifier format (name vs. ARN vs. path), leaving a real ambiguity unresolved.

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 ('查询存储桶...地域' – query a bucket's physical deployment region), which is clearly distinguishable from siblings like list_buckets, create_bucket or stat_object. It is clear but does not explicitly contrast itself with any 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?

There is no guidance on when to use this tool versus alternatives (e.g., stat_object or list_buckets, which might also expose location-related metadata), nor any stated prerequisites or preconditions. The agent must infer the usage context entirely.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a read operation and that a tag dictionary is returned, but says nothing about permissions, behavior when an object has no tags, or errors for a missing object/bucket.

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 phrase, front-loaded with the verb and resource, with no filler. It is under-specified rather than bloated, so it stays concise without 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 2-parameter tool with 0% schema coverage, no annotations, and no output schema, the description should explain the parameters and any read behavior. It omits both, so an agent lacks the minimum needed to invoke 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% and neither parameter is documented in the schema. The description mentions "对象" (object), which loosely hints that "key" is the object key, but it never clarifies the required "key" versus the optional "bucket" scope, leaving the agent to guess.

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 Chinese phrase "查询对象关联的 Key-Value 标签字典" gives a specific verb (查询/query) and resource (对象标签/object tags), so an agent understands it reads tag metadata for an object. It does not, however, differentiate itself from the sibling set_object_tags or state the inverse relationship 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?

The description offers no when-to-use guidance, no prerequisites, and no mention of set_object_tags as the write counterpart. The agent must infer usage purely from the tool 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?

With no annotations, the description carries the full burden. It discloses that links are time-limited and support GET/PUT, but omits key behavioral details: required permissions, whether the object must exist, default method/expiry behavior, and whether generating a URL has side effects.

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 wasted words. It efficiently communicates the core action, time limitation, and supported methods.

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 four undocumented parameters, no annotations, and no output schema, a one-line description is insufficient. It lacks usage guidance, parameter semantics, and behavioral details needed to call the tool correctly.

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

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

Schema description coverage is 0% across four parameters. The description conceptually covers method (GET/PUT) and expiry ('时效'), but says nothing about the required key, the optional bucket, expiry units/defaults/limits, or how those parameters interact.

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: generating a time-limited presigned HTTP(S) direct link, with supported methods GET/PUT. It is distinguishable from transfer siblings like download_file and upload_file, though it does not explicitly name or contrast them.

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

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

Usage is implied: use this when you need a time-limited direct link for GET download or PUT upload. However, it provides no explicit when-to-use guidance, no exclusions, and does not point to alternatives such as download_file or upload_file.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation and discloses the returned fields, but says nothing about permissions, whether results are paginated, or any limits on bucket count.

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

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

A single front-loaded sentence that carries the verb, resource, and return fields with no filler. It is appropriately sized for a zero-parameter listing 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?

For a simple no-argument read tool with no output schema, the description usefully states what is returned (names plus creation times). The remaining gap is only behavioral context such as permissions or pagination, which is minor here.

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

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

The tool takes zero parameters, so the baseline is 4. There is no parameter syntax to clarify and the schema is trivially complete.

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

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

States a specific verb (列出/list) and resource (存储桶/buckets), and even specifies the returned fields (names and creation time). The resource 'bucket' inherently distinguishes it from the many object-level siblings (list_objects, search_objects), though it never explicitly names an alternative.

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, no prerequisites, and no mention of how it relates to siblings such as get_bucket_location or list_objects. The agent must infer context 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?

No annotations are provided, so the description carries the full burden. It discloses that the delimiter defaults to '/' and that cursor pagination is supported, but omits critical behavioral details like read-only nature, permission requirements, return format, sorting, and the effect of max_keys.

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 delimiter default is front-loaded. It is appropriately sized for its content, though the content itself is sparse.

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 5 parameters, no annotations, no output schema, and 0% schema description coverage, the description is significantly incomplete. It does not explain key parameters like bucket and prefix, nor does it describe what the operation 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% for all 5 parameters. The description only clarifies the delimiter default ('/') and implies continuation_token via 'cursor pagination', leaving bucket, prefix, and max_keys 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?

The description says it simulates a hierarchical virtual directory tree and supports cursor pagination, which hints at listing objects, but it never explicitly states the verb 'list' or the resource 'objects'. It relies on the tool name to convey the core action and does not distinguish itself from siblings like search_objects.

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 such as search_objects or list_buckets. No prerequisites, conditions, or exclusions are mentioned.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose two important traits: the operation is atomic and the source object is removed after a successful copy, which is real destructive-behavior context. However it says nothing about target overwrite behavior, cross-bucket implications, or failure/rollback semantics.

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 tight sentence with the key semantic (atomic move plus automatic source deletion) front-loaded in parentheses. No waste, though it is arguably too terse for a 4-parameter mutation 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?

For a destructive, multi-parameter mutation tool with no annotations and no output schema, the description is under-specified: bucket parameters, overwrite behavior, and error semantics are absent. The core move semantics are covered, but not enough for an agent to call it confidently in edge cases.

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?

Four parameters with 0% schema description coverage, so the description must compensate and does not. It never explains source_key/target_key semantics for renaming or how source_bucket/target_bucket behave (defaults, cross-bucket moves), leaving half the parameters undocumented everywhere.

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 precise verb pair plus resource: atomically moves and renames an object, and clarifies the difference from a plain copy by noting the source is deleted after a successful copy. This implicitly distinguishes it from copy_object without naming it, so it falls just short of 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 explicit when-to-use guidance and no mention of alternatives such as copy_object plus delete_object, nor when not to use this tool. The only implicit signal is the embedded 'delete source after copy' semantics.

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

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

With no annotations, the description must carry the full behavioral burden. It does disclose that the operation writes or overwrites an object, but it omits critical details like required permissions, whether the bucket must exist, how existing content is handled, and what the operation 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?

The description is a single short phrase, which is concise but severely under-specified for a mutation tool with four parameters and no annotations. It lacks structure and sufficient content to earn its place as a useful description.

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

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

Given the complexity of a write tool with four parameters, no annotations, and no output schema, the description is far too sparse. It does not cover parameter meanings, permissions, return behavior, or usage context, leaving the definition materially incomplete.

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 is solely responsible for clarifying the four parameters. It adds no meaning beyond the tool name, failing to explain key, bucket, content, or content_type, and thus leaves required parameters 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?

The description states a specific verb and resource: writing text directly to or overwriting an object. This clearly distinguishes it from read operations, but it does not explicitly name or contrast with close siblings like upload_file or read_object_text, 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?

No guidance is provided on when to use this tool versus alternatives such as upload_file or other write tools. There is no mention of conditions, prerequisites, or exclusions, leaving the agent to infer usage 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?

No annotations are provided, so the description must carry the full behavioral burden. It discloses the HTTP Range mechanism (implying a read-only, partial read) and intended use cases, but omits permissions, rate limits, error behavior, and return format details.

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 no wasted words, front-loading the core action and following with a compact use-case clause. It is appropriately sized for a tool description, even if it omits details better handled elsewhere.

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 4 parameters, 0% schema description coverage, no annotations, and no output schema, the description should explain parameter semantics and basic behavior. It only provides purpose and two use cases, leaving critical invocation details absent.

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

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

Schema description coverage is 0%, and the description does not mention any parameter by name. 'Byte range' loosely implies start_byte and end_byte, but key and bucket are completely undocumented, 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 states a specific verb and resource: 'HTTP Range byte range read'. It also adds two use cases (large object tail troubleshooting and object header inspection) that hint at when this differs from a full-object read, but it never names sibling tools like read_object_text or download_file.

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

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

The parenthetical explicitly says the tool is suitable for large object tail troubleshooting and object header inspection, giving clear context for when to use it. It does not provide exclusions or name alternatives, so it falls 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?

With no annotations, the description carries the full behavioral burden. It does disclose meaningful traits – a 256KB truncation threshold and binary-file interception – but omits permission requirements, error behavior, and what happens when truncation triggers.

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 clause that front-loads the core purpose and appends the two scoping traits. Efficient, though terse enough to feel under-specified rather than fully economical.

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 4-parameter read tool with no annotations, no output schema, and zero schema description coverage, the description leaves too much unspecified – notably how to target the object, encoding behavior, and the byte-limit parameter.

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?

All 4 parameters (key, bucket, encoding, max_bytes) have 0% schema description coverage, and the description adds no meaning for any of them. max_bytes plausibly relates to the 256KB threshold but is never linked to it.

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 ('文本直读' – direct text read) and adds scope constraints (256KB truncation, binary interception). The purpose is clear, though it does not explicitly distinguish itself from the closest sibling read_object_range.

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: the mention of binary-file interception suggests this is for text files, but there is no explicit when-to-use guidance or naming of alternatives such as read_object_range or download_file.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the auth identity returned is masked (脱敏) and that RTT/Region are surfaced, implying a read-only probe, but it never states that the call is non-destructive, side-effect free, or requires no permissions.

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

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

A single dense sentence that front-loads the verb and lists the checked dimensions with no filler. It is appropriately sized for a trivial no-arg endpoint, though the terse list style leaves nothing explaining what the output looks like.

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 no-parameter, no-output-schema diagnostic tool, the description covers the meaningful surface: it tells the agent what the call probes and that identity is redacted. Only the safety/side-effect profile is left unstated.

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, so per the rubric the baseline is 4. There is no argument surface for the description to clarify further.

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

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

The description names a specific verb (自检/self-check) and enumerates exactly what is checked: endpoint connectivity, network RTT, effective Region, and masked auth identity. That is far more specific than the bare name s3_ping and clearly separates it from the object/bucket manipulation siblings, though it never explicitly says it is a diagnostic-only tool.

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

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

Usage is only implied — '自检' suggests a health/diagnostic check, but there is no statement of when to call it, what problem it solves, or how it relates to the other S3 tools. No alternatives or exclusions 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?

With no annotations, the description carries the full burden: it never declares the operation read-only, gives no pagination or result-limit behavior, and no indication of cost or scoping requirements. It also advertises two search modes but the schema exposes no mode selector, leaving the behavioral contract ambiguous.

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 or redundancy. It is clean and readable, though arguably terse relative to the tool's four parameters.

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

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

For a 4-parameter tool with no annotations, no output schema, and no parameter documentation, the description is far too thin. Nothing tells the agent how to scope the search, cap results, or interpret the response.

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 4 parameters, so the description must compensate and does not. It hints at keyword vs regex semantics for 'query' but does not say which applies or how it is selected, and never mentions bucket, prefix, or max_results at all.

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 (matching/search) and a scope ('prefix path tree'), and it specifies two modes (keyword matching and regex). However, 'prefix path tree' is not a standard term and it never clarifies whether object keys, paths, or contents are searched, nor does it distinguish itself from siblings like list_objects or read_object_text.

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 use this tool instead of list_objects, read_object_text, or the other search-adjacent siblings. The agent is left to infer that this is a filtered lookup rather than a plain listing.

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

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

With no annotations, the description carries the full burden. It does disclose the important behavioral trait that this is a full replace rather than a merge (全量覆盖), which meaningfully warns of destructive behavior on existing tags. However, nothing is said about permissions, failure modes, or what happens to unspecified tags beyond the overwrite claim.

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 the critical 'full overwrite' semantics front-loaded and no filler. It is not under-specified for its length, though that length is itself the limitation.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema description coverage on three parameters (one nested), a single clause is far too thin. An agent lacks the destructive-write context and parameter details needed to invoke it safely.

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

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

Schema description coverage is 0% and there are three parameters, including a nested key-value 'tags' object and an optional 'bucket'. The description only vaguely gestures at 'business tags' and adds no meaning for 'key', 'bucket', value typing, or the nested structure, so it 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 verb+resource are specific: 写入/全量覆盖 (write / full overwrite) applied to 对象业务标签 (object business tags). It is clearly distinguishable from the read-side sibling get_object_tags, though it never names that sibling 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?

There is no indication of when to use this versus get_object_tags, when the overwrite semantics are appropriate, or what prerequisites (bucket/key validity, permissions) apply. Usage must be entirely inferred from the name and 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only extraction and lists returned attributes, but omits required permissions, behavior for a missing key, bucket defaults, and error or rate-limit characteristics.

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; each clause names a returned metadata field. Appropriately sized for a simple stat operation.

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 annotations and no output schema, the description partially compensates by listing returned fields. However, input parameters are entirely unaddressed and there is no output structure or error behavior, leaving the definition incomplete for correct invocation.

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

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

Schema description coverage is 0%, with two parameters, key and bucket, completely undocumented in both schema and description. The description adds no input semantics, so an agent cannot tell that key is required or that bucket is optional.

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 the resource attributes returned: object size, Content-Type, last modified time, ETag, and metadata. Clear, but it does not differentiate this stat operation from siblings such as get_object_tags or read_object_text.

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?

Implied usage is to retrieve object metadata, but there is no explicit when-to-use guidance, no exclusions, and no named alternative for cases where object content or tags are needed instead.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose two non-obvious traits: the transfer is streamed, and the local path is strictly confined to the workspace sandbox. It omits whether existing keys are overwritten, failure/partial-upload semantics, size limits, and required credentials, so the disclosure is only partial.

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 that front-loads the action and scope. Nothing is wasted, though the parenthetical is doing double duty as a constraint rather than as structure. It is appropriately sized for the content it carries.

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?

This is a mutation tool with no annotations, no output schema, and four undocumented parameters. The description covers purpose and one key guardrail but says nothing about return values, error behavior, or parameter meanings, leaving significant gaps for an agent to call it correctly.

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

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

Schema description coverage is 0% for all four parameters, so the description must compensate and largely does not. 'Local file' loosely maps to local_path and the S3 target to key/bucket, but nothing explains key format, whether bucket is optional or defaulted, or acceptable content_type values. The uncovered parameters remain opaque.

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

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

The description names a specific verb and resource: streaming upload of a local file to S3. This clearly distinguishes it from siblings like put_object_text (text payload), download_file (reverse direction), and copy_object (server-side copy). It stops short of naming those alternatives explicitly, so it stays at 4.

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 use this tool versus put_object_text, copy_object, or download_file, and no mention of prerequisites. The parenthetical sandbox note hints that the source path must live inside the workspace, but that is a constraint rather than usage routing. An agent gets no explicit when-to-use guidance.

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