Fast.io

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

Discloses read-only behavior for content, destructive actions (chat-delete), side effects (credit consumption for ask/status/chat-create/message-send), idempotency of chat-cancel, and verbosity defaults. Annotations are consistent (destructiveHint true corresponds to chat-delete).

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 dense but well-organized, starting with high-level purpose then detailing actions and caveats. Could be slightly more concise, but every sentence adds value. Front-loaded with core concept.

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 23 parameters and no output schema, the description covers all major actions, their behaviors, side effects, and default modes. It also directs to 'describe' for full reference, completing the information needed for an agent to select and invoke 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 coverage is 100% with parameter descriptions. The tool description adds context beyond schema, such as default verbosity per action, best-effort nature of detail parameter, and clarification for file_attach/folders_attach. Provides additional usage-level guidance that enhances the schema.

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

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

The description clearly states that Ripley is a delegation surface for a RAG agent, answering natural-language questions about files/folders while managing chat threads and generating shares. It distinguishes itself from sibling primitive tools by advising to prefer Ripley over issuing many primitive reads.

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?

Explicitly provides when to use and when not: 'Prefer Ripley over issuing many primitive reads' and 'for content writes, call the primitive MCP tools directly.' Also gives quick start action='ask' and mentions lower-level actions for multi-turn control.

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

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

Annotations already declare destructiveHint=true, and the description confirms 'Destructive: delete.' It adds the note to call 'describe' for full reference but does not disclose other behaviors like overwrite policies or listing limits.

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

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

The description is extremely concise, with two sentences covering purpose, operations, and reference. Every sentence is necessary and 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?

Given the tool has 10 parameters and no output schema, the description is somewhat incomplete. It relies on the agent calling 'describe' to get full action/param reference. The core purpose is clear, but behavioral details are lacking.

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 100%, so the baseline is 3. The description gives examples of asset types (logos, banners, profile photos) and mentions entity scopes, but these are also covered in the schema. It adds minimal extra meaning.

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

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

The description clearly states it manages brand assets (logos, banners, profile photos) across entities (org, workspace, share, user) and lists main operations (upload, delete, list, read). It distinguishes itself from siblings by focusing on brand assets, though it doesn't explicitly differentiate from the 'upload' sibling 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?

No guidance on when to use this tool versus siblings like 'upload' or 'storage'. It does not state when not to use it or provide examples of appropriate contexts.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=true. The description adds value by listing specific destructive actions (api-key-delete, oauth-revoke, oauth-revoke-all) and highlighting the 'describe' action for detailed reference. No contradiction with annotations.

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

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

The description is three sentences, efficiently listing the core functionality, the discoverability mechanism, and destructive actions. Every sentence adds value; no redundancy or fluff.

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

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

Given the tool's complexity (23 parameters, no output schema), the description provides an entry point and relies on the 'describe' action for completeness. It covers enough context for initial use, though return values and detailed parameter usage are deferred.

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 100%, so baseline is 3. The description does not add meaning beyond the schema; it only directs to the 'describe' action for param details. No additional parameter semantics are provided.

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

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

The description clearly identifies the tool as handling authentication and sessions (signin, signup, signout, 2FA, PKCE, API keys, OAuth sessions). It distinguishes from sibling tools like 'user' or 'org' by focusing on auth operations. The verb+resource pattern is specific and 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 instructs to call action='describe' for full action/param reference, providing a discoverability mechanism. However, it does not explicitly state when to use this tool vs alternatives (e.g., when to use 'auth' vs 'user' for user management) or when not to use it.

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

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

Description adds context beyond annotations: identifies destructive actions (delete, bulk-delete), explains verbosity behavior and that override may be a silent no-op. No contradiction with annotations.

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

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

Description is well-structured with a front-loaded overview, followed by specifics on destructive actions and verbosity. It is slightly dense but each sentence adds value; could be more concise but still effective.

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

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

Given the tool's complexity (25 parameters, multiple actions, nested objects, no output schema), the description covers essential behavioral aspects (destroy, verbosity, describe action). Lacks example usage or return format, but adequate for a complex tool.

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

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

Schema coverage is 100%, baseline 3. Description adds meaningful semantics: clarifies that node_id applies to both files and folders, share_id implies profile_type=share, and workspace_id similarly. Also explains the purpose of the 'describe' action and verbosity 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?

The description clearly states the resource (comments) and specific operations: add, list, delete, react, anchor to various media, link to tasks. It distinguishes itself from sibling tools like 'how-to' or 'task' by focusing on commenting functionality.

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?

Provides explicit guidance to call 'action=describe' for full reference, explains verbosity defaults and overrides. However, lacks explicit when-not-to-use or alternative tools among siblings.

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

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

The description adds behavioral context beyond annotations: it mentions bandwidth credit consumption and deprecation of quickshare-details. Annotations already indicate read-only and idempotent behavior, so the description provides useful additional detail without contradiction.

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

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

The description is extremely concise: two sentences that front-load the main actions, include a deprecation warning, and point to the describe action for further reference. No wasted 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?

While the schema covers all parameters and annotations add safety context, the description itself defers to action='describe' for full reference, indicating it is not fully self-contained. It lacks details on return values (no output schema) and does not explain bandwidth credits.

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 100%, so each parameter has individual descriptions. The tool description adds no extra parameter-level semantics beyond categorizing actions and noting deprecation. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: downloading URLs for files, folder ZIPs, and (deprecated) quickshare links. It specifies the verb 'download' and the resource types (file-url, zip-url), and distinguishes itself from the fileshare tool for the deprecated action.

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 only provides usage guidance for the deprecated quickshare-details action, directing users to the fileshare tool. It does not offer when-to-use or when-not-to-use guidance for the primary actions (file-url, zip-url) or compare with other sibling tools like upload or storage.

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

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

The description adds valuable context beyond annotations: it explains that dashboard actions are 'view-only dismiss/snooze', mentions 'best-effort AI overlay', and clarifies that verbosity overrides are best-effort. This aligns with idempotentHint=true and destructiveHint=false, with no contradiction.

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 relatively long but front-loads the main purpose and then dives into verbosity details. It could be more structured (e.g., bullet points) and slightly more concise, but it is not excessively verbose.

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 31 parameters and no output schema, the description explains the major actions and defaults, and points to 'describe' for full details. However, it does not describe return values or response structure, leaving some gaps for a complex tool.

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

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

Schema description coverage is 100%, so the schema already documents parameters thoroughly. The description adds some meta-context (e.g., default verbosity rules), but this is mostly a reorganization of schema info. The added value is limited.

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

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

The description clearly states the tool is for event log and activity monitoring for workspaces and shares, and also surfaces a dashboard feed. It specifies multiple actions and provides a clear verb-resource relationship. However, it does not explicitly differentiate from sibling tools like 'activity' or 'user', which might also deal with events.

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 advises to call action='describe' for full reference, which is helpful. It explains default verbosity for different actions, but does not provide explicit guidance on when to use this tool versus alternatives, nor when not to use it.

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

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

The description goes beyond annotations by detailing critical behaviors: deletion never touches the bound file, uniform 404 for security, password handling via header, and reversible access changes. These details provide rich transparency that annotations alone do not cover.

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 paragraph with dense information. It is front-loaded with the core purpose and efficiently covers all capabilities. While it is somewhat long, every sentence adds value, and it is well-structured for the complexity.

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

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

Given the tool's complexity (16 parameters, no output schema), the description provides a comprehensive overview of actions, constraints, and security. It explains key design decisions like immutable binding and uniform 404. However, it lacks details on return values for each action, which a complete description would include.

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 input schema has 100% description coverage, so the baseline is 3. The description adds extra value by clarifying that password must be supplied via header and by emphasizing constraints like EXACTLY ONE of user/email for grant-add/grant-revoke. This improves parameter understanding beyond the schema.

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

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

The description clearly states it manages 'durable single-file share links' with operations like create/list/details/update/delete, per-user grants, and direct URLs. It differentiates from sibling tools by focusing specifically on file shares and emphasizing immutable binding to a workspace file, which distinguishes it from generic sharing tools.

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

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

There is no explicit guidance on when to use this tool versus alternatives. While the description mentions binding to a workspace file and uniform 404, it does not provide context for choosing fileshare over sibling tools like 'share' or 'upload'. The lack of usage criteria makes it less helpful for an AI agent to decide.

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

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

Annotations already declare readOnlyHint=true, so the description adds value by detailing grouping, independent pagination, health reporting, and that metadata bucket is workspace-only. No contradictions. Additional context beyond annotations.

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

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

Description is concise and well-structured: purpose first, then details, then alternatives and caveats. No wasted sentences. Each sentence adds value.

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 18 parameters and no output schema, description covers grouping, pagination, health, action select. Lacks mention of return format or error cases, but overall adequate for a complex tool.

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

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

Schema description coverage is 100%, so baseline is 3. Description repeats some parameter info (e.g., action enum, profile_id aliases) but doesn't add significant new meaning beyond what schema provides.

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?

Description clearly states it is a unified search across workspace or share, results grouped by type into buckets. It specifies the scope (workspace/share) and distinguishes from sibling tools like storage action=search and metadata action=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?

Explicitly states when to use (for grouped superset search) and when not (narrower tools for single result type). Lists alternatives: storage action=search for files, metadata action=search for lexical metadata, and code-mode search for API catalog. Also mentions using action='describe' for full reference.

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

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

Annotations already declare readOnlyHint, openWorldHint, destructiveHint. Description reinforces by stating 'performs NO platform action' and 'returns GUIDANCE TEXT'. Adds behavioral context like being grounded in Fastio's knowledge and naming tool-specific calls, which goes beyond annotations.

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

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

The description is relatively long but every sentence serves a purpose: purpose, usage distinction, behavioral notes, parameter tips, and availability. It front-loads the core function. Minor redundancy could be trimmed but overall efficient.

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?

Despite no output schema, the description fully explains return values (guidance text or clarifying question), mentions the 'describe' option for full reference, and notes prerequisites (authenticated user) and cost (free). No 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?

Schema coverage is 100%, but the description adds extra context beyond the schema's parameter descriptions, e.g., advising to be specific to avoid clarifying questions and explaining the 'describe' action. This adds meaningful usage guidance.

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

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

The description clearly states it is for asking natural-language 'how do I…' questions about Fastio, returns guidance text, and performs no platform action. It explicitly distinguishes from the 'ai' tool for RAG, making its purpose 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?

Provides explicit guidance: use for questions about Fastio itself, not for user-uploaded files (use 'ai'). Also explains it is advisory only and names concrete tool actions to prefer over guessing endpoints.

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

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

Annotations declare destructiveHint=true and readOnlyHint=false, and the description reinforces 'Destructive: delete.' It adds context about multiple operations (list, update, revoke) beyond what annotations provide. However, it does not detail side effects like how revocation affects existing invitations.

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 sentences, both front-loaded with core functionality and a key usage hint. Every sentence serves a purpose without redundancy.

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 (10 parameters, multiple actions) and no output schema, the description is fairly complete. It covers the tool's purpose and the key behavior hint (describe). It could mention the return format of list operations, but overall adequate.

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 100%, so the schema already documents each parameter. The description adds no further parameter-level detail beyond the schema, meeting the baseline for high coverage.

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

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

The description clearly and specifically states the tool manages workspace/share invitations with actions: list, filter by state, update, revoke. It distinguishes this tool from siblings by mentioning the destructive delete capability.

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 advises to call action='describe' for the full action/parameter reference, providing a clear entry point. However, it does not explicitly contrast with sibling tools like 'member' or 'workspace' for when to use this tool 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?

Annotations already indicate destructiveHint=true. The description adds 'Destructive: remove,' which is consistent but does not elaborate on other behaviors (e.g., auth requirements, rate limits). Minimal added value beyond annotations.

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

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

Extremely concise: two sentences covering purpose and a key usage tip. No unnecessary words, front-loaded with the main function.

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?

Despite high parameter count (20) and no output schema, the description is minimal. It offloads details to action='describe', leaving the agent with little upfront understanding of each action's requirements or effects.

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 100%, so baseline is 3. The description does not add meaning beyond the schema; it merely references action='describe' for details. No additional param context provided.

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

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

The description clearly states 'Workspace/share member management' and lists specific actions (list, add, remove, update, transfer ownership, join, leave). This distinguishes it from sibling tools like workspace, share, or user.

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 advises calling action='describe' for full reference and highlights that 'remove' is destructive. However, it lacks explicit guidance on when to use this tool versus alternatives or when not to use it.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=true), the description adds details about specific destructive actions and AI credit consumption. It also notes that the category parameter is ignored, batch sizes are server-clamped, and field autoextract requirement, providing valuable behavioral 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?

The description is front-loaded with the core purpose and pipeline, then provides sibling guidance and behavioral notes. It is dense but every sentence adds value, with no wasted words. The length is appropriate for the tool's complexity.

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?

Despite the thorough overview of operations and side-effects, the description lacks information about return values or output structure for actions like search, template-list, etc. There is no output schema, so the description should provide some guidance. The instruction to call action='describe' partially mitigates this, but for a 25-param tool, the description is not 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?

With 100% schema description coverage, the baseline is 3. The description adds extra context such as the 'category' parameter being ignored and the 'action' parameter referencing 'describe' for full details. However, the description does not elaborate on many parameter details beyond the schema, so it slightly elevates but not to 5.

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

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

The description clearly states the tool handles 'AI metadata templates & extraction' and lists all major operations including CRUD, AI pipeline, views, and search. It distinguishes from the sibling 'storage' tool by noting that node-level metadata lives on that 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?

The description explicitly says when to use the storage tool instead for node-level operations. It also advises to call action='describe' for full reference, and lists destructive actions and AI credit side-effects, guiding the agent on appropriate usage.

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

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

Annotations already set destructiveHint=true and readOnlyHint=false. The description adds specific context about the 'close' action being destructive, which is helpful. However, it doesn't disclose other behavioral traits like rate limits, authentication needs, or side effects for non-destructive actions. The addition is moderate.

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

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

The description is extremely concise at two sentences, front-loading the main capabilities and providing a critical directive ('use describe for full reference'). Every sentence 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?

Given the tool's complexity (58 parameters, many actions), the description is too sparse. It directs to 'describe' for details, but does not explain how parameters relate to actions or provide enough context for the agent to use it effectively without an extra call. The output schema is missing, and the description doesn't compensate.

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 100%, so every parameter already has a description. The tool description adds no extra meaning beyond listing the categories of actions. Baseline is 3 per guidelines, and no extra value is provided.

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

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

The description clearly states 'Organization management' and lists the covered areas (CRUD, billing, members, etc.), making the tool's purpose obvious. However, it doesn't differentiate from sibling tools like 'member' or 'invitation', which might overlap, but the name 'org' implies a unified management endpoint.

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

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

The description provides a meta-instruction to call action='describe' for full reference, but lacks guidance on when to use this tool versus alternatives or when not to use it. No exclusions or context are provided, leaving the agent without clear decision criteria.

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

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

Beyond annotations (destructiveHint=true), the description adds important behavioral context: autotitle side effects (consumes credits, mutates metadata), intelligence costs credits (10/page and default false), delete is permanent, intelligence forced false on workspace_folder shares, and verbosity defaults. No contradictions with annotations.

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

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

The description is long but dense with useful information, front-loaded with overall purpose. Every sentence adds value for a complex tool with 60 parameters. While it could be slightly more structured with bullet points, it is appropriately concise given the complexity.

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

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

The description covers all essential aspects: actions, deprecation, side effects, costs, defaults, parameter semantics, and usage guidelines. For a tool of this complexity, it is comprehensive and leaves no important 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?

Despite 100% schema coverage, the description adds significant value by explaining parameter nuances: details on action=describe, intelligence cost, limit internal vs display_limit, confirm validation, verbosity defaults, and specific usage for review parameters. This enhances understanding beyond the schema.

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 starts with 'Share management: create/update/delete, archive, password auth, members, autotitle,' clearly stating the scope. It distinguishes from sibling tools like fileshare by noting that quickshare-create is deprecated and advises using fileshare's create action. The description is specific and covers diverse functionality.

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

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

The description provides explicit guidance on when to use which action, deprecation warning, cost warnings for intelligence, verbosity defaults, and recommends calling action='describe' for full reference. It also explains when to use fileshare instead, offering clear context and exclusions.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds specifics about destructive actions: purge is irreversible, delete moves to trash, metadata-delete removes keys. It also explains default verbosity for different actions. This goes beyond the annotations, providing useful behavioral 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?

The description is a single, somewhat dense sentence that covers many points. It front-loads the core actions but lacks paragraph breaks or structured sections. It is concise but could be more readable by splitting into bullet points or separate sentences.

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

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

Given the tool's complexity (50 parameters, many actions), the high-level description provides a good overview and points to action='describe' for details. However, it doesn't explain return values or all behavior nuance. Without an output schema, more context could be helpful, but the description does an adequate job for an introductory reference.

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 50 parameters have descriptions in the input schema (100% coverage), so the schema already documents meaning. The description adds minimal parameter-level detail, only noting default verbosity levels and the action parameter's use. Thus, it adds some value but not substantially beyond the schema.

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

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

The description clearly states the tool handles files and folders on workspaces/shares, listing many specific operations. It distinguishes from sibling tools like download, upload, which are separate concerns. The purpose is unmistakable.

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 directs users to call action='describe' for full reference, which is helpful. However, it does not explicitly state when to use this tool versus alternatives, nor when not to use it. There is no comparison to sibling tools, though the scope is broad enough that it's likely the primary file operation tool.

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

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

The annotations declare destructiveHint=true, and the description supplements by naming the destructive actions ('delete-list, delete-task'). This adds context beyond the annotation. The description also implies the tool is not read-only (consistent with readOnlyHint=false) and hints at the breadth of operations (bulk ops, attachments, etc.). It does not cover rate limits or authorization, but the annotation and description together provide adequate transparency for selection.

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 concise: 3 sentences. It front-loads the purpose and key differentiator (ad-hoc vs workflow), lists core features, provides actionable guidance (use describe), and warns about destructive operations. Every sentence serves a purpose; no redundancy or filler.

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

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

Given the tool has no output schema and 34 parameters, the description provides a good overview of features (statuses, priorities, assignees, etc.) and directs to the describe action for full parameter details. It mentions the destructive nature and the context (workspaces/shares). It could be enhanced by describing typical return shapes or noting that some actions may require specific parameters, but for a complex tool, the describe fallback makes it sufficiently complete.

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

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

The schema coverage is 100% with descriptions for all 34 parameters. The description adds value by highlighting the action parameter and instructing to use 'describe' for a full action/param reference. This meta-guidance helps the agent navigate the parameter-rich schema. While the description doesn't detail individual parameter semantics beyond the schema, the suggestion to call describe compensates for the tool's complexity.

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

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

The description clearly identifies the tool as for 'lightweight task lists/tasks for ad-hoc in-workspace tracking' and distinguishes it from the durable orchestration sibling 'workflow'. It states the core capabilities (statuses, priorities, assignees, etc.) and the verb 'tracking' implies management. The resource is task lists/tasks, and the scope is ad-hoc in-workspace, making purpose specific and distinct.

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 explicitly guides when to use this tool ('ad-hoc in-workspace tracking') and when to use an alternative ('For durable, multi-step orchestration use the `workflow` tool.'). It also recommends calling action='describe' for full details. However, it does not provide explicit 'when not to use' beyond the workflow comparison, nor does it cover other potential alternatives or prerequisites.

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

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

The description discloses all critical behavioral traits: side effects (file creation, storage credit consumption), overwrite behavior (same-name files overwrite with recoverable versions), error conditions (filesize mismatch causing finalize to fail with code 10522), and the hard ceiling behavior of max_size. Annotations already indicate destructiveHint=true, but the description adds actionable specifics. No contradictions with annotations.

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

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

The description is well-structured with clear sections (e.g., 'BINARY:', 'UPLOAD STRATEGY') and front-loaded with the main variants. However, it is quite lengthy and dense, which could be slightly more concise without losing information. It earns its length due to the tool's complexity.

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

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

Given the tool's high complexity (40 parameters, multiple actions, no output schema), the description is remarkably complete. It covers all upload paths, error codes, defaults, and even points to further details via action='describe'. There is no missing context for an agent to select and invoke 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 coverage is 100% with 40 parameters, so baseline is 3. The description adds significant value by explaining how parameters relate to upload strategies (e.g., content vs content_base64 vs blob_id, filesize constraints, folder_id vs parent_node_id). It also clarifies parameter usage in context (e.g., 'stream' boolean for stream mode). One point deducted because the description could be more explicit about a few parameters like 'offset' and 'limit' which are only mentioned in schema.

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

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

The description clearly defines the tool's purpose: file upload with multiple strategies (streaming, chunked, web URL import, batch). It specifies the verb 'upload' and the resource 'files', and distinguishes itself from sibling tools (which are other categories like ai, auth, comment, etc.) by focusing exclusively on upload operations.

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

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

The description provides a comprehensive decision tree under 'UPLOAD STRATEGY' that tells the agent exactly when to use each upload mode (e.g., web-import for URLs, stream-upload for unknown sizes, chunked for known byte count, batch for small files). It also includes explicit 'do not' guidance (e.g., 'Do NOT guess filesize for generated content') and defaults to stream-upload.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=true. Description adds 'Destructive: close', which is consistent and highlights that action, but does not elaborate on other actions' behavior 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?

Very concise single sentence plus a note. No waste, but could benefit from slightly more structure given the tool's complexity. Still, it earns a high score for efficiency.

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?

Despite 100% schema coverage, the description lacks context about the tool's overall behavior, return values (no output schema), and how actions interconnect. The openWorldHint is not explained, leaving gaps for an agent.

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 has 100% coverage with descriptions for all parameters. Description adds no extra meaning beyond the schema, relying on action='describe' for details. Baseline score of 3 is appropriate.

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 mentions user profile, contacts, invitations, and assets, which gives a general idea but does not clearly distinguish from sibling tools like 'member' or 'invitation'. The action enum provides specificity, but the description itself lacks 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?

Minimal guidance: advises to use action='describe' for full reference and notes that 'close' is destructive. No explicit when-to-use vs alternatives, and no context on tool selection among siblings.

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

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

The description discloses key behavioral traits beyond annotations: 'Write/lifecycle actions are FIRE-AND-FORGET (return ids + state + a `_next` poll hint); destructive actions need confirm='true'.' This adds crucial context that annotations (readOnlyHint=false, destructiveHint=true) do not fully convey. It also notes that 'describe' and 'guide' are callable without auth. No contradiction with annotations.

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

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

The description is dense but front-loaded: it starts with the core purpose, exclusions, and a comprehensive list of covered areas. Every sentence adds value, and it avoids redundancy. However, it could be slightly more concise by listing fewer sub-domains, but the detail aids completeness.

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 136 parameters and numerous actions, the description is fairly complete by outlining major behavioral patterns and directing to action='describe' for per-action details. It covers scope, fire-and-forget behavior, confirm requirement, and auth hints. Given the complexity and lack of output schema, the description adequately sets context.

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?

With 100% schema description coverage, the baseline is 3. The tool description provides high-level context for parameters by listing domains like 'Covers lifecycle, steps, obligations...' but does not detail individual parameters. This adds some meaning beyond the schema, especially for grouping, but not substantial per-parameter value.

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

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

The description clearly states the tool's purpose: 'Durable workflow ORCHESTRATION + native content-review + e-signature, scoped to a workspace.' It explicitly distinguishes itself from siblings by stating 'NOT the in-workspace task-tracking primitive, NOT `workspace action=enable-workflow`.' This provides a specific verb+resource and differentiates it from other 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?

The description gives guidance on when to use this tool by stating what it is not, effectively excluding the 'task' and 'workspace' tools. It also tells the agent to 'Call action='describe' for the full per-action reference' and 'action='guide' for the workflow-authoring playbook', providing clear context for further exploration. However, it does not provide explicit when-not-to-use scenarios beyond the two 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?

The description provides critical behavioral details beyond annotations: destructive delete (workspace + all files), intelligence costs credits (10/page), rate-limited toggle, and verbosity defaults. This fully informs the agent of important 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?

The description is fairly concise given the tool's complexity, with important information front-loaded. It groups related information and uses line breaks. Some density could be reduced, but overall it is well-structured.

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 48 parameters, no output schema, and rich annotations, the description covers all essential aspects: destructive risks, cost implications, moved actions, and verbosity handling. It is complete enough for an agent to use 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?

The input schema has 100% parameter coverage, so the description does not need to compensate. However, it adds value by explaining verbosity defaults and overriding behavior, which is beyond the schema's parameter descriptions.

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

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

The description clearly states the tool is for workspace management and enumerates actions like list, update, delete, archive, members, notes, quickshares. It explicitly distinguishes from siblings by noting that metadata actions have been moved to the metadata tool and node-level metadata to storage 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?

The description gives explicit guidance on when to use the tool and when not to (e.g., metadata actions moved to metadata tool, node-level metadata to storage tool). It also advises using action='describe' for full reference and warns about intelligence costing credits. However, it does not exhaustively cover all alternative tool uses.

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