Fast.io

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

Beyond annotations (readOnlyHint=false, destructiveHint=true), the description details that storage content is read-only, but chat threads and shares are created, and specifically names 'Destructive: chat-delete'. It further discloses credit consumption for certain actions, idempotency of chat-cancel, and best-effort behavior of detail/pagination parameters — 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?

Although long, every sentence carries actionable information: purpose, usage preference, write caveat, quick start, side effects, destructive actions, and verbosity defaults. The structure is front-loaded and logically organized, making the length appropriate for a 23-parameter multi-action tool.

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

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

The description is exceptionally complete for a complex tool with no output schema. It covers the core workflows (ask, status, chat management, share generation), return shape for ask, side effects (credits, cancellation), and edge cases like the wait parameter and best-effort detail/pagination. Combined with the rich schema, an agent has all necessary context to invoke 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 already covers all 23 parameters (100% coverage), so baseline is 3, but the description adds meaning beyond the schema: it highlights the 'ask' quick start with its return shape, 'status' and 'describe' actions, and explains default verbosity for list vs details actions. It also clarifies that 'limit' and 'offset' may silently be no-ops.

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 'the MCP delegation surface over Fastio's RAG agent' with a specific verb: 'answers natural-language questions about workspace/share files & folders (with citations)'. It also distinguishes itself from siblings by stating it never creates/edits/deletes files and that content writes should use primitive MCP tools directly, plus it manages chat threads and shares.

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?

Explicit guidance is given: 'Prefer Ripley over issuing many primitive reads: ask one NL question' and 'for content writes, call the primitive MCP tools directly' — a clear when-to-use and when-not-to-use. It also notes lower-level chat/message actions for multi-turn control and points to '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 include destructiveHint=true, and the description explicitly calls out 'Destructive: delete', adding specificity beyond the annotation. It also discloses the range of actions. No contradiction with annotations (readOnlyHint=false, destructiveHint=true).

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

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

Three sentences, front-loaded with purpose, followed by operational scope and a clear pointer to the describe action. Every sentence earns its place with no 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?

The tool has 10 parameters and no output schema, but the schema itself is richly described. The description covers the main actions and explicitly defers to action='describe' for full details. Minor gap: the 'types' action is not mentioned, but the pointer to describe mitigates this.

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 all parameters are already documented in the schema. The tool description does not add parameter-level meaning beyond the schema, but it does provide domain context (e.g., logos, banners, profile photos). Baseline 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?

Description states a specific verb+resource: 'Brand asset management' with concrete asset types (logos, banners, profile photos) and scope (org/workspace/share/user). It lists key operations (upload, delete, list, read) and distinguishes itself from generic sibling tools like upload/download by naming the asset domain.

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 clear context on what the tool manages and its entity scope. Points users to action='describe' for the full action/param reference, which is useful meta-guidance. However, it does not explicitly state when to use this tool over 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?

Explicitly flags destructive operations (api-key-delete, oauth-revoke, oauth-revoke-all), which is critical behavior disclosure. It also implies session side-effects through the listed operations. It could say more about persistence or user-visible effects, but for a dispatcher it covers the high-risk cases well.

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 dense sentences lead with the tool's domain, immediately route the agent to 'describe' for details, and close with an explicit destructive-action warning. No filler.

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

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

For a dispatcher covering 17 actions, the description plus the rich schema gives the agent a clear entry path and boundary. It could be slightly more explicit about common pitfalls (e.g. which params are mutually exclusive), but the pointer to 'describe' fills that gap.

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

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

The schema already documents every parameter with detailed, action-specific descriptions split across fields - in particular the 'code' and 'token' fields explain ambiguity and point to action='describe'. The description adds the convention of using describe for the full per-action reference, but doesn't need to restate parameter details.

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

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

The description names a clear resource ('auth & sessions') and enumerates the operation families (signin, signup, signout, 2FA, PKCE, API keys, OAuth) that the tool covers bel. This distinguishes it from sibling tools at a glance and tells an agent exactly what domain it owns.

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 tells the agent to call action='describe' for the full action/parameter reference)SkipThat is a concrete usage instruction for navigating a large dispatcher surface, and it lists destructive operations. It doesn't name conditions for choosing this over siblings, but the domain statement ('Auth & sessions') makes that clear enough.

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 readOnlyHint=false, and the description adds meaningful behavioral context: explicitly stating 'Destructive: delete, bulk-delete' and disclosing that the detail override is 'best-effort — may be a silent no-op until the comments API honors output='. This goes beyond the annotations but doesn't fully describe all behaviors, making 4 appropriate.

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 compact yet information-dense, covering purpose, action discovery, destructive behavior, and verbosity controls in just a few sentences. It is front-loaded with the main purpose and every sentence contributes, with no fluff or repetition.

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, 10 actions, nested reference objects), the description does a good job by summarizing scope, pointing to action='describe' for full details, and covering key behavioral nuances. It doesn't explain return values or the full reference structure, but the schema and describe action compensate, so a 4 is fair.

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 adds a small amount of parameter semantics via the verbosity discussion (detail defaults), but this is already present in the schema's detail parameter description. No significant new parameter meaning is introduced, so the baseline score stands.

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: 'Comments on files: add/list/delete/react' and explicitly mentions anchoring to image regions, A/V timestamps, PDF pages, or text selections. This specific verb+resource pairing distinguishes it from all sibling tools, none of which relate to comments.

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 clear usage context, such as calling action='describe' for the full reference and explaining verbosity defaults for list/list-all vs details. However, it does not explicitly mention when not to use this tool or compare it to alternatives, so it stops short of a 5.

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

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

Annotations declare readOnlyHint and idempotentHint, and the description adds 'Consumes bandwidth credits' which is valuable non-obvious behavior beyond the annotations. It also notes deprecation. No contradiction with structured data.

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, front-loaded with the core purpose, and includes essential caveats (deprecation, bandwidth credits, describe action) without redundancy. 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?

For an 11-parameter, multi-action tool, the description plus 100% schema coverage and the `describe` action provides a fairly complete picture. It doesn't detail return values, but the `describe` action is explicitly offered to fill that gap.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning to the `action` parameter by explaining what each enum value (file-url, zip-url, quickshare-details) does, something the schema's action description omits. It also flags deprecation, enhancing parameter understanding.

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: 'Download URLs for files (file-url), folder ZIPs (zip-url), and quickshare links'. It identifies specific actions and differentiates from siblings like `fileshare` by noting the deprecated quickshare-details and the 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?

Provides clear usage context by mentioning bandwidth credits and explicitly deprecating quickshare-details with a pointer to the `fileshare` tool for new shares. However, it doesn't explicitly state when to prefer this tool over all alternatives beyond that.

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 provide idempotentHint=true and destructiveHint=false, and the description does not contradict either. Beyond the annotations, the description discloses important traits: the dashboard is 'view-only' with 'best-effort AI overlay', verbosity overrides are 'best-effort' on certain actions, and several behaviors differ by action (e.g., changes cursor reuse, long-polling on activity-poll, fileshare feed only for workspace members). This adds substantial behavioral context beyond the structured fields.

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

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

The description is dense but well-organized, front-loading the main purpose and then layering action-specific notes, verbosity defaults, and references to the describe action. Every sentence carries distinct information, and the structure groups related concerns (events+activity, dashboard, changes, verbosity). It is longer than average, but the complexity of a 30-parameter multi-action tool justifies the length without 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?

For a tool with 30 parameters, no output schema, and 11 actions, the description provides a solid high-level map and directs the agent to action='describe' for the full action/param reference. It covers the major conceptual semantics (verbosity, cursor usage, file share visibility caveats) but relies on that external describe action for per-action field lists and response details. This is a reasonable balance given the scale, though not exhaustive.

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%, but the description text goes further by adding critical semantic caveats: the user_id field clarification about derived vs emitter subject, the category field warning that `node` is AI/RAG pipeline not file operations scrubbing, and the cloud_import subcategory disambiguation. These are not present in the schema and materially improve correct parameter usage. The description earns a top score by compensating for schema ambiguities.

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 explicitly names the resource ('Events & Activity') and enumerates the core capabilities: event log/activity monitoring, per-member DASHBOARD feed, and the org-wide changes cursor. It distinguishes the multi-action nature of the tool (search, activity-list, dashboard, changes) and clearly scopes each. The generic tool name 'event' is fully disambiguated by the description.

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 clear context for when to use specific actions: 'changes' for a single org-wide cursor 'instead of polling each one', and a recommendation to call action='describe' for the full action/param reference. It also explains default verbosity levels. However, it does not explicitly contrast this tool against sibling tools (e.g., workspace, share, storage) or state when to prefer one over another, which is a minor gap given the tool's breadth.

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 annotations only indicating destructive/open world hints, the description adds rich context: immutable file binding, deletion safety, uniform 404 design, header-only password transmission, and reversibility of grant-revoke. These are non-obvious behaviors that govern invocation and error handling.

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

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

The description is a dense paragraph, but given the tool's complexity (16 params, 13 sub-actions), every sentence earns its place. It front-loads the core purpose and groups related details, though a bulleted format could improve scanability.

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 high parameter count and no output schema, the description covers critical behaviors: immutable binding, deletion semantics, uniform 404s, password header usage, expiry rules, capability tiers, and pending invite handling. It leaves little ambiguity for an agent to operate 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 schema already covers 100% of parameters with detailed descriptions, so the baseline is 3. The description adds extra semantics beyond the schema, such as direct URL behavior requiring Authorization/header on GET and explicit note that passwords never appear in URLs, which clarifies existing password-related parameters.

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 explicitly states 'File Shares: durable single-file share links' and enumerates the action families (create/list/details/update/delete, grants, direct URLs). This clearly distinguishes it from sibling tools like 'share' or 'upload' by naming the exact resource and 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 practical usage guidance: 'Call action="describe" for the full action/param reference' and explains when to use headers for password-protected shares. It also gives caveats like 'deletion NEVER touches the bound file' and 'do not speculate' on 404s, but does not explicitly name alternative tools for exclusion.

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 provide readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is clear. The description adds genuinely useful behavioral detail beyond those annotations: grouped buckets, independent pagination, health reports, search_in changing the response shape when sent, and the detail tier affecting the facts field. It does not fully enumerate every behavioral nuance, but with annotations covering the core safety profile, the added context justifies a 4.

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 every sentence earns its place: it front-loads the core behavior, then siblings, then parameter semantics, then the action='describe' pointer. The main trade-off is that the opening sentence is long. The structure is otherwise tight, with no filler.

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

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

For a 20-parameter tool with 6 enums and no output schema, the description is strong: it covers result shape, pagination, health reporting, workspace-vs-share differences, and the action='describe' escape hatch. It does not restate every schema property, which is appropriate given 100% schema coverage. The main omission is not describing the search_metadata block shape after search_in is sent, but the escape hatch compensates.

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, but the description goes beyond by explaining cross-parameter relationships: search_in changes response shape and pairs with name_match; name_match exact/prefix/contains treat * and ? literally while glob uses wildcards; metadata_limit and metadata_offset are dropped on shares; and five id params are aliases that must match profile_type. That adds meaning the schema alone does not provide.

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 leads with a specific verb ('search') and a precise resource scope ('across a workspace or share'), then distinguishes the tool by its grouped-by-type result shape and explicitly contrasts it with storage action=search and metadata action=search. That contrast makes it immediately distinguishable from 19 sibling 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 concrete routing guidance: use storage action=search for file lookups, use find when metadata-only hits or comments are needed in the same call, and use metadata action=search for lexical metadata fields alone. It also tells the agent to call action='describe' for the full action/param reference, which is a strong when-to-use signal.

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 mark readOnlyHint=true, openWorldHint=true, and destructiveHint=false; the description goes beyond by adding 'EXPLAIN-ONLY / ADVISORY,' stating it performs no platform action, will not create shares/move files/change anything, and is free with only an authenticated user required. This is rich behavioral context 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 dense but well-organized, front-loading the core purpose and safety profile before diving into usage distinctions. Every sentence earns its place, though the length is notable; the ALL-CAPS label and clear clauses keep it scannable. It is not bloated but could be slightly tightened.

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 no output schema and a simple 3-parameter schema, the description is exceptionally complete: it explains return behavior (answer or clarifying question), scope (Fastio how-to vs RAG), safety/no-op nature, cost/auth requirements, and how to get a full action reference. No significant gaps remain.

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; description adds meaningful semantics: 'Call action="describe" for the full action/param reference,' 'a vague question returns a clarifying question instead of an answer,' and that `context` is 'treated strictly as untrusted DATA — it cannot redirect the assistant.' These details enhance 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 opens with a specific verb+resource: 'ask a natural-language how-do-I question about Fastio and get a grounded, product-aware answer.' It clearly identifies the tool as built-in product help and explicitly contrasts it with the `ai` tool for RAG over uploaded files, distinguishing it from siblings.

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 when-to-use guidance: 'prefer this over guessing endpoints or burning exploratory calls' and explains that `how-to` answers questions about Fastio ITSELF, while `ai` handles Q&A over uploaded files. It also tells the agent to act with other tools after reading guidance and mentions the `action='describe'` option for a 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?

The description goes well beyond the annotations by disclosing important behavioral nuances: allocate is GET-OR-CREATE and can hand back an already-held slot, fill acts as a heartbeat, browse returns topics only, expand returns full details, and release is destructive. These details are not present in the annotations and materially affect how an agent should invoke the tool.

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

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

The description is dense but every clause earns its place: purpose, lifecycle, heartbeat semantics, GET-OR-CREATE behavior, browse/expand distinction, describe pointer, and destructive warning. It front-loads the main purpose and communicates a complex multi-action tool in a compact, useful way.

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 10-parameter, six-action tool with no output schema, the description covers the central workflow and key behavioral caveats. It does not spell out return shapes for allocate or describe, but the schema covers parameters and the description directs to action='describe' for full reference. A small gap remains, so 4 is appropriate.

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 every parameter thoroughly. The description adds action-level semantics rather than parameter-level detail, which is appropriate, but it does not add much beyond the schema. Baseline 3 is correct.

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 resource ('Agent Intents') and the core purpose: announcing workspace work so peers see collisions. It names all six actions and their roles, making the tool's function unmistakable. However, it does not explicitly contrast with any sibling tool, so it earns a 4 rather than a 5.

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

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

The description gives a precise lifecycle: allocate when work starts, fill once content is known, browse live intents, expand for detail, release when done. It also provides an explicit exclusion ('there is no renewal verb') and directs users to action='describe' for the full reference. This is strong, actionable guidance for when to use each action.

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 destructive behavior (destructiveHint=true), and the description reinforces this with 'Destructive: delete.' It adds context about update/revoke operations but does not detail side effects, permissions, or response behavior. The safety profile is mostly covered by annotations, with the description adding minimal extra value.

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 short sentences that front-load the primary purpose, provide a clear directive for obtaining full details, and flag destructive actions. Every sentence serves a distinct and necessary role, with 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's complexity (10 parameters, multiple actions) and absence of an output schema, the description provides a high-level overview and directs to action='describe' for complete details. It does not explicitly list all actions or parameter groups, but the describe reference compensates, making the description sufficiently complete for initial orientation.

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 all 10 parameters are already described in the schema. The description adds no additional parameter semantics beyond referencing action='describe' for full details. This matches the baseline for high schema coverage; no extra credit needed.

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 'Workspace/share invitations' with actions like list, filter, update, revoke, which distinguishes it from sibling tools like share or member. It could be more exhaustive by listing all actions (e.g., delete, describe), but the pointer to action='describe' compensates, making the purpose evident.

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

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

The description implies usage when managing workspace/share invitations, but it does not explicitly state when to use this tool versus alternatives or mention exclusions. The advice to call action='describe' for the full reference is helpful though limited. No direct comparison to sibling tools is given.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true. The description goes beyond this by identifying 'remove' as the destructive action and by disclosing the self-describing action='describe' behavior. This adds specific context without contradicting 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 short sentences: purpose with operations, the 'describe' instruction, and a destructive warning. Every sentence earns its place with 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's complexity (10 actions, 20 parameters, no output schema), the description provides a concise overview and leverages the built-in 'describe' action for full detail. It doesn't outline return values, but that's acceptable without an output schema. It is sufficient for orientation.

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%, meaning all 20 parameters have descriptions. The description text itself adds no parameter-level detail beyond pointing to action='describe' for more information, so it meets the baseline for fully-covered schemas.

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 specifies 'Workspace/share member management' and enumerates the operations: list, add, remove, update, transfer ownership, join, leave. This distinguishes it from sibling tools like share (managing shares) and workspace (workspace settings).

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

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

It provides clear context for when to use the tool (member management for workspace/share) and instructs to call action='describe' for the full action/param reference. It does not explicitly contrast with sibling tools or state exclusions, but the resource scope is unambiguous.

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 flags fields-merge as DESTRUCTIVE and clarifies what that means: it folds near-duplicate field names together, which is a meaningful mutation warning beyond the generic destructiveHint annotation. It also discloses platform removals (RETIRED TEMPLATES and SAVED VIEWS) and redirects extraction to storage, setting accurate expectations. No contradiction with the annotations 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?

The description fits a broad multi-action tool into three compact sentences, with the action index front-loaded, retired functionality next, and storage routing last. Parentheticals keep the action list scannable, and the all-caps DESTRUCTIVE and RETIRED flags highlight the non-obvious parts. There is no filler.

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

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

For a 15-parameter tool with no output schema, the overview plus the highly descriptive schema gives an agent strong grounding: it identifies all live actions, warns about retired ones, and routes adjacent work to storage. It does not state return shapes or per-action eligibility semantics directly, but the `describe` action exists and the schema is thorough, so the agent can proceed.

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 explains all 15 parameters in detail, including nuanced ones like template_id hard-refusal and content_query AND semantics. The top-level description adds useful conceptual labels (field vocabulary, lexical value search, compound matching) but does not go deeper on individual parameters than the schema. Baseline 3 applies.

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 anchors to a concrete resource ('Workspace metadata') and enumerates each operation with its action name and a short gloss, e.g. 'lexical value search (search)' and 'folding near-duplicate field names together (fields-merge, DESTRUCTIVE).' It also explicitly distinguishes what the tool is not: templates/views are retired and per-file extraction lives on storage. This makes it easy to identify among siblings.

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 redirects per-file extraction to the `storage` tool (metadata-extract and metadata-extract-all), addressing the most likely tool-selection confusion. It also warns that retired template/view actions no longer exist here, preventing wasted calls. It does not give a full decision tree among the six metadata actions, but the schema and `describe` action fill that gap.

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 explicitly warns that close permanently deletes the org and all data, adding concrete destructive consequence beyond the destructiveHint=true annotation. It aligns with annotations (readOnlyHint=false, openWorldHint=true) and does not contradict them.

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

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

Three short sentences front-load the scope, direct the agent to the describe action for full reference, and highlight the destructive operation. Every sentence earns its place for a tool of this breadth.

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 55 parameters and a large action enum, the description cannot enumerate everything, but it provides a strong entry point by directing the agent to action='describe' for the full reference. It does not cover prerequisites or sibling routing, but it is sufficient to begin correct use.

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 provides detailed meaning for all 55 parameters. The description's mention of action='describe' is useful orientation but does not add semantic detail beyond what the schema already states.

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's domain as Organization management and enumerates major operation areas: CRUD, billing, members, invitations, ownership transfer, assets, and discovery. It does not explicitly differentiate the tool from overlapping siblings like member, invitation, or asset, so it stops short of a 5.

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

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

The only usage-related guidance is to call action='describe' for the full reference and a warning that close is destructive. There is no guidance on when to choose this tool over sibling tools, nor any conditions for specific actions like transfer-ownership or billing-create.

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?

Goes well beyond the annotations: it flags delete as permanent, discloses that autotitle consumes credits and mutates share metadata, warns that intelligence costs credits (10/page) and defaults to false, and explains per-action verbosity defaults. No contradiction with the 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?

Dense but well-organized: purpose first, then deprecation warning, self-reference to describe, destructive semantics, side effects, cost warning, and verbosity defaults. Every sentence carries operational value, and the warnings are visually flagged.

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 42-parameter, multi-action tool with no output schema, the description covers deprecation, cost, destructive behavior, side effects, and verbosity defaults, and provides an action='describe' escape hatch for further detail. It is not fully self-contained regarding return values, but that is a reasonable deferral for such 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%, and the schema itself already documents key behaviors like credit costs, removed parameters, and limit/display_limit semantics. The description reinforces cost and verbosity defaults but adds little parameter-level meaning beyond what the schema already 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?

The description opens with 'Share management: create/update/delete, archive, password auth, members, autotitle' — a specific, verb-rich inventory of operations rather than a tautology. It also names the sibling tool fileshare as the replacement for the deprecated quickshare-create, helping distinguish this tool from related siblings.

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 routes agents away from deprecated quickshare-create toward fileshare's create for durable single-file shares, and directs agents to call action='describe' for the full action/param reference. It doesn't enumerate every possible alternative sibling, but the critical routing decision is covered clearly.

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 the annotations (readOnlyHint=false, destructiveHint=true), the description discloses fire-and-forget lifecycle semantics, `_next` poll hints, terminal void behavior, credit reservation on send, pre-authenticated stream-route URLs, and confirm gating for destructive actions. These are substantial behavioral details not present in the 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 well-ordered: scope first, then the operation catalog, then key behavioral caveats, then the describe escape hatch. Every sentence carries information; there is no filler or repetition.

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 high-complexity tool with 22 parameters, 20 actions, and no output schema, it covers critical return behaviors (ids + state + `_next`, stream-route URLs) and directs agents to action='describe' for exhaustive per-action details. It does not spell out list/download return shapes, but the describe reference materially compensates.

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 all 22 parameters. The description adds useful global context such as confirm gating and fire-and-forget behavior, but it does not add significant per-parameter meaning beyond what the schema already 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?

The description names the domain (E-signature) and explicitly enumerates the operation classes: envelope drafts, send/void/retry, document/audit downloads, signing links, and templates. It clearly scopes everything to workspace-parented envelopes and templates, which distinguishes it from sibling tools like download or fileshare.

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 the tool is workspace-scoped, tells agents to call action='describe' for the full per-action reference, and flags that destructive actions require confirm='true'. It does not explicitly name sibling alternatives or when-not-to-use conditions, but no sibling covers e-signature, so the guidance is strong.

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?

Despite annotations already flagging destructiveHint=true and readOnlyHint=false, the description goes well beyond them by specifying which operations are destructive and what they actually do: "purge (irreversible). delete moves to trash. metadata-delete removes metadata keys." It also discloses the searchable metadata behavior and the verbosity default tiers per action. This is exactly the kind of beyond-annotation context the dimension rewards.

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 tool's scope, then gives high-value usage hints, destructive warnings, and verbosity defaults in a compact block. Despite covering a 31-action tool, every sentence carries distinct, decision-relevant information and there is no filler or 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?

For a 58-parameter, 31-action tool with no output schema, the description provides an efficient high-level orientation, flags safety-critical destructive behavior, and points to action='describe' for the full action/parameter reference. The richly documented schema covers the remaining invocation details, so the combination is sufficient for correct selection and safe initial use.

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 baseline is 3. The description adds a small amount of parameter context by explaining the `detail` parameter defaults and the action='describe' reference for full parameter docs, but it does not meaningfully enrich parameter semantics beyond the already very detailed per-parameter schema 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 opens with a precise resource and verb set: "Files & folders on workspaces/shares: list, search, copy, move, delete, rename, trash, transfer, versions, locks, previews, and per-node metadata". This is specific and clearly distinguishes the tool's scope from a mere tautology. However, it does not explicitly position itself against overlapping sibling tools like find, metadata, share, or upload/download, so it misses the top criterion of sibling differentiation.

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

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

The description provides clear, actionable workflow guidance: "check or search metadata before reading files" and explicitly warns about destructive actions (purge vs delete vs metadata-delete). It also explains verbosity defaults and how to override them. Still, it names no sibling tools or when-not-to-use conditions, so it falls short of the explicit exclusions/alternatives required for a 5.

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

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

Annotations only say readOnlyHint=false and destructiveHint=true, but the description adds substantial behavioral context: overwriting same-name uploads in place while preserving a recoverable version, consuming storage credits on certain actions, the 10522 filesize mismatch failure, max_size aborting mid-transfer, wait being in seconds, and password being sent only as a header. This goes far beyond what annotations reveal and matches the destructiveHint of overwrites and credit consumption.

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

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

The description is very long and contains notable redundancy: the content_base64-is-a-last-resort and firewall advice is repeated multiple times, and the 'no base64, no MCP size limit, up to 100 MB' claim appears more than once. Although the UPLOAD STRATEGY section is well-structured and front-loaded, the overall block is far from concise, and some sentences restate earlier warnings.

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 40 parameters, 20 actions, and no output schema, this description is remarkably complete: it covers the full decision tree, side effects, failure modes, error codes, CAS semantics, profile aliases, and the POST /blob sidecar flow. It also tells the agent to call action='describe' for the full per-action reference, covering remaining gaps in an actionable way.

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, but the description adds meaningful semantics beyond the schema for key parameters: blob_id is the default single-use source for file uploads, content_base64 is a last resort likely to fail above a few MB, content is only for on-the-fly text, filesize must match uploaded bytes to avoid the 10522 trap, and max_size should be overestimated. Not every one of the 40 parameters gets extra treatment, but the critical ambiguous ones are clarified substantially.

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 opens with a specific verb and resource — "File upload" — and immediately enumerates the distinct modes: stream-upload, chunked, web URL import, and batch. This clearly differentiates the tool from siblings like download, storage, and fileshare, and gives an agent a precise mental model of what the tool does.

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

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

The description provides an explicit, top-to-bottom UPLOAD STRATEGY with numbered decision rules: use web-import when a URL is available, prefer POST /blob + stream-upload for everything up to 100 MB, switch to chunked only over the cap or when a session id is needed, and use batch for many small files. It also explicitly warns when NOT to use content_base64 and tells the agent to check firewall settings instead, giving clear guidance versus alternatives.

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

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

Annotations already note destructiveHint=true and readOnlyHint=false. The description adds the specific information that the 'close' action is destructive, naming the exact operation. It also points to 'describe' for more detail, which is useful transparency about how to learn behavior. 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 compact: two sentences that convey the tool's scope, the key action to invoke for reference, and the destructive hint. Every clause earns its place, with no redundancy or filler. The 'Destructive: close' note is specific and valuable.

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

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

This is a complex multi-action tool with 19 parameters, no output schema, and broad capabilities. The description provides a high-level overview and defers to describe, which partially mitigates the lack of action-specific details. However, it omits return-value expectations and tool-selection guidance relative to siblings, leaving gaps for agent decision-making.

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 19 parameters have complete descriptions in the schema (100% coverage), so the description does not need to elaborate on them. It adds the hint to use describe for a full action/param reference, which is helpful but does not materially enhance parameter understanding beyond the schema. Baseline 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 identifies the tool as covering user profile, contacts, invitations, and assets, which gives a clear resource scope. It lacks a specific verb for a single action but is appropriate for a multi-action hub. The instruction to call action='describe' helps the agent discover specifics, and the resource list differentiates it from sibling tools like 'invitation' and 'auth'.

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 no guidance on when to use this tool versus alternatives. The only directive is to call action='describe' for the full reference, which is a within-tool navigation aid, not a selection guideline. No exclusions or sibling comparisons are offered.

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 exposes destructive scope ('delete (workspace + all files)'), cost/rate-limit implications ('intelligence COSTS CREDITS (10/page)'), side effects of toggling intelligence ('Disable flushes embeddings; re-enable re-indexes'), and verbosity defaults. Annotations only mark destructiveHint=true and readOnlyHint=false, so the description adds substantial behavioral context 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 long but every sentence carries load-bearing operational information: exclusions, destructive warning, cost caveats, verbosity defaults. It front-loads purpose and is organized logically, so an agent can quickly scan the key points without wading through 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?

For a tool with 29 parameters and 20 actions, the description covers the full scope, explicit exclusions, destructive/cost behavior, and points to action='describe' for exhaustive per-action details. It is complete enough for an agent to decide whether to invoke this tool and how to route the intent.

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 tool description mostly echoes schema details like the `detail` param defaults and intelligence cost warning, which are already present in the schema's property descriptions. It does not add meaningful new parameter-level explanation beyond what the schema already conveys.

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 opens with 'Workspace management: list/details/update/delete, archive, members, notes, quickshares, share import, import toggle' – a concrete verb+resource scope that names the operations. It further distinguishes itself from siblings by stating metadata actions moved to `metadata` and `storage` tools, so an agent knows this tool's boundaries.

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 tells the agent when not to use this tool: 'metadata actions MOVED — ... There are no `metadata-*` actions on this tool.' It also instructs calling action='describe' for the full action/param reference and warns to enable intelligence only on explicit user request. These are clear usage conditions beyond generic descriptions.

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