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

The description states that the tool returns account info and lists the specific fields. It does not explicitly mention side effects, but the annotations indicate readOnlyHint and idempotentHint, which are consistent with a read operation. The behavior is generally transparent.

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, consisting of two sentences that convey the purpose and usage. It is focused and free of unnecessary detail, making it easy to read and understand.

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 that there is no output schema, the description adequately explains what the tool returns (accountId, apiUrl, downloadUrl). It also provides context on how authorization is handled. There is no missing essential information for an agent to use this 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 is empty ({}), so there are no parameters to describe. The description does not add any parameter information, but since there are none, this is fully appropriate. Schema coverage is 100% with no gaps.

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: authorize with B2 and return account info including accountId, apiUrl, and downloadUrl. It specifies the action and the output, leaving no ambiguity about 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 guidance on when to use the tool: it notes that the server handles authorization automatically, but the tool is useful for verifying credentials and retrieving account details. It doesn't explicitly mention alternatives, but the context is 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?

The description adds no behavioral context beyond what the annotations already convey: it creates a resource, is not read-only, and is not idempotent. It does not mention authorization requirements, side effects on failure, or what happens if the bucket name already exists.

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 two concise sentences with the primary action front-loaded. The remaining sentence earns its place by capturing important bucket-name constraints that an agent must know before calling.

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 a complex 7-parameter schema with nested objects and no output schema, the description is narrow. It fully covers bucket naming constraints, but omits usage context, required authorization, expected return value, and relationship to sibling bucket operations.

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 meaningful parameter nuance beyond the schema for bucketName by specifying global uniqueness, 6-63 characters, allowed characters, case-insensitivity, and the prohibition on a 'b2-' prefix.

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

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

The description states a specific action and resource: 'Create a new B2 bucket.' This clearly separates it from siblings like b2_delete_bucket and b2_update_bucket, and the modifier 'new' removes ambiguity about the operation's intent.

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

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

There is no guidance about when to use this tool versus alternatives, no prerequisites, and no mention of related tools such as b2_authorize_account or b2_update_bucket. The intended use is only implied by the verb '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?

Annotations already indicate destructive and non-read-only behavior. The description adds meaningful operational context by disclosing how the one-time application key secret is handled in each mode: file sink mode returns redacted metadata plus a secretSink pointer, while inline mode returns the secret with an explicit warning. This goes beyond the structured fields and helps the agent anticipate 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 two sentences with no padding. The primary purpose is front-loaded, and the follow-up sentence efficiently explains the two operational modes and their output implications. Every phrase 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 six parameters, full schema coverage, annotations, and no output schema, the description covers the crucial behavioral distinction between file-sink and inline modes and what the response will contain. It does not enumerate every possible response field or error case, but for this tool it is sufficiently complete for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds semantic context about secret handling and modes but does not provide additional meaning for individual parameters beyond what the schema already states. A 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 opens with a specific verb+resource: 'Create a Backblaze account for a new Partner group member.' It clearly identifies the action and the target, and is distinct from siblings like b2_eject_group_member or b2_list_group_members. The extra mode detail reinforces the purpose without obscuring it.

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

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

The description makes the intended use clear: this is for onboarding a new Partner group member. It does not explicitly name alternatives or state when not to use the tool, but the context is unambiguous and the sibling set includes related but distinct operations, so an agent can infer 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?

The description adds meaningful behavioral context beyond the annotations: it explains how the secret is handled in file sink mode versus inline mode, and what the MCP response contains in each case. This is valuable because the tool is destructive and non-idempotent, and the secret-handling behavior is not obvious from annotations alone.

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 and front-loaded with the core purpose. Each sentence adds value, particularly the mode-specific secret-handling details, though terms like 'file sink mode' and 'inline mode' are introduced without explanation.

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

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

With no output schema, the description does a decent job explaining response contents, but it leaves ambiguity about how an agent determines which mode (file sink vs inline) is active. Required parameters like confirm and idempotencyKey are covered by the schema, so the main gap is the mode-selection 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?

Schema description coverage is 100%, so the schema already documents all eight parameters. The tool description itself does not add parameter-level detail, matching the baseline score for a fully documented 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 states a specific verb and resource: 'Create a B2 application key.' This clearly distinguishes it from sibling tools like b2_delete_key and b2_list_keys, though it does not explicitly contrast against them in text.

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

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

The intended use is implied by the tool name and first sentence: use when you need to create a B2 application key. However, there is no explicit guidance about when to prefer this over related key-management tools or any 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 discloses the behavioral requirement that the bucket must be empty, which is a key runtime behavior. It doesn't repeat the destructive/idempotent hints already present in annotations, but the added empty-bucket condition goes beyond annotation info.

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 succinct and directly to the point, stating the action and one crucial precondition without any redundant wording. It effectively communicates the essential information in two short 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 simple nature of the operation and the presence of schema descriptions for parameters, the description adequately covers the core purpose and a key constraint. It doesn't explain return values, but no output schema exists, so that is not required.

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 description itself does not elaborate on parameters, but the schema descriptions cover 100% of the parameters (bucketId and confirm). Since schema coverage is high, a baseline of 3 applies, and the description adds no extra parameter 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 the action 'Delete' and the resource 'a B2 bucket', along with a necessary precondition. The verb and object are unambiguous, leaving no doubt about the tool's purpose.

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 a critical usage condition: the bucket must be empty before deletion. While it doesn't explicitly compare with alternative tools, the condition is highly informative for correct usage in typical scenarios.

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 flag destructiveHint=true; the description adds meaningful consequences: deletion is irreversible and access is lost immediately. This exceeds the structured safety flags with real-world impact.

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 with no filler; the core action and irreversibility are front-loaded, and the access-loss consequence earns its place.

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

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

For a simple two-parameter destructive action, the essential facts (what happens, reversibility, immediate effect) are present. It lacks usage/alternative context, but schema and annotations fill most operational details.

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 applicationKeyId and confirm are already documented. The description adds no parameter-level information, which is acceptable given the schema baseline.

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

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

States a specific verb and resource ('Permanently delete a B2 application key'), and the irreversibility clarifies the scope. This clearly distinguishes it from sibling tools like b2_delete_bucket or b2_create_key.

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 choose this tool over alternatives, nor any conditions under which deletion should be avoided. It implies the action but doesn't provide decision context.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, and the description adds substantial context beyond that: results are derived from daily usage reports, scope follows the caller's key, and Usage Reports must be enabled. This meaningfully prepares an agent for how the tool behaves in practice.

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 with no filler: the primary action and default are front-loaded, followed by use cases and then important operational constraints. Every sentence adds information needed for correct selection and invocation.

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 read-only tool with three optional parameters and no required fields, this description is complete: it covers what is ranked, the possible grouping, the default time window, the output concept (leaders with egress share), the data source, authorization scoping, and a prerequisite. An agent can confidently invoke and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning by clarifying that 'account'/'bucket' maps to the 'by' parameter, that omitting 'days' means month-to-date, and that the result focuses on each leader's share of total egress. It does not discuss the limit parameter, but the schema already covers that.

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

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

States a specific verb ('Rank top egress') with a clear resource (downloaded bytes by account or bucket) and time scope (default month-to-date). It explicitly names the use cases ('who's downloading the most', 'where is egress concentrated'), which clearly separates it from sibling tools like b2_largest_files and b2_usage_growth.

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

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

Gives clear context for when to use it: ranking egress leaders by account/bucket over a period, with a default month-to-date window. It also notes the prerequisite that Usage Reports must be enabled, but it does not explicitly state when not to use it or name alternative tools.

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

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

Annotations already mark destructiveHint true, but the description adds significant context: the account is not deleted, the member resets password on next login, and the action is irreversible via API. This goes beyond the annotation by clarifying what actually happens.

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 with no wasted words. The purpose is front-loaded, followed by key constraints. Efficient and clearly 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?

Covers the behavioral implications (account not deleted, password reset, irreversibility) and the option to change email. All parameters are documented in the schema. The description is sufficient for a destructive tool, though it could explicitly mention the confirm requirement (which is in the schema).

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 parameters are already well-documented. The description adds a note about optionally changing email, but this is also covered in the schema. Baseline of 3 is appropriate since the schema carries the semantic load.

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 action (eject) and resource (member from a Group), and distinguishes from siblings like b2_create_group_member and b2_list_group_members. It is specific and not a tautology.

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 useful context on the effect (account not deleted, password reset) and a restriction (cannot be re-added via API), giving clear guidance on when to use it. However, it does not explicitly compare to alternatives or state 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the clarification that the rules are webhooks and are bucket-scoped, but does not describe return structure or edge cases like empty rule sets. 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?

A single front-loaded sentence states the action and object with no wasted words. Every word earns its place.

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

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

For a one-parameter, read-only getter with annotations carrying the safety profile and no output schema, the description is sufficient for an agent to invoke correctly. It clearly identifies what is being fetched, and the required bucketId is documented in the schema.

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's only parameter, bucketId, is fully described ('The bucket ID to get notification rules for.'), and schema description coverage is 100%. The description does not add parameter-level detail, but the schema carries the meaning, so 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 uses the specific verb 'Get' and names the resource 'event notification rules (webhooks) configured for a B2 bucket.' This clearly distinguishes it from the sibling b2_set_bucket_notification_rules, which writes rather than 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?

No guidance is provided on when to use this tool versus b2_set_bucket_notification_rules or other siblings. The read-only verbs and annotations imply retrieval, but the description does not state prerequisites, exclusions, or 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?

Beyond the readOnlyHint=true annotation, the description discloses a live listing, bounded scan by max_scan and a time budget, and truncated=true. This materially shapes agent expectations about results being approximate on large buckets, and it explicitly states that file contents are never returned.

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-load the purpose, then explain the important scanning caveat and return contents. Every sentence earns its place with 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?

With no output schema, the description helpfully states the return fields (name, size, upload time) and the truncated=true behavior. It doesn't discuss auth, error cases, or how it relates to b2_usage_growth, but for a read-only listing tool the essential information is present.

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 covers 100% of parameters with descriptions, and the tool description adds meaningful guidance for prefix and max_scan, explaining the full-listing requirement, truncation behavior, and subtree ranking. This adds value beyond the schema without needing to do more.

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

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

The description states a specific action and resource ('List a bucket's largest objects by size') and clarifies that it returns metadata, never contents. It does not contrast itself with sibling tools like b2_usage_growth or b2_list_buckets, so an agent must infer 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?

Gives clear context with natural-language triggers ('largest files', 'what's taking up space') and instructs using a prefix for a complete subtree ranking. It does not explicitly name alternatives or when not to use this tool, though the 'never contents' caveat helps.

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

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

The annotations already provide readOnlyHint and openWorldHint, indicating a safe, non-destructive operation. The description adds valuable behavioral details beyond the annotations: it explicitly states that requests are automatically narrowed to authorized bucket IDs when bucket-scoped, that results are truncated if exceeding the limit, and it describes the return fields (ID, name, type, CORS rules, lifecycle rules). This enhances transparency beyond what the annotations alone convey, though it does not fully describe edge cases like 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 moderately concise, but it is well-structured with two main sentences: one stating the core action and filters, another explaining the cap and truncation. It front-loads the primary purpose and includes necessary details without excessive verbosity. It could be slightly tightened (e.g., merging repeated 'filter' mentions), but it remains clear and 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?

Given that there is no output schema, the description compensates by explicitly listing the returned fields (ID, name, type, CORS rules, lifecycle rules). It also covers important context such as the automatic authorization narrowing and the truncation behavior, which are essential for a user to understand the tool's behavior in a real-world B2 account scenario. The description is complete for the complexity of a simple list operation.

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 provides descriptions for all four parameters with 100% coverage, including default values and enums for bucketTypes. The description reinforces these by explaining the purpose of the limit (to keep response small) and the consequence of exceeding it (truncation with a note). This adds semantic value, particularly around the limit parameter, going slightly beyond the schema's own 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 lists B2 buckets for the authorized account, using a specific verb ('List') and resource ('B2 buckets'). It distinguishes itself from other list tools by mentioning optional filters (by bucket ID, name, or type) and the automatic narrowing to authorized bucket IDs when bucket-scoped. This makes its purpose unambiguous and distinct from 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 provides context on when to use the tool: it is the primary listing operation, and it explains that the response is capped and how to handle truncation (raise the limit or add filters). While it does not explicitly mention alternative tools (e.g., b2_list_keys or s3_list_objects_v2), the context is clear enough for typical usage. It falls just short of explicit 'when-not-to-use' guidance, hence a 4.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds value by disclosing pagination limits (up to 1,000 per call), the use of nextEmail for continuation, and that storage stats per member are included. These details go beyond annotations and help the agent understand response volume and pagination flow. 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 two sentences with no filler. The core purpose is front-loaded, followed by essential behavioral details (pagination limit and response content). Every word earns its place; it is compact and 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?

For a read-only list operation with no output schema, the description provides sufficient context: it defines the resource scope, pagination mechanism, and return content (members with storage stats). It does not enumerate member fields, but that is not essential for invocation. Combined with annotations covering safety, the description is complete enough for 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 coverage is 100% (all 4 parameters have descriptions). The description does not add new semantic meaning beyond the schema—it restates pagination and the 1,000 limit, which are already in parameter descriptions (maxMemberCount maximum and startEmail as cursor). With high schema coverage, baseline 3 is appropriate; no additional parameter context 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?

Description states a specific verb ('List'), resource ('Group members'), and scope ('for a specific Group'). It also specifies the active (ACCEPTED) state, distinguishing it from siblings like b2_list_groups (lists groups) and b2_create_group_member (adds a member). The tool's purpose is unambiguous and clearly differentiated.

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 context by stating it lists accepted members for a specific group, and mentions pagination behavior. However, it does not explicitly name alternatives or state when not to use this tool versus others like b2_list_groups. There is no explicit when/when-not guidance, though the purpose is clear enough for basic selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral detail beyond that: it specifies a 100-group limit, pagination via nextGroupId, and the authorization requirement. These are not in the annotations and help the agent understand expected behavior.

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

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

Two sentences with zero wasted words. The main action is front-loaded, and the critical details (limit, pagination, authorization) are included without redundancy. It is a model of efficient writing.

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

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

For a simple list operation with no output schema, the description covers the key points: the scope ('active Groups'), the cap and pagination mechanism, and a prerequisite (authorization). It does not describe the response shape, but that is a minor gap given the tool's simplicity and the presence of a pagination hint.

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 four parameters are already documented. The description's mention of 'Returns up to 100 groups' and 'use nextGroupId for pagination' loosely relates to maxGroupCount and startGroupId but does not add new semantic meaning beyond the schema. Per the rubric, a baseline of 3 is appropriate when the schema carries the full burden.

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 uses a specific verb ('List') and a clear resource ('active Groups'), and adds the qualifier 'administered by a Group admin account,' which distinguishes it from sibling tools like b2_list_group_members (which lists members) and b2_list_buckets. It is unambiguous and immediately conveys the tool's core function.

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 states the required context (Group admin account, Partner API authorization) and implies the tool is for listing groups, but it does not explicitly name alternatives or state when not to use it. The distinction from b2_list_group_members is inferable but not spelled out, so guidance is present but not exhaustive.

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 establish read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context by explicitly stating that key secrets are not returned and exactly which fields are included (IDs, names, capabilities, restrictions). This goes beyond the schema and informs the agent about data sensitivity.

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 concise sentences with zero redundancy. The primary purpose is front-loaded, and the important caveat about key secrets is placed immediately after, giving the agent the most decision-relevant information efficiently.

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

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

For a straightforward list tool with no required parameters, the description covers the key details: what is listed, what is returned, and what is deliberately excluded. Pagination mechanics are handled by the schema's parameter descriptions, so nothing critical is missing.

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

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

Schema description coverage is 100%, with both maxKeyCount and startApplicationKeyId fully described in the schema itself. The description adds no additional parameter-level detail, but the schema already provides sufficient semantics for correct invocation.

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

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

The description uses a specific verb ('List') and resource ('application keys associated with the B2 account'), making the tool's function immediately clear. It also distinguishes itself from sibling tools like b2_create_key and b2_delete_key by focusing on listing rather than mutation.

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

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

The description clearly identifies this as a listing operation for application keys, which gives the agent enough context to select it over creation or deletion siblings. It does not explicitly state 'use this instead of X', but the read-only listing intent and the security-focused caveat provide clear situational context.

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

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

The annotations already flag the operation as destructive and not read-only. The description adds a valuable behavioral caveat beyond those annotations: account creation has no provider-side recovery path if a file sink write fails. This helps the agent appreciate the irreversibility and failure implications.

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 and front-loaded: the first sentence states the purpose, the second adds a crucial caveat. Minor jargon such as 'file sink' slightly reduces clarity, but 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 a fully described schema, clear annotations, and a focused purpose statement, the description is largely complete for invocation. The failure-recovery caveat materially improves completeness for a destructive operation, though no output/return behavior is described.

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 every parameter already has a meaningful description, including the confirm flag's destructive-policy dependency. The tool description itself adds no parameter-specific guidance, so it neither duplicates nor needs to compensate for 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 identifies the action ('Reserve'), the resource ('a B2 trial account'), and the channel ('through the Partner API'). This is distinct from the sibling create/update tools and leaves no ambiguity about 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 gives a clear condition of use ('Available only in explicit inline mode') and explains the reason behind it, which helps an agent decide *how* to call it. However, it does not name alternatives or explicitly state when not to use this tool versus another sibling.

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 this destructive and idempotent; the description adds useful specificity by stating that any existing rules are replaced. It does not go as far as noting the conditional confirm requirement, but the schema covers that, so the added behavioral insight is sufficient for a scoring of 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?

Two short sentences with the key action and destructive effect front-loaded. No filler or redundant restating of the schema.

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

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

Adequate for a clear mutating operation with detailed schema and annotations, but it omits when-to-use guidance and the confirm/destructive-policy context that would make it fully self-contained, especially given the absence of an output schema describing the result.

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

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

The description adds only a webhook hint and the replacement consequence; it does not explain bucketId, confirm, or rule construction. With schema description coverage at 67% and rich per-property documentation in the schema, the description neither meaningfully compensates nor detracts from what the agent can already read.

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

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

The description names a specific operation: setting event notification webhook rules for a B2 bucket, and adds the non-obvious behavior that existing rules are replaced. This distinguishes it from sibling b2_get_bucket_notification_rules without needing to open the schema.

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

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

There is no guidance on when to use this tool vs alternatives, no prerequisites, and no mention that b2_get_bucket_notification_rules is the read counterpart. The description only states what the tool does, leaving the agent to infer selection context.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the baseline burden is lower. The description adds meaningful behavior beyond annotations: it is a live listing bounded by max_uploads and an internal time budget, may truncate results on bloated buckets, and wasted_gb may be a lower bound. It also discloses that the tool recommends a lifecycle rule.

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 with no filler: use case, return metrics, invocation, and truncation caveat are each given distinct content. The most important scoping information is front-loaded.

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

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

Even without an output schema, the description tells the agent what will be returned: count, oldest upload age, and wasted bytes. It also covers the key failure mode and mitigation recommendation. Combined with rich annotations, this is complete enough for correct invocation and result interpretation.

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 parameters little parameter-level meaning beyond restating that the bucket can be given by name or bucketId, which duplicates 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 states a specific verb and resource: 'Find abandoned multipart uploads that silently consume storage in a bucket.' It also includes use-case keywords like 'bucket bloat' and 'wasted storage', which help distinguish it from generic listing tools such as s3_list_multipart_uploads and from size-focused siblings like b2_largest_files.

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 clear invocation contexts: 'bucket bloat', 'stuck/incomplete uploads', and 'wasted storage'. It does not explicitly name alternative tools or state when not to use this tool, so it stops short of full exclusionary guidance.

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 identify this as destructive and non-read-only, but the description itself adds no behavioral context beyond 'update.' It does not mention confirmation requirements, destructive consequences, or how updates apply. The confirm parameter appears only in the schema, not the tool description.

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

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

A single sentence with the verb and resource front-loaded and no filler. Every phrase contributes to understanding what the tool operates on and what it can change.

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 tool with nested objects and no output schema, the one-line description is adequate for basic tool selection but leaves important caveats—destructive confirmation, Object Lock requirements, and update semantics—to the schema and annotations. It is not incomplete enough to block use, but it is not fully self-sufficient.

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

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

Schema coverage is 64%, so the schema carries most parameter documentation. The description adds a useful high-level category list, but it omits key parameters like confirm, fileLockEnabled, defaultRetention, bucketInfo, and ifRevisionIs, so it only partially compensates for the coverage gap.

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

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

The description uses a specific verb ('Update') with a clear resource ('existing B2 bucket') and lists major setting categories (type, CORS rules, lifecycle rules, encryption, replication). This clearly separates it from siblings like b2_create_bucket, b2_delete_bucket, and b2_set_bucket_notification_rules.

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

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

The phrase 'existing B2 bucket' implies an update use case, and the listed settings suggest when to choose this tool. However, there is no explicit guidance about when not to use it or which sibling to prefer for related tasks such as notification rules or lifecycle-only updates.

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 signal destructiveHint=true, readOnlyHint=false, and idempotentHint=true. The description adds useful context beyond those hints: an active legal hold makes the file undeletable regardless of retention settings, and the operation requires a specific capability. It does not separately warn that clearing the hold removes protection, but the destructive annotation already covers that.

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

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

Two focused sentences: the first states the action and resource, and the second adds behavioral and permission context. There is no filler, repetition, or unnecessary preamble.

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?

Combined with the full schema and annotations, the description supplies the remaining operational facts: capability requirement and the relationship between legal hold and retention settings. Since there is no output schema, return values are not described, but for a state-setting operation this does not prevent correct invocation.

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

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

Schema description coverage is 100%, so every parameter, including the legalHold enum and the confirm field, is already documented in the input schema. The description adds no parameter-level detail, but none is required beyond the schema's 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 opens with a specific verb phrase ('Set or clear a legal hold') and identifies the exact resource ('a specific file version in B2'). It further distinguishes this from the related sibling b2_update_file_retention by stating that an active legal hold prevents deletion 'regardless of retention 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?

The description states the capability prerequisite (writeFileLegalHolds) and the behavioral effect of an active hold, which lets an agent infer when this tool applies. However, it never explicitly contrasts legal holds with retention policy or names the sibling b2_update_file_retention, so when-to-use guidance is implied rather than directly stated.

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

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

Annotations already mark this as destructive and non-read-only; the description adds useful behavior beyond that, such as 'In compliance mode, the retain-until date can only be extended' and the required writeFileRetentions capability. There is no contradiction with annotations. It could include more side-effect detail, but the provided context is meaningful.

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 carry the essential information: purpose, mode support, compliance constraint, and capability requirement. Every sentence earns its place with 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?

The description plus the richly documented schema cover the core operation, prerequisites, mode restrictions, required parameters, and the confirm behavior. There is no output schema, but for a mutation tool this is acceptable. A minor gap is that the description does not explicitly summarize clearing behavior, though the schema covers it.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds extra parameter-relevant meaning: the compliance mode only allows extending retain-until, and the capability requirement affects whether certain operations are permitted. This goes beyond what the schema's property descriptions state.

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 'Set or modify the retention policy on a specific file version in B2,' naming the action, the resource, and the scope precisely. It also names the two supported retention modes, distinguishing this from legal-hold and bucket-level operations. This is specific and non-tautological.

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

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

The description clearly establishes when the tool is applicable—when a B2 file version's retention policy needs to be set or modified—and adds the capability prerequisite. It does not explicitly name alternative tools, but the operation scope and sibling names make the intended use unambiguous. The schema covers the confirm flag for destructive operations.

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 the tool read-only, idempotent, and non-destructive. The description adds substantial behavioral context beyond that: it uses end-of-day stored_gb snapshots, fetches only two days for efficiency, returns the compared dates and per-account start/current GB plus % growth, flags new accounts, and explains that scope follows the caller's key. This gives the agent a clear picture of what the call does and what to expect.

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 adds value: purpose, use cases, data semantics, performance behavior, return contents, scoping, and a prerequisite. It is front-loaded with the core action and remains readable despite its length.

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

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

With no output schema, the description explains what the response contains (dates compared, per-account start vs current GB, % growth, new account flags). It also covers prerequisites, scope, and performance characteristics. For a read-only reporting tool with four optional parameters, nothing essential is missing.

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

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

Schema description coverage is 100%, with all four parameters documented in the input schema itself. The tool description reinforces the period-window concept but does not add much new parameter-level meaning beyond what the schema already says. Baseline 3 is appropriate when the schema carries the parameter documentation burden.

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

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

The description states a specific action ('Rank accounts by how much STORED data grew or shrank'), names the data source (daily B2 usage reports, stored_gb snapshots), and gives concrete use cases ('which customers grew the most/least', 'who's moving data off'). This clearly differentiates it from siblings like b2_egress_leaders or b2_largest_files.

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 clear usage context: it is for growth/shrinkage ranking between two points, compares latest snapshot against month/quarter/year earlier, and notes the prerequisite that Usage Reports must be enabled. It does not explicitly name alternative tools or state when not to use it, but the intended scenarios are well specified.

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, so the description is not required to restate destructiveness. It adds useful behavioral context by specifying that the operation aborts an in-progress upload and releases associated storage, making the consequence concrete beyond the bare annotation.

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

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

The description is a single, tightly constructed sentence that communicates the action, scope, and consequence with no redundant words. It is front-loaded and easy to parse.

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

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

For a destructive operation, the description plus annotations and 100% schema parameter coverage provide enough information to invoke the tool correctly. It would benefit from a brief note about irreversible consequences or the distinction from s3_complete_multipart_upload, but those are either covered by annotations or inferable from the sibling tool names.

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 every parameter, including the important confirm flag, already has a meaningful schema description. The tool description itself adds no parameter-specific detail, so the baseline 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 uses a specific verb ('Abort') with a clear resource ('in-progress S3-compatible multipart upload') and an outcome ('release all associated storage'). This clearly distinguishes it from related operations like s3_complete_multipart_upload or s3_create_multipart_upload.

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 word 'in-progress' implies this tool is for canceling an unfinished multipart upload rather than completing it, which gives some usage context. However, it does not explicitly state when to choose this over s3_complete_multipart_upload or s3_delete_object, nor does it mention any 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 cover read-only (false), idempotent (true), and non-destructive (false) hints. The description adds the behavioral requirement that parts must be provided in ascending order, which is useful, but it does not disclose other traits such as error behavior or effects of retries. This is acceptable given 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?

Two short sentences: the first states the action, the second states the critical input requirement. Zero filler, front-loaded with the core action.

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 complete parameter schema, the no-output-schema case, and annotations covering safety and idempotency, this description provides sufficient context for an agent to invoke the tool correctly. It could be slightly richer on error cases or return values, but nothing essential is missing.

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

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

Schema description coverage is 100%, so the parameters are already well-documented. The description's mention of ETags and ordering adds a minor contextual layer but does not introduce new information beyond what the schema 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 uses a specific verb 'Finalize' with the resource 'S3-compatible multipart upload', clearly distinguishing it from create/abort operations. It also adds a key requirement ('Provide the ETags... in order') that solidifies its purpose.

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

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

Usage is implied: the tool finalizes an upload, which presupposes that all parts have been uploaded. It does not explicitly mention alternatives like abort_multipart_upload or state conditions for when to use this over other tools, but the context makes the primary use case clear.

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

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

The description adds useful behavioral context beyond the annotations: the acl parameter is called out as a no-op S3 compatibility hint, and B2 access is tied to the destination bucket policy. This helps the agent understand side effects and authorization behavior that the annotations do not convey. There is 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 two sentences with no filler. It front-loads the core operation and scope, then places the important acl caveat and access-policy note. Every sentence earns its place and the structure is easy for an agent to scan.

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 9-parameter tool with full schema coverage and useful annotations, the description is reasonably complete: it clarifies bucket scope and the acl no-op. It does not describe the return value or error behavior, but the absence of an output schema and the schema's thorough parameter documentation keeps this from being a major gap.

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

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

Schema description coverage is 100%, so the schema already documents all parameter meanings. The description repeats the acl no-op behavior that the schema already states, adding no new param-level insight. Baseline 3 is appropriate because the schema does the heavy lifting and the description does not need to compensate.

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 operation: 'Copy an object within B2 or between B2 buckets via B2's S3-compatible CopyObject API.' It names a specific verb, resource, and scope, and the phrase 'CopyObject API' distinguishes it from sibling upload/part-copy tools without requiring schema inspection.

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 clear context for the operation and its cross-bucket scope, but it never explicitly tells the agent when to choose this over alternatives like s3_put_object or s3_upload_part_copy. Usage is implied by the semantics of 'copy' rather than stated with exclusions or sibling comparisons.

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 convey non-read-only and non-idempotent behavior. The description adds useful operational context by clarifying that this call only initiates the upload, returns an UploadId, and does not upload data itself. However, it omits the important lifecycle fact that the initiated upload persists as unfinished state until completed or aborted, so it adds some but not rich behavioral disclosure.

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 carry purpose, scope, return value, and companion-tool routing without any filler. The key information is front-loaded in the first sentence.

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?

Combined with the schema, the description is sufficient for the immediate call: it implies required bucket/key, optional metadata, and the meaning of the returned UploadId. The main gap is lifecycle guidance—an initiated multipart upload should eventually be completed or aborted—and there is no output schema to fill that in, making the overall description informative but not fully complete.

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

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

Schema description coverage is about 83%, and the schema already explains bucket, key, metadata, contentType, and serverSideEncryption. The tool description adds no parameter-specific meaning beyond 'large file' and the returned UploadId, so it stays at the schema-coverage baseline of 3.

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 a specific action ('Initiate an S3-compatible multipart upload') on a clear resource ('a large file in B2') and immediately names the companion sibling tool, s3_presign_upload_part, distinguishing this initiation step from per-part URL minting. There is no ambiguity about 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?

It gives clear usage context: use this when the file is large and when a multipart strategy is intended, and pass the returned UploadId to s3_presign_upload_part. However, it does not explicitly say when not to use it, such as recommending s3_put_object for small objects, or mention that completion/abort steps must follow.

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 destructive and non-read-only behavior. The description adds minimal extra context by noting that version ID selects a specific version, but it does not disclose consequences like irreversibility or behavior in versioned buckets. This is acceptable but not rich.

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

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

Two short sentences, front-loaded with the action and resource. Every word earns its place; no filler or unnecessary detail.

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

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

For a destructive 4-parameter tool with annotations and full schema coverage, this is minimally sufficient. However, it omits behavior on missing objects, versioning edge cases, and the bulk-delete alternative. Without an output schema, a bit more context would round it out.

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%, and the description does not add meaning beyond what the schema already provides. The version-ID mention in the description only restates the schema field description, so the baseline of 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 states a specific verb ('Delete'), a clear resource ('an object from a B2 bucket'), and the optional version-ID behavior. It is immediately distinguishable from the sibling s3_delete_objects by the singular object scope.

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

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

No guidance is given on when to use this tool versus alternatives. In particular, the sibling tool s3_delete_objects provides bulk deletion, and the description does not mention that distinction or any other selection 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is covered. The description adds the 'bounded SDK concurrency' detail, but does not add further behavioral context such as irreversibility, versionId effects, or interaction with the confirm parameter.

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

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

A single sentence with the verb first, the target resource next, and a useful bound trailing; no filler or repetition of schema fields. It earns its place and is immediately scannable.

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

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

For a destructive batch tool, the schema covers quiet, confirm, objects, and governance, while the description adds the concurrency and batch-size framing. The lack of an output schema is mitigated by the quiet parameter documentation, though a one-line note about response behavior would have made it fully complete.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters and their fields. The description only restates the maxItems bound of 1000 objects, adding no new semantic detail beyond the schema baseline.

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

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

The description names a concrete action ('Delete multiple objects') plus the exact resource ('B2 bucket') and an explicit scope bound ('up to 1000 objects'). It is immediately distinguishable from the sibling s3_delete_object, which covers the single-object case.

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

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

The phrase 'multiple objects' and the explicit 1000-object upper bound provide a clear context for batch deletion versus the single-object sibling. It does not explicitly name s3_delete_object or state when not to use the tool, so it stops just short of full routing guidance.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive, lowering the disclosure burden. The description adds useful context about the S3-compatible API and its verification purpose, but does not describe the return payload or failure behavior. This is adequate but not rich.

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

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

Two sentences, front-loaded with the operation and resource, and every clause adds value. The parenthetical and dash clause pack in API family and purpose without any filler.

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

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

For a one-parameter, read-only, idempotent tool with complete schema coverage and rich annotations, the description covers the essential context: API family, purpose, and lack of native alternative. It does not explicitly state the return value, but the operation name and purpose make it mostly inferable.

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 a single required bucket parameter, so the schema fully documents the input. The description mentions 'B2 bucket' and 'location constraint' but adds no 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?

Description opens with a specific verb ('Get') and resource ('region (location constraint) of a B2 bucket'), and distinguishes itself from b2_* siblings by explicitly stating there is no native equivalent. This makes it clearly identifiable among the many S3 and B2 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 provides a clear use case ('verify region/endpoint pairing') and notes that no native b2_* equivalent exists, guiding the agent away from the b2_* family. It does not explicitly name alternatives like s3_head_bucket, so the guidance is useful but not exhaustive.

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 the 1 MiB inline cap, base64 return encoding, streaming behavior via saveToPath, and that the presigned URL path keeps object bytes out of the server/model context. This goes well beyond the sparse annotations and gives an agent a clear behavioral model 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?

Two dense sentences front-load the primary behavior and decision rule, then route to the sibling tool. Every clause earns its place and there is no repetition of schema or annotation content.

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

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

For a 5-parameter tool with no output schema and sparse annotations, the description covers the key facts an agent needs: size limits, return encoding, local streaming, and the correct sibling for real object data. Required parameters remain obvious from the schema, and no critical behavior is left unexplained.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds meaningful usage semantics for saveToPath ('stream any size to a local path') and clarifies that inline reads are limited to small objects returned as base64. It does not elaborate on range or versionId, but those are already adequately described in 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 states a specific verb and resource: 'Read a SMALL object inline' with concrete constraints (≤1 MiB, returned base64) and explicitly contrasts with s3_get_presigned_url. An agent can immediately distinguish this tool from sibling object-access 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?

It explicitly says when to use the inline path (manifests, sidecars, configs), when to use saveToPath for any size, and when to use s3_get_presigned_url for real object data. The exclusion is clear and names the exact sibling alternative.

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, the description adds valuable behavioral context: the URL is a bearer capability, it is short-lived, it should be treated as sensitive until expiry, and B2 does not support presigned POST. The destructive nature of PutObject URLs is consistent with destructiveHint=true, and readOnlyHint=false matches the upload capability. No contradiction exists.

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, each earning its place: the core behavior, the operational advantage and sensitivity guidance, and the critical B2 limitation. The most important information is front-loaded, with 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?

Given no output schema, the description usefully states that the response includes URL, operation, expiresIn, and expiresAt. It also covers the key operational context (direct byte flow, sensitivity, unsupported POST flow) and the tool's role relative to siblings. An agent has enough information to call this tool correctly and interpret its result.

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

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

The input schema provides 100% coverage of all seven parameters, including descriptions, defaults, enums, and constraints, so the description does not need to restate parameter details. The description does add contextual meaning by labeling the URL a bearer capability and mentioning the response fields, but this is not parameter-level semantics. 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 names a specific verb (Generate), a precise resource (short-lived presigned URL bearer capability for one B2 object), and the two allowed operations (GetObject download / PutObject upload). It also distinguishes itself from sibling tools by explaining that bytes flow directly between client and B2 and never through the MCP server.

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

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

The description clearly positions this as 'the preferred path for moving real object data,' giving the agent a direct criterion for choosing it over s3_get_object or s3_put_object. It also explicitly warns that presigned POST is unsupported and instructs to use a PutObject URL instead, but it does not enumerate other alternative tools or when to avoid this 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral context: it operates on the S3-compatible endpoint, checks both existence and reachability, and depends on current credentials. This goes beyond what the annotations convey, though it could mention explicit error/status outcomes.

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

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

Two tight sentences with no filler. The primary purpose is first, followed by a precise usage directive. Every phrase earns its place and nothing needs to be trimmed.

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

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

For a simple one-parameter, read-only tool with full annotations and complete schema coverage, this description supplies all necessary context: what it checks, what credentials it uses, and when to prefer it over a sibling. No missing information blocks an agent from selecting or invoking it correctly.

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

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

Schema description coverage is 100% and the only parameter, 'bucket', is already described as 'The bucket name to check.' The description reinforces this by referencing the bucket but does not add new semantic details such as name format or restrictions. Baseline 3 is appropriate given full schema 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?

States a specific verb ('Check whether') and resource ('B2 bucket') with the precise scope: exists and is reachable on the S3-compatible endpoint with current credentials. It also distinguishes itself from b2_list_buckets, removing any ambiguity with 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?

Explicitly gives the use case: 'Use this to validate S3-surface reachability' and directly names the alternative (b2_list_buckets) that does not cover S3 reachability. This tells an agent exactly when to choose this tool over a similar sibling.

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, idempotentHint=true, and destructiveHint=false, so the read-only safety profile is established. The description adds value beyond those by disclosing that the operation returns metadata only and by listing the response fields (content type, size, last modified, ETag, custom metadata), which is genuinely useful given there is no output schema.

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 with zero filler: the core purpose and differentiator are front-loaded in the first sentence, and the response summary follows directly. Every clause earns its place.

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

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

For a simple metadata-retrieval tool with rich annotations and fully documented parameters, the description is nearly complete, and it partially compensates for the missing output schema by enumerating the returned metadata fields. Minor gaps remain around failure behavior (e.g., 404 for a missing object) and versionId semantics, but these are not blocking for correct invocation.

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

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

Schema description coverage is 100% — bucket, key, and versionId each already carry descriptive entries, so the baseline 3 applies. The description adds no parameter-specific detail, but none is required given that the schema does the heavy lifting.

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

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

States a specific verb and resource ('Get metadata for a B2 object') and the key differentiator 'without downloading it', which distinguishes it from s3_get_object and s3_head_bucket. The second sentence enumerates the response contents, making the tool's scope 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 phrase 'without downloading it' provides clear context for when to choose this tool over the object-download sibling: when only metadata is needed and the body is not. However, no alternative is named explicitly and no exclusionary conditions are stated, so it stops short of the strongest routing guidance.

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 cover the safety profile with readOnlyHint, idempotentHint, and destructiveHint=false. The description adds useful context by specifying 'in-progress' and 'S3-compatible', but it does not disclose that results are paginated through maxUploads/keyMarker/uploadIdMarker, despite saying 'List all'.

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

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

A single sentence with no filler, front-loading the verb and resource. It is as short as possible while still conveying the tool's scope and S3 compatibility.

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?

There is no output schema, but the description never explains the response shape or how pagination works, so an agent cannot fully anticipate what the tool returns. The presence of two 'Pagination cursor' parameters implies paging, but the description gives no guidance on how to traverse pages to actually list 'all' uploads.

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 description adds no parameter-level meaning beyond the schema; 'for a bucket' merely recontextualizes the required bucket parameter. With 67% schema coverage, the missing delimiter and maxUploads semantics are not compensated for by the description.

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

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

The description uses a specific verb ('List') with a clear resource ('in-progress S3-compatible multipart uploads') and a clear scope ('for a bucket'). It distinguishes itself from sibling s3_list_parts, which lists parts of a specific upload, and from b2_unfinished_uploads by emphasizing S3 compatibility.

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 action itself implies when to use it (when in-progress multipart uploads need enumeration), but it gives no explicit alternatives or exclusions. It does not tell the agent to prefer s3_list_parts for a single upload or to use abort/complete operations for finalization, so routing relies on inference.

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 cover the read-only, idempotent, non-destructive behavior, so the description does not need to repeat safety traits. It adds useful functional detail about filtering, delimiter folder views, and pagination, but it does not disclose truncation behavior or the need to follow continuation tokens.

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

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

One well-structured sentence that front-loads the primary action and resource, then lists the key capabilities. Every clause adds information, and there is no redundant or filler content.

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

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

The description, combined with rich annotations and a well-documented schema, gives an agent enough to invoke the tool correctly. It covers filtering, folder-style listing, and pagination; the only notable gap is not explicitly explaining that results can be truncated and require a continuation token, though the word 'pagination' hints at 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?

Schema description coverage is high at 83%, providing a solid baseline. The description goes further by giving semantic meaning to key parameters: 'prefix filtering' maps to prefix, 'delimiter-based folder listings' maps to delimiter, and 'pagination' maps to continuationToken. Only maxKeys lacks prose explanation, though the schema defines its bounds.

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?

Begins with the specific verb-object pair 'List objects in a B2 bucket' and names the exact S3-compatible ListObjectsV2 API. This clearly identifies the operation and distinguishes it from siblings like s3_list_object_versions and s3_list_parts.

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 use cases by mentioning prefix filtering, delimiter-based folder listings, and pagination, but it never states when to choose this tool over alternatives such as s3_list_object_versions or s3_list_parts. There is no explicit when-to-use or when-not-to-use guidance.

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 cover read-only, idempotent, non-destructive behavior. The description adds useful context beyond that by revealing the response includes delete markers and that the bucket must be versioned. It does not describe pagination, error behavior, or response shape, but those are secondary for a safe read operation.

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

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

A single sentence with no filler, front-loaded with the verb and object, and the 'including delete markers' qualifier is placed at the end where it does not interfere with the primary action. Every word 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?

The description plus schema covers the core behavior and parameter meanings, but there is no mention of output structure, pagination behavior, or how the tool behaves on an unversioned bucket. Since there is no output schema and the tool has 6 parameters, these gaps leave some uncertainty 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 description coverage is 67% (bucket, prefix, keyMarker, and versionIdMarker are described; maxKeys and delimiter are not), and the description contributes no parameter-level meaning. An agent gets no help from the description for the undocumented maxKeys and delimiter 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 uses a specific verb ('List'), identifies the exact resource ('all versions of objects in a versioned B2 bucket'), and adds a distinguishing detail ('including delete markers') that separates it from siblings like s3_list_objects_v2. This makes the tool's scope immediately clear.

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 the use case: an agent needs this tool when it wants every version or delete markers rather than just current objects. However, it never explicitly names alternatives like s3_list_objects_v2 or states when not to use this tool, leaving the routing decision to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the description does not need to restate safety. It adds the useful context that the upload must be in-progress, but it does not disclose pagination behavior, response shape, or any error conditions, so it stays at the baseline.

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

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

A single, front-loaded sentence communicates the operation, resource, and required state with no redundant wording. Every word contributes to the agent's understanding.

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

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

For a simple read-only list operation, the description plus schema annotations cover the essential invocation details: the operation, the target resource, and the in-progress state. It does not describe the return object, but a list operation of this kind is still sufficiently callable without that detail.

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 covers 80% of parameters, documentating bucket, key, uploadId, and partNumberMarker, leaving only maxParts without a description. The description does not add meaning to any parameter beyond the schema, so the baseline 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 uses a specific verb ('List'), a clear resource ('parts'), and a scoping condition ('an in-progress S3-compatible multipart upload'). This clearly distinguishes it from sibling tools like s3_list_multipart_uploads, which list uploads rather than parts, and from s3_upload_part_copy.

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

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

The phrase 'in-progress' provides clear context that this tool is for active multipart uploads, implying it is not for completed uploads. It does not explicitly name alternatives or exclusions, but the intended use case is clear enough without additional guidance.

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 reveals that URLs are short-lived bearer capabilities, that the response contains expiresIn/expiresAt, and that each URL should be treated as sensitive until expiry. It also clarifies that the upload happens directly to B2 by the client/worker rather than by this tool. This adds meaningful behavior beyond the annotations 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?

The description is dense but every sentence contributes: purpose, security/expiry behavior, the full multipart flow, and a size constraint. It is front-loaded with the core function before the workflow details. 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?

With no output schema, the description compensates by stating the key response fields (expiresIn/expiresAt) and the required flow with ETags. It covers prerequisites, sequencing, and the part-size rule. The exact response shape mapping part numbers to URLs is not spelled out, but enough context is present for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds workflow-level context and the ≥5 MiB part-size rule, but does not add detailed parameter-level semantics 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 names a specific verb and resource: generating short-lived presigned PUT URLs for parts of an S3-compatible multipart upload. It distinguishes itself from siblings like s3_get_presigned_url by specifying PUT and multipart parts, and clarifies the tool does not perform the upload itself ('client/worker uploads each part DIRECTLY').

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 embeds the tool in a concrete workflow, naming the preceding and following calls and the ETag handoff. It also states a hard constraint ('Parts except the last must be ≥5 MiB'). It does not explicitly name alternative tools or when not to use them, so this is clear context without 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 annotations already mark this as destructive and idempotent. The description adds valuable behavioral detail: passing rules: [] clears the entire lifecycle configuration, and B2 does not support Transition/storage-class rules. This helps an agent avoid invalid or unintended calls.

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, information-dense sentences with no filler. The primary action is front-loaded, followed by clearing behavior and supported/unsupported rule types.

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 schema already documents all parameters and the annotations cover safety behavior, the description adds the essential B2-specific context. The only minor gap is that it does not explicitly state that setting non-empty rules replaces any existing lifecycle configuration, but this is largely implied by the 'set' and 'clear' semantics.

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 meaningful semantics beyond the schema by explaining that rules: [] clears the configuration and by enumerating the supported lifecycle actions. The confirm parameter is not described in the description, but the schema already covers it.

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

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

The description states a clear verb and resource: 'Set S3 lifecycle rules on a B2 bucket.' It also names the supported rule types and the key B2-specific limitation around Transition/storage-class rules, which distinguishes this tool from general S3 mutation 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 clear context: this is the tool for lifecycle configuration on a B2 bucket and it clarifies what rule types are supported. It does not explicitly name sibling tools as alternatives or state when not to use this tool, but the scope is specific enough that the intended use case is clear.

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

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

Annotations already cover read-only status, idempotency, and destructiveness. The description adds useful behavioral context beyond annotations: the 1 MiB size limit, the inline nature of the upload, and the fact that presigned URLs keep bytes from passing through the server. It does not detail overwrite/versioning behavior, but the annotations lower the burden here.

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 compact sentences with no filler. The purpose and size constraint are front-loaded, followed by parameter options and routing to alternatives. 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 high schema coverage, present annotations, and no output schema, the description covers the core decision space well: size threshold, inline vs. presigned, and multipart alternative. It could be slightly more explicit that content or filePath must actually be supplied despite only bucket and key being marked required in the schema, but the imperative 'Provide base64-encoded content or a local file path' substantially mitigates 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 description coverage is 100%, so the schema already documents all nine parameters. The description adds marginal value by clarifying that content is base64-encoded and that either base64 content or a local file path can be provided, but it does not need to compensate for missing schema documentation.

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

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

The description states a specific verb ('Upload'), a specific resource ('a SMALL object inline (≤1 MiB) to a B2 bucket'), and the intended use cases ('manifests, sidecars, and tiny configs'). It distinguishes this tool from s3_get_presigned_url and multipart upload tools, so an agent can tell them apart without opening schemas.

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 states when to use this tool (SMALL inline objects ≤1 MiB) and when not to ('For real object data, generate a PutObject URL... or use the multipart tools for large objects'). It names the specific alternative tools and the condition that selects between them, leaving little to inference.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds contextual detail about assembling large objects without re-uploading, but does not disclose additional behavioral specifics such as failure modes, authentication requirements, or source-destination constraints. It neither contradicts nor substantially enriches 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?

Two sentences with no filler. The action is front-loaded and the use-case rationale follows immediately. Every word 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?

The description and schema together are sufficient for invoking the tool, but since there is no output schema, the description does not explain what the response contains (e.g., the part ETag needed to complete the multipart upload). It also does not explicitly sequence the upload workflow, though uploadId referencing s3_create_multipart_upload implies it.

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

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

Schema description coverage is 100%, so every parameter already has meaningful documentation. The tool description itself adds no parameter-level semantics beyond the schema, which puts this at the baseline of 3.

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

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

The description names a specific verb ('Copy') and resource ('a part from an existing B2 object into an in-progress S3-compatible multipart upload'). This clearly distinguishes it from related siblings like s3_copy_object (whole object copy) and s3_put_object (new data upload).

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 second sentence tells the user when to use this tool: to efficiently assemble large objects from existing parts without re-uploading data. It provides clear context for the multipart upload workflow, though it does not explicitly name alternative tools or state 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.