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

No annotations are provided, so the description carries full behavioral burden. It hints at destination behavior (directory vs file) and a vague "Local copy first," but discloses nothing about permission needs, what happens on an existing file, or failure/partial-write behavior for what is effectively a download 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?

Highly compact and front-loaded with the core action, with no filler. The trailing fragment "Local copy first" is terse to the point of ambiguity, slightly hurting clarity for no length gain.

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. However, for a tool that writes to the local filesystem with no annotations and 0% parameter documentation, the description should cover overwrite behavior, permissions, and failure semantics; it does not.

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 partially explains the destination argument's directory-vs-file behavior but says nothing about the required source path and completely omits the overwrite parameter (which defaults to false), leaving an agent unable to tell how collisions are handled.

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 ("Save a Drive file to a local path") and clarifies the destination semantics (a directory keeps the file's name). It is clear enough to distinguish from upload/write siblings, though it never names or contrasts 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 use this versus icloud_read_file, icloud_upload, or other siblings, and no prerequisites or exclusions. Usage is only implied by the verb "Save."

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 burden, and it does disclose that the result includes local sync state — genuinely useful context beyond the schema. It does not state that this is a read-only/non-mutating operation, nor any failure behavior for missing or remote-only paths.

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 (single item, local sync state) earns its place.

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

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

An output schema exists, so return values need not be explained, and the tool is simple with one parameter. Still, path semantics are undocumented and there is no annotation coverage to compensate, leaving an agent to guess path format.

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

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

Schema coverage is 0% and the single 'path' parameter has no description anywhere. The phrase 'one file or folder' tells the agent the path addresses a single item, but nothing clarifies path format, roots, or whether it is local vs iCloud-relative.

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 the resource (metadata for a single file or folder) and adds a distinguishing detail (local sync state) that separates it from account-level siblings like icloud_status. The verb is implicit in the name rather than spelled out, but an agent can still tell it apart from icloud_list and icloud_search.

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

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

Use is implied by 'for one file or folder' — you supply a path when you need metadata on a single item rather than a listing. However, it never states when to prefer this over icloud_status or icloud_list, nor any prerequisites 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?

With no annotations, the description carries the full behavioral burden. 'List' implies a read operation, but nothing is said about whether listing recurses into subfolders, whether results are paginated, or whether hidden/trashed items are included — meaningful gaps for an agent enumerating a folder.

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

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

Two compact sentences, front-loaded with the action and scope. The second sentence enumerates return fields, which is mildly redundant given an output schema exists, but it costs little and reads cleanly.

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

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

The output schema covers return values, so the entry-field listing is a bonus rather than a necessity. However, with zero annotations and a bare parameter, the definition still omits recursion, pagination, and permission context, leaving it only minimally sufficient.

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 the single 'path' property has an opaque empty-string default. The description usefully clarifies that an omitted path means root, which the schema does not convey, but adds no format, separator, or escaping detail for the path value itself.

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 (a Drive folder), and pins the default scope to root. It does not distinguish itself from the closely related icloud_search or icloud_list_trash siblings, but the core purpose is unambiguous.

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

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

No guidance on when to list versus when to use icloud_search, icloud_info, or icloud_list_trash. The default-to-root note is the only contextual hint, leaving the agent to infer selection criteria from sibling names 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. "List" implies a read-only operation, but the description says nothing about ordering, pagination, whether trashed items can be nested, or how empty results appear — and it is silent on any auth or scope requirements.

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 the resource front-loaded and no filler. Nothing could be trimmed without losing meaning.

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

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

An output schema exists, so return-value shape is already covered and need not be explained. For a zero-parameter, read-only listing tool the description is essentially sufficient, though a note on ordering or scope would make it fully self-contained.

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 schema imposes nothing to document. The baseline for a parameterless tool applies, and the description correctly does not invent any input arguments.

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 ("items in the iCloud Drive trash"), which is unambiguous and distinguishes it from the mutation sibling icloud_trash. However, it does not explicitly contrast itself with icloud_restore or icloud_list, leaving the agent to infer the boundary.

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

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

The description gives no when-to-use guidance, no prerequisites, and never names an alternative such as icloud_restore or icloud_list. An agent can infer intent from the name alone, but nothing in the text routes it or sets expectations.

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 and does disclose two real behavioral traits: the parent-must-exist precondition and idempotent behavior (returns the existing folder rather than erroring). It stops short of covering permissions, error cases (e.g., a file already at that path), or 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?

Two short sentences, zero filler, with the core action front-loaded and the constraint/precondition attached inline. Every clause earns its place.

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

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

For a single-parameter mutation tool with an output schema already covering return values, the description is nearly sufficient — it even documents idempotent return behavior, which the output schema alone wouldn't convey. Missing path format and permission/error semantics keep it just short of 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?

Schema description coverage is 0%, so the description must compensate for the single 'path' parameter. 'Parent must exist' adds meaningful constraint on how path is interpreted, but format details (absolute vs. root-relative, folder naming rules) are never specified.

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 folder') with no ambiguity, and among siblings like icloud_rename, icloud_move, and icloud_write_file it is clearly the only folder-creation tool. An agent can identify its role 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?

It states a precondition ('parent must exist') and an idempotency condition, which is useful usage context. However, it never states when to reach for this tool versus siblings, and no alternatives or exclusions are named — usage is 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, yet it discloses nothing about whether the destination folder must already exist, whether an existing file at the destination is overwritten, whether the move is atomic or reversible, or what happens across folders. 'Into another folder' is the only behavioral constraint offered.

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, which is appropriately sized for the operation. It is efficient but so terse that it leaves no room for the guidance a mutation tool needs.

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, but for a two-parameter mutation tool with no annotations and no parameter documentation the description is too thin. An agent cannot determine from it whether the destination must pre-exist or what failure/overwrite semantics apply.

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

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

Schema description coverage is 0% for both parameters, and the description does not compensate: it never explains whether 'path' is relative or absolute, or whether 'dest_folder' must be an existing directory. The phrase 'a file or folder' for path and 'another folder' for dest_folder merely restates the schema property titles ('Path', 'Dest Folder').

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 (Move) and resource (a file or folder) with the destination scope ('into another folder'). It is clear on its own, but it does not distinguish itself from the close sibling icloud_rename, which is the operation an agent is most likely to confuse with a move.

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

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

There is no guidance on when to use this versus icloud_rename, icloud_upload, or icloud_mkdir, and no prerequisites or exclusions are given. The agent must infer the use case purely from the one-line purpose.

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 does disclose meaningful traits — UTF-8 decoding, lossiness on binary, a per-call cap (truncation) with offset paging — but 'Local copy first' is opaque and it never says whether truncation is signalled, what happens on a missing file, or permissions required.

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?

Extremely terse and front-loaded, with the core purpose in the first fragment. 'Local copy first' is cryptic rather than wasteful, but the compressed fragment style doesn't hurt selection.

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 no explanation, and the description covers encoding, capping, and paging. Still incomplete for a read operation: no error behavior, no explanation of the caching claim, and no guidance on detecting a truncated result.

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, so the description must compensate. It clarifies 'offset' (paging) and 'max_bytes' (the per-call cap) but leaves 'path' unexplained and gives no formats, units, or defaults.

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 ('Read a file as UTF-8 text') with a useful qualifier about decoding fidelity. It doesn't explicitly name or contrast the nearest sibling (icloud_download), though 'lossy for binary' implicitly steers binary content away from this 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?

'lossy for binary' hints at when not to use it and 'page with offset' gives the paging method, but no alternative tool is named and there are no explicit preconditions. Usage is implied rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutation tool. It does not say whether an existing target name is overwritten, whether the operation fails on collision, what permissions are required, or whether the change is reversible. The presence of an output schema only relieves it of describing return values.

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 efficient, though the extreme terseness is achieved partly by omitting necessary detail rather than by editing it 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 mutation tool with no annotations, zero parameter documentation, and a sibling (icloud_move) that plausibly overlaps, one sentence is not enough. The output schema covers returns, but nothing addresses collision behavior, permissions, or path conventions.

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

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

Schema description coverage is 0%, so the description must compensate and it does not. It gives no guidance on path format (absolute vs. relative to iCloud Drive root, whether folders use a trailing separator) or naming constraints for new_name, leaving the two required parameters entirely unexplained beyond their self-evident titles.

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 (rename) and resource (file or folder) with the scoping qualifier 'in place'. This distinguishes it implicitly from location-changing operations, though it never names the icloud_move sibling that is the closest 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?

'In place' implies the name changes but the location does not, which faintly signals when to prefer this over icloud_move, but no alternative or condition is stated explicitly. An agent must infer the rename-vs-move boundary on its own.

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 says almost nothing: it does not disclose permissions required, whether restoring to the original location can overwrite or collide with an existing item, or what happens when multiple items share the same name. 'Restore' implies a state mutation but no behavioral detail is given.

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 sentence with zero filler; appropriately sized. It is efficient but borders on under-specified rather than genuinely concise-and-complete.

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, but for an unannotated mutation tool the description omits the things an agent actually needs: target disambiguation, failure modes (item not in trash, name not found), and any permission or irreversibility notes.

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 and is only titled 'Name'. The phrase 'by name' confirms the lookup key is a name rather than an ID, but adds nothing about case sensitivity, path qualification, or how duplicate names are disambiguated — the ambiguity most likely to cause a wrong invocation.

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 (restore) and resource (an item from the trash), which cleanly separates it from siblings like icloud_trash, icloud_list_trash, and icloud_delete-style tools. It doesn't explicitly name a sibling, so it stops short of the 5 mark.

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 or mention of alternatives; the agent must infer that this applies only to items already in the trash (vs icloud_list_trash for viewing, or icloud_move for relocation). No prerequisites or preconditions are stated.

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

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

With no annotations, the description carries the full burden. It does add real value by disclosing matching semantics (substring vs glob when * ? [ appear), but it omits that this is a read-only operation, the recursive depth behavior (default 3), and any result-cap 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 tight sentences, zero waste, with the core operation front-loaded and the matching rule second. 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?

An output schema exists, so return values needn't be described. However, for a 4-parameter tool with no annotations and no schema descriptions, the description leaves search scope (path, recursion depth) and result limits unexplained.

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 clarifies query semantics well but says nothing about path (default empty), max_depth (default 3, i.e., recursive search), or max_results (default 100) – three of four parameters remain undocumented anywhere.

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 (find) and resource (items by name under a folder), which distinguishes it from read/write/upload siblings. It does not, however, draw an explicit line against icloud_list, the nearest neighbor.

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: 'by name' suggests it is the name-matching counterpart to icloud_list, but no when-to-use, when-not, or alternative is named. An agent must infer the routing from sibling names.

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

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

No annotations are provided, so the description must carry the behavioral burden. It implicitly signals a read-only, non-mutating operation and tells the agent what state is inspected, but it says nothing about authentication requirements, failure modes (e.g., what "session works" returns when it does not), or rate limits. Adequate for a simple diagnostic, but not rich.

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, zero waste, and the three reported facts are front-loaded after the verb. Nothing is padded and nothing material is omitted for a tool of this size.

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

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

With an output schema present, the description need not explain return values, and with zero parameters there is no schema burden. It covers what is checked and implies the read-only nature. The one gap is that it does not help the agent position this against sibling status/info tools, though that is largely a routing concern rather than a completeness defect.

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 by the rubric the baseline is 4. There is nothing for the description to disambiguate, and it correctly does not invent parameter detail.

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

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

Uses a specific verb ("Report") and enumerates exactly what is reported: the Apple ID in use, whether the saved iCloud session works, and the local sync folder. That is far more concrete than a generic status tool, but it never distinguishes itself from sibling icloud_info or icloud_list, which an agent might reasonably confuse with this one.

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 rather than stated: the enumerated outputs (Apple ID, session validity, sync folder) make it clear this is the connectivity/diagnostic check an agent would run before sync, read, or upload operations. There is no explicit when-to-use, no when-not, and no named alternative (e.g., icloud_info), so guidance remains inferential.

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, and it discloses the single most important behavioral trait for a destructive-looking operation: the move is recoverable via icloud_restore. It omits secondary behavior such as name-collision handling in the trash or whether the source path must exist, but the critical reversibility signal is present.

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

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

A single sentence with zero waste, front-loading the action and resource and appending the recovery route as a compact parenthetical.

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 no explanation, and the description covers action, target, and reversibility adequately for a one-parameter tool. Remaining gaps (trash name collisions, error conditions) are minor.

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?

One parameter at 0% schema description coverage, so the schema provides no guidance on 'path'. The description adds only that the target may be either a file or a folder; it says nothing about path format, relative vs absolute, or whether the path must already exist.

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 ('Move a file or folder to the iCloud trash'), and the scope distinguishes it from icloud_move (relocate) and any permanent-delete sibling. The parenthetical naming icloud_restore makes the operation's nature unambiguous.

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

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

The description makes clear this is the non-destructive removal path and points at icloud_restore for reversal, which is the primary decision an agent faces. It stops short of explicit when-not-to-use guidance (e.g., overwriting an existing trash entry or deleting permanently).

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 disclosure burden. It does volunteer one meaningful behavior — name-collision failure and the overwrite escape hatch — which is genuinely useful. It omits auth requirements, whether the destination folder must pre-exist, and any mutation/reversibility context.

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

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

Two short sentences with zero filler, and the core action is front-loaded ahead of the failure condition. Every clause carries information.

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

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

An output schema exists, so return-value detail is not needed, and the collision rule is a good addition. But for a 4-parameter mutation tool with zero annotation and zero schema-description coverage, the description leaves the destination and naming semantics too thin to call 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?

Schema coverage is 0%, so the description must compensate, and it only explains the interplay of 'overwrite' with the 'name' collision case. It says nothing about what 'name' defaults to (presumably the local filename), what an empty 'dest_folder' means (root?), or the expected local_file format.

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 ('Upload a local file into a Drive folder') that clearly separates it from siblings like icloud_download, icloud_read_file, and icloud_write_file. The only wobble is the ecosystem mismatch between the tool name (icloud_*) and the description's 'Drive folder' wording, but the operation itself is unambiguous.

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 conditional 'Existing names fail unless overwrite is true' gives a real precondition for success, which is more than most siblings offer. However, it never contrasts this tool with alternatives such as icloud_write_file or icloud_mkdir, nor states when an agent should upload versus write directly.

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, and it does disclose one important trait — existing names fail unless overwrite=true. It does not cover permissions, whether intermediate directories are created, encoding, or whether the write is destructive to prior content of the same name.

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, the create action front-loaded and the collision constraint immediately after. Nothing is padded or redundant.

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 the failure-mode rule is a useful addition. Still, for a mutation tool with zero annotation coverage and zero schema descriptions, the description leaves path semantics and permission requirements unaddressed.

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 clarifies that content is a string and that overwrite defaults to non-destructive behavior, but 'path' is never explained (local vs Drive-relative, required) and the other two parameters get only partial treatment.

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

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

The description gives a specific verb and resource ('Create a text file in Drive') and clarifies the input source ('from a string'). It implicitly separates itself from sibling icloud_upload (binary uploads) and icloud_mkdir (directories), though it never names those alternatives 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?

Usage is implied rather than stated: the overwrite clause tells the agent what happens on name collision but not when to prefer this tool over icloud_upload or icloud_rename. No prerequisites (parent path existence, auth) are given.

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