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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It exceeds expectations by disclosing the write nature, reversibility, risk level, and the critical nuance that MinIO canned policies replace rather than add, potentially narrowing access. It also explains dry_run preview 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?

The description is well-structured with a tag, a purpose line, a behavioral warning, and an Args list. It is slightly verbose but every sentence adds value; the format improves scannability. Minor redundancy exists with the WRITE tag and 'risk=medium', but overall efficient.

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

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

The tool is a straightforward write operation, and the description covers purpose, usage hints, parameter provenance, behavioral quirks, and dry-run capability. No output schema exists, but for an attach operation the absence of return-value details is acceptable. The description is self-contained and contextually rich.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining every parameter: access_key (from iam_users), policies (from iam_policies), dry_run (preview), and target (default if omitted). This adds substantial meaning beyond the raw schema, which only lists names and types.

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

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

The description opens with a specific verb and resource: 'Attach canned policies to a user.' It clearly distinguishes the action from sibling tools like detach_user_policy and mentions reversibility, making the purpose unambiguous. The 'WRITE' tag reinforces the operation type.

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 referencing 'from iam_users' and 'from iam_policies' for argument values, and it warns about a specific risky scenario (narrowing the tool's own access). However, it does not explicitly state when to prefer this over alternatives or provide exclusions, which limits usage 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?

No annotations are present, so the description must fully disclose side effects. It does so by revealing that object lock force-enables versioning, that the result reflects observed rather than assumed state, and that undo deletes the bucket only while empty. These are non-obvious behavioral traits that go far beyond 'create a bucket.'

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

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

The description is front-loaded with a one-line summary and then uses short paragraphs for caveats and a labeled Args section. Every sentence provides actionable information, and the structure makes the content easy to scan 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?

The tool has four parameters, no annotations, and no output schema, yet the description covers purpose, side effects, reversibility, and all parameter semantics. The caveat about the result reporting observed state is a relevant behavioral detail that helps the agent anticipate response variability. The description is complete for the tool's complexity.

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

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

With 0% schema_description_coverage, the description takes on full parameter documentation. It explains all four parameters: bucket_name constraints (3-63 chars, allowed characters), object_lock's permanence, dry_run's preview behavior, and target's default resolution. This adds essential meaning beyond the bare schema titles and defaults.

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

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

The description opens with exactly what the tool does: 'Create a bucket, optionally WORM-capable.' This is a specific verb+resource statement that clearly distinguishes it from siblings like bucket_delete, bucket_ls, and set_* configuration tools. The WORM-capable option is a unique differentiator.

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 that object_lock=True is 'the ONLY way' to get object lock and that it 'Cannot be changed afterwards,' giving clear when-to-use and when-not-to-use guidance. It also notes that undo deletes the bucket only while empty, warning the user about the reversibility condition. This is strong usage direction beyond simple verb definition.

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

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

With no annotations provided, the description carries the full burden and largely delivers. It discloses irreversibility, the emptiness requirement, that noncurrent versions and delete markers count toward emptiness, and the no-mass-delete policy. It doesn't state auth/credential requirements or what happens on non-empty delete (refusal response shape), but covers the critical behavioral traits well.

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

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

Tight, front-loaded: risk tag, one-line purpose with the core safety constraint, then a sentence on preview and emptiness semantics, closing with a compact Args block. No filler or redundancy; every sentence earns its place.

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

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

Destructive tool with no annotations and no output schema. The description covers purpose, conditions, preview behavior, parameter semantics, and the emptiness-check nuance including noncurrent versions/delete markers. Minor gaps: doesn't describe the refusal response or confirm what return value signals success, and no auth/credential notes. Strong but not exhaustive.

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

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

Schema description coverage is 0%, so the description must compensate — and it does. Each of the three parameters (bucket_name, dry_run, target) is given meaningful prose: eligibility/refusal semantics, preview behavior, and config-source. This exceeds what the schema alone conveys despite zero schema-level docs.

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?

Clear verb+resource ('Delete a bucket') with explicit safety condition ('refused unless verifiably empty') and irreversibility warning. The [WRITE][risk=high] tag and detailed first line distinguish it from sibling read-only tools like bucket_ls, bucket_info, and bucket_quota_get, and from policy/versioning setters.

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?

States when to use (delete a bucket) and provides explicit safeguards: refused unless empty, dry_run preview option, and the tool never mass-deletes to force emptiness. Includes bucketing vs alternatives implicitly by being the only delete-bucket sibling. 'Bucket name (from bucket_ls)' provides acquisition 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?

With no annotations provided, the description carries the full behavioral burden. The '[READ]' prefix proactively declares this as a read-only operation, which is important given siblings like bucket_delete and set_bucket_policy are mutations. It also discloses that results are 'ranked' and 'riskiest first', and that a 'cause + action' is provided per finding — meaningful behavioral details beyond a simple audit listing.

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

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

The description is well-structured with a bracketed [READ] tag, a declarative opening sentence stating purpose and ranking, a compact list of audit dimensions, a user-focused use-case line, and a short Args section. It is efficient and front-loaded with the core purpose. Minor redundancy: the ranking fact appears twice ('Ranked... riskiest first' and 'fastest answer'), which is slightly repetitive.

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 audit tool with 0% schema coverage, no output schema, and no annotations, the description does substantial work: it defines the full scope of checks, discloses read-only status, explains parameter semantics, and frames the ranking behavior. It could add clarity on the return format (since there's no output schema) and edge-case behavior around the limit, but these gaps are modest for a straightforward audit tool.

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

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

Schema description coverage is 0%, so the description must compensate. It documents both parameters: 'limit: Maximum buckets to audit (default 100)' and 'target: MinIO target name from config; omit for the default.' The descriptions add the semantic meaning that the schema's bare names (limit, target) lack. However, it doesn't explain the unit or consequence of the limit (e.g., what happens if there are 200 buckets — is only 100 audited, or skipped?), and the target's meaning relies on config context. Adequate but not exhaustive.

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 verb ('scores every bucket') and the resource (bucket-exposure findings), and explicitly defines what it checks: anonymous/public read and write policy statements, missing default encryption, versioning off, and no lifecycle. It positions itself as the fastest answer to an exposure question, distinguishing it from related tools like bucket_policy_get, bucket_versioning_get, etc.

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 states when to use this tool ('the fastest answer to is anything in my object storage exposed?') and enumerates the specific exposure dimensions. It doesn't explicitly name sibling alternatives or state when not to use it, but the audit-vs-single-get distinction is implicitly clear given sibling names like bucket_policy_get and bucket_versioning_get.

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

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

No annotations are provided, so the description carries the disclosure burden. It declares it's a READ operation via the [READ] prefix, which covers the safety profile. It does not disclose potential failure modes (e.g., behavior when bucket doesn't exist or when the user lacks permissions), return format, or pagination, but for a read-only config fetch this is reasonably adequate.

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?

Six tightly-packed sentences in the body plus a short Args block, with the READ intent front-loaded. Every line adds value — the config-facet enumeration, param sourcing, and default behavior. Zero filler or redundancy.

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

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

For a read-only config retrieval tool with two straightforward params and no output schema, the description covers what it returns (six config facets), param sourcing, and default behavior. It could add output-format details but the tool's simplicity and the comprehensive facet list make it largely complete. No annotation or output schema to lean on, so it reasonably carries its weight.

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

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

Schema description coverage is 0%, so the description must compensate. It explains bucket_name (bucket name from bucket_ls) and target (MinIO target name from config, default optional), adding sourcing context beyond the schema's bare property names. This is good but minimal — it doesn't elaborate on value formats or constraints, so it's baseline 3 rather than higher.

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

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

The description states a specific verb+resource ('read one bucket's full config') and enumerates exactly what config is returned: policy, versioning, lifecycle, encryption, quota, tags. This clearly distinguishes it from siblings like bucket_ls (listing) and the individual getter tools (bucket_policy_get, bucket_versioning_get, etc.) which each fetch a single facet.

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 notes bucket_name comes 'from bucket_ls' and target comes 'from config; omit for the default', giving clear input sourcing context. It doesn't explicitly state when to prefer this over the granular getter siblings, but the purpose (full config in one call) strongly implies it's the comprehensive alternative, so only slight elective-guidance is missing.

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

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

No annotations are provided, so the description carries the full burden. The '[READ]' prefix signals this is a non-destructive operation, and it discloses the null-return behavior when no lifecycle is set. However, it doesn't describe pagination, error cases (e.g., nonexistent bucket), or return format details, leaving gaps for a read operation with zero annotation coverage.

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 and efficient, using a docstring format with a one-line purpose and two parameter explanations. No wasted words. It's appropriately sized for a simple two-parameter read operation.

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

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

For a straightforward read operation with 2 simple params, no output schema, and no nested objects, the information provided is mostly adequate. It covers the purpose, the null return case, parameter provenance, and default behavior. However, given zero annotation coverage and no output schema, the description could do more to describe expected return structure or error conditions, especially since sibling tools like bucket_policy_get and bucket_versioning_get exist with similar patterns.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to both parameters: bucket_name is sourced from bucket_ls, and target is the MinIO target name from config with a default behavior. This adds useful context beyond the schema, though the descriptions are brief and don't elaborate on formats or validation constraints.

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

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

The description clearly states it reads the bucket's lifecycle rules, with a specific verb ('read') and resource ('bucket's lifecycle rules'). It also notes the null return when no lifecycle is set, which adds specificity. However, it doesn't explicitly distinguish from sibling tools like set_lifecycle or delete_lifecycle, though the '[READ]' prefix and resource naming make the differentiation fairly obvious.

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 'bucket_name' comes 'from bucket_ls', which gives a clear source hint for the parameter. It also notes 'target' is optional and can be omitted for the default. However, it doesn't explicitly state when to use this versus alternatives (e.g., 'use set_lifecycle to modify, this to read'), nor any exclusions or prerequisites beyond the bucket_ls provenance hint.

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

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

With no annotations provided, the description carries the full burden. It explicitly declares this as a read operation with low risk, and importantly explains the semantic difference between two similar-looking states, which is valuable behavioral context. It does not discuss permissions or error conditions, but for a read-only config inspection the added nuance is substantial.

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

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

The description is well-structured with a lead tag, a clear definition, a helpful nuance explanation, and an Args section. Every sentence contributes useful information, though the two-absence explanation may be slightly long. It is appropriately sized for the tool's complexity.

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

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

Even without an output schema, the description covers the essential return semantics by explaining the two possible absence states. It also mentions both parameters and their origins. It lacks details like error handling or full return structure, but for a simple read operation the provided context is 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 description coverage is 0%, but the description fully compensates. bucket_name is defined as coming from bucket_ls, which helps the agent understand the correct value source. target is explained as a MinIO target name with a default omission behavior. Both parameters are given meaningful usage context beyond their raw schema definitions.

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 retrieves the object-lock (WORM) state of a specific bucket, and it highlights a key nuance between two absence states. However, it does not differentiate from the sibling tool object_lock_status, which may have similar purpose, so it lacks explicit sibling distinction.

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

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

The description provides clear context on when to use this tool: when you need to understand the precise lock state and distinguish between 'never enabled' and 'enabled but no default retention'. It also gives usage details for the target parameter. It does not mention alternatives or exclusions, but the rationale is strong enough to guide appropriate use.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does well by explaining the envelope structure, the truncation flag semantics, and what the side-effect-free '[READ]' nature means. It could add details about pagination behavior or whether sort order is defined, but the truncation warning is valuable behavioral transparency.

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 tightly written with zero wasted words. Each sentence earns its place: the envelope format, the truncation warning, and the parameter explanations. The docstring format with named args is clean and 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 simple list tool with 2 optional parameters and no output schema, the description adequately covers return format, truncation semantics, and parameter meaning. There's no output schema, so the description correctly takes on documenting the return envelope. It's slightly sparse on operational details (e.g., what counts as a bucket, error behavior), but sufficient for its complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains both parameters: 'limit' with a default of 500 and 'target' as the MinIO target name with default behavior. This adds meaningful semantics beyond the raw schema which only lists types and defaults.

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

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

The description clearly states it lists buckets (name + creation time) with a truncation-aware envelope. The '[READ]' prefix and explicit resource naming distinguish it from sibling tools like bucket_info, object_ls, and bucket_quota_get.

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 explains when to re-run with a higher limit when 'truncated' is true, which is important usage context. It doesn't explicitly say 'when not to use' or name alternatives, but the truncation handling is actionable guidance. Sibling differentiation is implicit via the 'buckets' resource focus.

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

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

No annotations are provided, so the description carries the full burden. It labels the tool with '[READ]' and mentions output includes a JSON verbatim copy plus a summary, which is some transparency. However, it doesn't disclose failure modes (e.g., what happens for a missing policy, whether it errors on non-existent buckets), auth permission requirements, or behavior when the bucket has no policy set.

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 - a one-line summary plus clear args documentation. Every sentence earns its place, and the args info is well-structured. No padding or redundancy.

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

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

For a read tool with 2 params, no output schema, and no annotations, the description covers the essentials: what it returns and how to fill the args. It's not fully complete - it omits what happens when no policy exists, whether deleting a policy is a prerequisite, and any permission details for a likely restricted admin operation. But it's adequate for basic invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does provide useful context for both parameters: 'bucket_name from bucket_ls' and 'target: MinIO target name from config; omit for default.' This adds meaning beyond the raw schema, though it doesn't explain value formats or constraints beyond what arg names imply.

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 it reads a bucket's policy JSON and provides an anonymous-access summary - a specific verb (READ) plus resource (bucket policy) and additional output detail. It doesn't explicitly differentiate from sibling get tools (bucket_lifecycle_get, bucket_versioning_get, bucket_quota_get) but the bucket_policy target is self-evident from the name, so the purpose is 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 read-only usage without alternative tool mentions. It provides arg usage context ('bucket_name from bucket_ls', 'target from config') that helps invocation but doesn't explicitly state when to use this vs. other get tools or when not to use it. The 'omit for default' guidance for target is useful.

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

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

With no annotations provided, the description carries full burden. It discloses the '[READ]' nature (safe operation), the admin credential requirement, and the semantics of 0 = unlimited. While it doesn't detail the return format or error behaviors, the disclosure covers the key operational traits for an agent.

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

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

The description is compact—two lines of purpose plus two parameter bullets. Every sentence adds value, and the READ tag plus quota semantics are front-loaded. Zero wasted words.

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

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

For a simple 2-parameter getter with no output schema, the description covers the purpose, credential requirements, parameter sources, and the 0=unlimited semantic. It doesn't explain the return value format, but for a simple quota getter that's reasonably inferable. Adequate coverage for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It provides guidance for both parameters: bucket_name comes from bucket_ls (source hint) and target can be omitted for default. However, it doesn't explain the target format beyond 'MinIO target name from config', which is fairly self-explanatory. The description adds moderate value over the raw schema.

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

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

The description clearly states '[READ] The bucket's hard quota (0 = unlimited)' with a specific verb (get) and resource (bucket quota). It distinguishes from siblings like set_bucket_quota by explicitly marking it as READ, and the name bucket_quota_get clearly differentiates from bucket_info, bucket_policy_get, and other bucket-related getters.

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 admin credentials requirement ('Needs admin credentials'), which is important usage context. It also indicates bucket_name comes from bucket_ls and target can be omitted for the default. It doesn't explicitly say when NOT to use this vs alternatives, but the credential requirement and clear purpose provide adequate context.

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

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

No annotations are provided, so the description carries the full burden. The [READ] tag and 'state' language imply a safe read operation, but it doesn't disclose what happens if the bucket doesn't exist, whether it errors on missing versioning configuration, or what the exact return format is. For a simple read tool this is a moderate gap, and [READ] partially compensates for the missing annotations.

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

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

The description is compact and efficient, using a clear [READ] tag followed by a single-sentence purpose and short Args section. Every sentence earns its place. Could arguably be trimmed further, but it's lean and well-organized.

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 2-param read tool with no output schema, the description covers the essential usage (what it reads, where bucket_name comes from, optional target). However, since there are no annotations and no output schema, the description could add more about the return value structure or behavior for missing buckets. It's adequate but leaves the actual output format unspecified.

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

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

Schema description coverage is 0%, so the parameters (bucket_name, target) are undocumented in the schema. The description's Args section explains bucket_name comes from bucket_ls and target is a MinIO target name to omit for default, which adds useful context. However, the description directly echoes what the schema names already convey and doesn't add format/enum details for the versioning states beyond the three possible values listed.

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 reads a bucket's versioning state with specific verb+resource ('The bucket's versioning state: Enabled / Suspended / Off') and the [READ] prefix clarifies it's a read operation. It's differentiated from siblings like set_versioning (which writes) by the read context, though it doesn't explicitly name the alternative.

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

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

The description implies this is a read/get operation on a bucket's versioning, distinguishing it from set_versioning which modifies. It includes the useful hint that bucket_name comes from bucket_ls (stating a prerequisite source). However, it doesn't explicitly state when to use this vs. sibling versioning tools like set_versioning or bucket_info.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The '[READ]' prefix signals read-only, and the description explains what it folds in and what it returns (ranked findings with next steps). It doesn't disclose potential cost/latency or output format details, but the core behavior is 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?

Well-structured: the description opens with the core purpose, provides when-to-use guidance, lists what it folds in, and wraps up with an Args section. Every sentence earns its place. Slightly verbose with the list of what it folds in, but that list directly informs tool selection, so it's justified.

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 RCA tool with a single optional parameter, no output schema, and no annotations, the description is remarkably complete. It states the tool's purpose, when to call it, what analyses it aggregates, the output format (ranked findings with suggested actions), and the single parameter. This fully equips an agent to decide to use it and 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 has 1 param (target) with 0% coverage in the description. However, the description's Args section does explain 'target: MinIO target name from config; omit for the default,' which adds meaning beyond the bare schema. With only one simple optional parameter and schema coverage at 0%, the description adequately compensates by explaining the parameter's purpose and default behavior.

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?

Clear verb+resource: it performs capacity & usage root-cause analysis, returning ranked findings with cause + suggested action. The first sentence clearly states the purpose. However, it doesn't strongly distinguish itself from siblings like cluster_status or usage_by_bucket, though the '[READ]' prefix and 'RCA' framing add specificity.

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?

Excellent guidance: it explicitly says 'Call this first on any storage is filling up / writes are failing question' and lists exactly what it folds in (capacity vs used, offline drives/nodes, per-drive hotspots, imbalance) into ranked findings. This is explicit when-to-use guidance that helps the agent select this tool appropriately.

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

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

No annotations are provided, so the description carries full burden. It discloses that this is a write operation with medium risk, that it is reversible, and that object lock cannot be disabled via S3. It also clarifies that existing objects keep retention, which is critical behavioral context.

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

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

The description is well-structured with a clear action statement, behavioral notes, and parameter list. Every sentence is informative, including the risk tag and reversibility note, with no fluff.

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

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

The tool has no output schema, yet the description adequately covers the operation's purpose, side effects, and parameters. It could mention error cases or return values, but for a mutation tool with dry-run described, it is nearly complete.

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

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

Schema description coverage is 0%, but the description compensates with a dedicated Args section explaining each parameter: bucket_name (required with object lock enabled), dry_run (preview behavior), and target (MinIO target, default). This adds meaningful semantics beyond the raw schema.

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

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

The description clearly states 'Remove the DEFAULT retention rule' with a specific verb and resource. It distinguishes from siblings like set_default_retention and set_object_retention by specifying it clears the default rule and noting object lock remains enabled.

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

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

The description provides clear context on when to use the tool by explaining the effect: future uploads become unprotected while existing objects retain retention. It also mentions the dry_run parameter for preview, aiding decision-making. However, it does not explicitly name alternative tools or provide 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The [READ] marker signals non-mutating intent, but the description does not explain what the returned summary contains structurally, how the data is aggregated (across which nodes/drives), or whether network timeouts/healing states affect results. For an aggregate read with zero annotation coverage, this is a notable gap.

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 appropriately terse — two compact lines plus a parameter note. The [READ] tag front-loads the operation type, the resource scope is stated, and the parameter doc is inline. No wasted words, though slightly more structure (e.g., what fields the 'summary' contains) would earn a 5.

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 tool with 1 optional parameter and no output schema, the description is mostly adequate. It says what it reports (nodes, drives, capacity, buckets, objects), which helps the agent understand the return content. However, given a rich family of sibling tools (health_*, node_status, drive_status, server_info), the description could more explicitly define its boundary versus those to ensure correct selection. It does not explain return-format details, though no output schema exists to fill that gap.

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

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

With only 1 parameter at 0% schema coverage, the description must compensate. It does explain 'target: MinIO target name from config; omit for the default,' which gives useful semantics about how to select the target and the default behavior. This covers the single parameter adequately, though minimal. A 3 is fair given the guidance provided for the one param.

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 verb ('[READ]') and the resource ('Dashboard-header summary'), listing what it reports: nodes, drives, capacity, buckets, objects. It distinguishes from siblings like drive_status and node_status in that this is a dashboard-header aggregate summary rather than a per-node/per-drive breakdown. Could be slightly more specific about the aggregation nature, but purpose is 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 gives minimal context ('Dashboard-header summary') but offers no explicit when-to-use guidance or exclusions. It does not contrast with closely-related siblings like node_status, drive_status, or server_info, nor does it clarify when to prefer this aggregate tool over those granular ones. There is only the target parameter disambiguation ('omit for default').

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

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

With no annotations, the description carries full burden and covers critical behavioral traits: the secret is redacted and NOT returned, the operation is reversible only by removal, existing access keys have their secrets replaced with no undo, and new users lack policies until attached. It also discloses risk level and write semantics. This is exceptionally 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 front-loaded with the essential purpose, uses a compact header and short paragraphs that each add concrete value (security, upsert semantics, prerequisites), and includes a clearly formatted Args list. It is information-dense without redundancy.

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

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

Given the tool's complexity (4 params, no output schema, no annotations), the description covers purpose, parameter semantics, important security caveats, undo limitations, and the effect on new users. It is complete for safe and correct invocation, leaving no major gaps.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It provides character limits, allowed patterns, redaction notes, dry-run behavior, and target context for each of the four parameters, going well beyond the schema's bare titles.

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

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

The description opens with 'Create or reset an IAM user,' which clearly states the verb and resource. It distinguishes from siblings like remove_user, set_user_status, and attach_user_policy by emphasizing the upsert/reset behavior and the creation of a fresh credential.

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

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

The description provides clear context on when to use the tool (creating a new user or resetting an existing user's secret) and explains the upsert behavior, dry-run preview, and the fact that new users have no policies. It does not explicitly name alternatives or exclusions, but the context is sufficient for selection among siblings.

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

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

With no annotations provided, the description carries the full burden and does well: it flags [WRITE], risk level, states reversibility via undo with prior JSON captured, and implies default-to-private behavior change. The dry_run parameter also provides safety preview behavior. This is strong behavioral disclosure for a tool with zero annotation coverage.

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, leading with the write/risk tag before diving into args. Each line earns its place. The args block is formatted cleanly. Slightly verbose with the reversibility note placement but overall economical.

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

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

For a 3-param tool with no output schema and no annotations, the description addresses the key context: bucket_name source, dry_run behavior, target default, reversibility, and resulting state (private/default). The main gap is not describing what the response/return value looks like, but absent an output schema this is a reasonable completeness level.

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

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

Schema description coverage is 0%, so the description must compensate for param documentation. It does address all three params: bucket_name (from bucket_ls), dry_run (preview without removing), and target (MinIO target from config, default). This adds meaning beyond the bare schema but is terse—just enough description without depth.

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 removes the bucket policy, returning it to private/default state. The verb 'Remove' combined with the specific resource 'bucket policy' and the outcome (back to private/default) provides clear purpose. While there's a sibling 'set_bucket_policy' that would logically contrast, the description doesn't explicitly differentiate from it, just the name implies deletion vs setting.

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 [WRITE][risk=medium] prefix and 'Reversible' note provide context on when it's appropriate to use. The sibling set_bucket_policy exists, and the write/risk markers distinguish this as a mutating operation. However, explicit when-to-use vs alternatives guidance is only lightly implied rather than spelled out.

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

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

No annotations were provided, so the description carries the behavioral disclosure burden. The [WRITE][risk=medium] tags and 'Reversible → prior config' note add meaningful behavioral context about the operation's safety profile. However, it doesn't detail what happens to active lifecycle behavior during/after removal, whether there's a confirmation prompt, or any timing considerations. The reversible note is useful but the risk disclosure is thin for a destructive write 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?

The description is tightly written — a compact header line with [WRITE] and risk tags, a one-line reversal note, and a concise Args block covering all three parameters. No wasted words across roughly 7 lines. Good front-loading of purpose before parameter details.

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

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

For a destructive write tool with 3 params, 0% schema coverage, and no output schema, the description does cover the essentials: purpose, reversibility, and param semantics. However, it lacks detail on post-removal state (does lifecycle revert to default?), confirmation behavior, and error/edge cases. The sibling set_lifecycle exists, making interplay between them relevant, but the description doesn't address ordering or conflicts.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It explains bucket_name (from bucket_ls), dry_run (preview without removing), and target (MinIO target, omit for default). This adds real semantic value beyond the raw schema types and defaults. The only minor gap is it doesn't mention dry_run's default value already in the schema, but that's covered structurally.

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 'Remove all lifecycle rules' with a specific verb (remove) and clear resource (lifecycle rules) and scope ('all'). It distinguishes from siblings like set_lifecycle and bucket_lifecycle_get. Could be a 5 but doesn't explicitly contrast with the sibling that gets lifecycle rules (bucket_lifecycle_get) or the undo_apply sibling.

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

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

The description implies when to use: to delete all lifecycle rules, with a dry_run option to preview. It names 'bucket_ls' as source for bucket_name and notes the target parameter for MinIO config. However, it doesn't explicitly state when NOT to use this vs alternatives like set_lifecycle or undo_apply, though the [WRITE] and risk markers give 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?

With no annotations provided, the description fully carries the transparency burden. It discloses that this is a WRITE operation with risk=medium, that it is reversible via attach, and specifically details a refusal behavior for its own credential with a clear rationale. This goes beyond typical transparency.

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 well-structured: a tag line, a one-sentence purpose, a focused warning, and a clean argument list. Every sentence provides necessary information without fluff.

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

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

For a relatively simple tool with no output schema, the description covers the operation, safety, reversibility, self-refusal caveat, and full parameter semantics. It is complete enough for an agent to successfully invoke the tool in most scenarios.

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

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

Schema has zero description coverage, but the description explains every parameter: access_key and policies are sourced from iam_users, dry_run provides a preview, and target defaults to config default when omitted. This adds significant semantic meaning beyond the raw 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?

Clearly states the action: 'Detach canned policies from a user.' The verb is specific and the resource is unambiguous. It also distinguishes from the sibling attach_user_policy by noting 'Reversible → attach.'

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 reversibility note explicitly points to attach_user_policy as the inverse operation, implying usage context. It also warns against using this tool on its own credential. It does not explicitly list alternative tools for different scenarios (e.g., bucket policies), but the sibling set makes the intent 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?

With no annotations, the description carries full behavioral burden. It does well by explaining group-inherited policy resolution, the MinIO default-deny interpretation of NO_EFFECTIVE_POLICY, finding categories, and worst-first sorting. It does not cover all possible behaviors such as error cases or rank scale details, but for a read-only diagnostic it is suitably 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 well-structured and front-loaded with [READ][risk=low]. It efficiently covers purpose, key behavioral caveats, finding list, sorting, and parameter semantics without unnecessary filler. Every sentence carries informational weight.

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 there is no output schema, the description admirably explains return content through finding categories, sorting, and truncation behavior. It also addresses complex IAM nuance. The only minor gap is not specifying the output envelope/rank format more concretely, but the description is still complete enough for tool selection and basic invocation.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It does: limit is described as 'Maximum findings to return (envelope reports truncation)' and target as 'MinIO target name from config; omit for the default.' This adds meaningful guidance beyond the bare schema defaults.

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

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

The opening line 'Ranked IAM findings: admin sprawl and unusable accounts' clearly identifies the tool's resource (IAM) and specific scope (admin sprawl and unusable accounts). It distinguishes itself from sibling tools like iam_users and iam_policies by emphasizing ranked findings and specific finding categories.

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 strong context for when the tool is appropriate (IAM exposure diagnosis, admin sprawl, unusable accounts) and explains key behavior like resolving group-inherited policies. However, it does not explicitly state when not to use it or name alternative tools, so it stops short of full guideline clarity.

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

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

With no annotations, the description carries the full disclosure burden. It states the read-only nature, low risk, and importantly explains that failed probes are reported in bucketErrors rather than skipped, so a clean findings list does not imply clean buckets. It also discloses reporting of day counts and mode-choice consequences.

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

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

The description is front-loaded with READ/risk and a one-line summary, then organized into behavioral bullets and an Args block. It is a bit long but every section adds necessary detail; nothing feels redundant.

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

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

There is no output schema, so the description must hint at return behavior. It mentions envelope truncation, bucketErrors, both day counts, and the contradiction types, which is sufficient for a diagnostic tool. It doesn't fully specify the response shape, but the provided context is adequate.

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

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

The schema provides no descriptions for limit or target (0% coverage), but the Args section fully compensates: limit caps findings and notes envelope truncation, while target selects the MinIO target and defaults when omitted. This adds meaningful semantics beyond the raw 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 tool as a read-only diagnostic that finds WORM/retention gaps across every bucket, sorted worst-first, and enumerates specific contradiction types. It does not explicitly contrast with the similar sibling lifecycle_gap_analysis, but the scope and focus are distinctive enough.

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 when you need to diagnose retention/WORM gaps, supported by the '[READ][risk=low]' prefix and the list of checks. However, it provides no explicit when-to-use vs. alternatives or exclusions, so only implied guidance is present.

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 a key behavioral trap: a non-null error means metrics scrape failure, distinct from a server with no drives, warning not to report empty list as healthy. It also specifies the return shape {"drives": [...], "returned": N, "error": ...}. With no annotations provided, this disclosure is essential and it delivers.

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 and front-loaded with the purpose in the first line. Every sentence earns its place — return shape, error semantics, and parameter explanation. The Args section is slightly verbose but clear. No wasted words.

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

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

For a read-only status query with a single optional parameter, the description explains the return format, error handling, and sort order. It lacks pagination details and doesn't specify what 'default target' resolves to, but given the tool's simplicity and no output schema, this is reasonably complete.

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

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

Schema description coverage is 0% with one optional parameter (target) plus default null. The description adds meaning for this single param ('MinIO target name from config; omit for the default'), which is useful. With only one trivial parameter that has a sensible default, schema carries minimal burden and the description covers it adequately.

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 [READ] tag plus 'Per-drive rows (server, drive, used ratio), fullest first' gives a specific verb+resource+scope. It clearly describes what data is returned and the sort order, distinguishing it from sibling node_status/cluster_status which cover different scopes.

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

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

It provides clear context ('fullest first') and importantly explains the error semantics — that a non-null error indicates a scrape failure, not an empty result. This is a critical usage caveat. It doesn't explicitly name alternative tools for when not to use this, but the error-handling guidance is valuable context.

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

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

No annotations are provided, so the description carries full weight. It does declare the tool is [READ] (non-mutating), which is valuable behavioral context. However, it doesn't disclose response format/size, potential latency of a 'one-shot' overview across endpoints, or any auth/credential requirements. The read-only disclosure is good but coverage is partial.

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

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

Exceptionally tight and well-structured. A clear [READ] tag, a single-line summary of what it returns, a usage directive, then the Args section. Three short sentences, zero filler, all earning their 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 one-param read-only overview tool with no output schema and 0% schema coverage, this description covers purpose, usage timing, read-only nature, and the parameter. What's missing is a hint about output richness (does it include per-endpoint breakdowns?), but for the tool's simplicity the coverage is quite good. The read-only marker and target param explanation address the main ambiguity points.

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

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

Schema description coverage is 0%, so the description must compensate. The single 'target' param is explained: 'MinIO target name from config; omit for the default.' This clarifies it's optional, where it comes from, and the omit behavior. Good compensation for a tool with one optional parameter.

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

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

The description clearly states it's a 'one-shot deployment overview' covering 'health + capacity + exposure headline' with an explicit [READ] marker. It doesn't explicitly distinguish from siblings like fleet_scope and fleet_region, though the word 'overview' and combination of health/capacity/exposure implies a scope beyond those. Purpose is specific and 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?

Explicitly provides usage guidance: 'Call this first on any broad how is my object storage doing question.' This tells the agent precisely when to use it and frames it as an entry point for broad queries, distinguishing it from more granular sibling tools. Strong 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 [READ] prefix signals read-only behavior, though no formal annotations are provided to corroborate. It discloses what the tool reports (drive counts vs quorum, healing status, backlog/errors) and describes output as 'plain-language findings', which gives some behavioral context beyond the schema. However, it doesn't describe failure modes, prerequisites, or what happens with a misconfigured target.

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 statement, then details what it reports, then documents the parameter. The list of reported items (online drives vs quorum, healing drives, backlog/errors) is functional but could be more concise without losing value. Nearly every sentence earns its place.

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

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

For a diagnostics/read tool with a single optional parameter and no output schema, the description adequately covers what gets evaluated and in what form (plain-language findings). It could note prerequisites (e.g., requires MinIO to be reachable) but the high context coverage makes the description reasonably complete for its complexity.

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

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

Schema coverage is 0%, but there's only one optional parameter (target). The description explains 'target: MinIO target name from config; omit for the default', which fully covers the single parameter's semantics. Baseline 3 is appropriate since the one param is well-documented but the description doesn't add much beyond what the schema field name implies.

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 explains this tool assesses healing backlog and erasure-set write-quorum risk, answering a concrete question ('how many more drive failures can I take?'). It clearly distinguishes from siblings like drive_status and node_status by focusing on failure tolerance and healing risk specifically.

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 frames usage context—answering drive-failure tolerance questions and reporting per-erasure-set healing status. It doesn't explicitly state when NOT to use it or name alternatives (e.g., drive_status for raw drive health), but the purpose framing strongly implies when it's appropriate.

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 that this is a READ operation and that a 503 status signals degraded state, which is useful. However, with no annotations provided, the description carries the full burden but doesn't fully disclose behavior—it doesn't say what happens on degraded clusters, whether it blocks/fails, or what the 'overall healthy verdict' logic is beyond combining liveness/readiness.

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 and front-loaded with the [READ] tag and resource path. It provides the key purpose in the first line and parameter docs in an Args section. Minor redundancy exists (the 'healthy' verdict is mentioned twice), but overall it's tight.

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

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

For a single-parameter read tool with no output schema, the description covers the essential purpose and param. However, given the presence of closely-related siblings (health_live, health_ready, cluster_status, fleet_overview), more guidance on the exact distinction and what the structured answer contains would improve completeness.

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

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

Schema coverage is 0%, so the description must compensate. It does explain the 'target' parameter ('MinIO target name from config; omit for the default'), which adds meaning beyond the bare schema. This is helpful but minimal—it doesn't clarify what a target name looks like or how it's resolved against config.

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

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

The description clearly states it clusters write-quorum health from /minio/health/cluster (503 = degraded), with a specific verb+resource. It distinguishes from siblings like health_live/health_ready by noting it combines them into one structured answer. However, it doesn't explicitly differentiate from closely-related siblings like health_live, health_ready, cluster_status, or fleet_overview beyond the 'combined' note.

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 it's for checking overall cluster write-quorum health and mentions combining liveness/readiness, which helps distinguish it. However, it doesn't explicitly state when to prefer this tool vs. the sibling alternatives (cluster_status, fleet_overview, health_live, health_ready), leaving the agent to infer the right 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?

With no annotations provided, the description carries the burden. It does disclose that this is a READ operation and unauthenticated, which is meaningful behavioral context. However, it doesn't disclose return format, what a live vs down response looks like, or what happens on failure, which would help the agent interpret results.

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—a single title line plus a short parameter note. It's front-loaded with the key information ([READ], endpoint) and wastes no words. Efficient and appropriately sized for a simple single-parameter tool.

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

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

For a simple liveness probe with one optional parameter and no output schema, the description is mostly adequate. However, it lacks any mention of what the return value looks like or how to interpret success/failure, and given the many sibling health/status tools, slightly more differentiation context would be valuable.

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 mentions the target parameter ("MinIO target name from config"), which adds a small amount of context beyond the schema. However, schema description coverage is 0%, yet the description does explain the one parameter's purpose. Since there's only one optional parameter and it's briefly described, this is adequate but minimal.

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 "Node liveness probe" with the specific endpoint "[READ] /minio/health/live", clearly indicating a read-only health check. It distinguishes somewhat from siblings like health_ready and health_cluster by specifying the exact endpoint, though it doesn't explicitly contrast with these neighboring health probes.

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 notes it's a liveness probe and mentions the target argument, but it doesn't explicitly state when to use this tool vs health_ready, health_cluster, node_status, or other health-related siblings. The unauthenticated qualification provides context but no 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?

The '[READ]' label indicates a read-only operation, and it notes the endpoint is 'unauthenticated', which is useful behavioral context. However, with no annotations provided, the description carries the burden of behavioral disclosure — it doesn't describe response format, latency expectations, or what 'ready' indicates about system state beyond the endpoint name itself.

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

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

Extremely concise — roughly two short sentences. Front-loads the key info ([READ], endpoint path, unauthenticated). No wasted words. The Args section is minimal but 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?

For a simple one-parameter, no-output-schema health probe tool, this is near complete. It identifies the endpoint, auth status, read-only nature, and parameter semantics. However, it's unclear whether the response indicates overall cluster health vs single node health, and no annotation coverage means the description should probably convey a bit more about what the caller should interpret from a positive/negative 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 0%, so the description technically carries the burden for the single optional 'target' parameter. The description says 'MinIO target name from config; omit for the default' which adds meaning about how/why to use the parameter. But it's a single optional parameter with a default of null, and the description is adequate rather than enriched.

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 it's a '[READ] Node readiness probe' hitting '/minio/health/ready'. The verb+resource is present and clear. However, it doesn't distinguish itself from related siblings like health_live, health_cluster, or node_status — 'ready' vs 'live' vs 'status' distinction is not explained, so it loses some clarity points versus siblings.

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

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

No guidance on when to use this vs health_live (readiness probe) vs node_status or health_cluster. It doesn't state what readiness specifically means or when a readiness check is preferred. The only usage hint is the optional target parameter, which is a parameter not a usage guideline.

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 embeds '[READ][risk=low]' tags and explains that groups whose reads fail are placed in groupErrors rather than dropped, and that the envelope reports truncation when the limit is reached. This provides meaningful behavioral context beyond the bare schema, though it does not disclose permission requirements or the exact response envelope structure.

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 and well-structured: a brief read-risk tag, a one-line summary, a behavioral note, and a bulleted arg list. Every sentence adds information without padding.

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 tool with no output schema, the description explains what is returned (IAM groups with members and policies), how failures are handled (groupErrors), and how the limit affects truncation. This is sufficient for an agent to invoke the tool correctly, though it could be more explicit about the response envelope format.

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

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

The input schema has no descriptions for either parameter, so the description provides the only semantic information. It explains that 'limit' is the maximum number of groups to return and that truncation is reported in the envelope, while 'target' selects a MinIO target from config and can be omitted for the default.

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

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

The description clearly identifies the tool as returning IAM groups with their members and attached policies, preceded by a '[READ]' tag indicating it is a read operation. This distinguishes it from sibling tools like iam_users and iam_policies, though it lacks an explicit verb like 'list' or 'get'.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as iam_policies or iam_users. It only mentions the target argument for configuration, which is not usage 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 includes '[READ][risk=low]' and explains behavioral details: the limit parameter causes envelope truncation reports, and target can be omitted for the default. These go beyond the bare schema and provide useful context, though no annotations are present to verify safety.

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

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

The description is extremely concise: a one-line noun phrase plus a two-item argument list. Every word carries meaning, and the structure is front-loaded with the read/risk indicator. No filler or repetition.

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

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

For a simple list tool, the description covers the essential behaviors (read-only, limit behavior, target selection). However, it does not explain the return format or the meaning of 'envelope', and there is no output schema to compensate. It is adequate but minimal, missing some context an agent might need.

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?

Both parameters are clearly explained beyond the schema. For 'limit', it states it controls the maximum number of policy names and mentions truncation reporting. For 'target', it explains it's a MinIO target name from config and that omitting uses the default. This fully compensates for the 0% schema description coverage.

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

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

The description clearly identifies the resource as 'canned policy names defined on the deployment', which distinguishes it from sibling IAM tools like iam_users and iam_groups. However, it lacks an explicit verb like 'list' or 'return', making the action implicit rather than stated.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or scenarios where a different tool (e.g., iam_users) would be more appropriate. The usage context is only implied by the read-only nature.

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

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

With no annotations provided, the description carries the full burden. It discloses the read-only nature via '[READ][risk=low]' and adds valuable context that the root credential is never listed as an IAM user, explaining why an empty list is not a failure. It also mentions truncation reporting for the limit parameter. This is good transparency for a simple read tool, though it does not detail response format or pagination beyond the truncation note.

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 and well-structured. It front-loads the read/risk status, gives a one-line summary, then the root credential note, and finally the Args section. Every sentence serves a purpose, with no redundancy or filler.

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

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

For a simple list tool with 2 parameters and no output schema, the description covers the core aspects: purpose, edge case (root user), and parameter semantics. It lists the returned fields (status, attached policies, group membership) but does not elaborate on their structure. Given the lack of an output schema, this is adequate, though slightly more detail on the response envelope could be helpful.

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

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

Schema coverage is 0%, so the description must compensate. It does so effectively by explaining both parameters: limit as a maximum with truncation reporting, and target as a MinIO target name that can be omitted for default. These explanations add meaning beyond the bare type/default information 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 clearly indicates this is a read operation for IAM users, listing status, attached policies, and group membership. The resource is specific, but the verb is implied via the [READ] tag rather than stated explicitly (e.g., 'List'). It distinguishes from sibling tools like iam_groups and iam_policies by focusing on users with their associated attributes.

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 does not explicitly state when to use this tool versus alternatives such as iam_groups or iam_policies. It provides no exclusions or comparative guidance. The note about root credentials is an interpretive edge case, not usage direction. Only parameter-level instructions (e.g., omitting target for default) are given.

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

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

No annotations are provided, so the description carries the disclosure burden. The '[READ]' tag and the return-envelope format description add behavioral transparency, and the 'initiated time null' caveat about data provenance is useful. However, it doesn't disclose pagination cursor behavior, rate limits, or whether results are ordered/deterministic.

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?

Compact and front-loaded with the [READ] tag and purpose in the first line, followed by a return-format explanation and per-arg documentation. The args section is organized and readable. Slightly verbose in the return-format section but no wasteful 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 tool has no output schema, so explaining the return envelope ('truncated', 'returned', 'limit') in the description is valuable. The per-argument documentation covers the 4 params at 0% schema coverage. The truncation-re-run guidance handles the edge case well. Could benefit from noting expected sort order or how it relates to object_ls, but it's fairly complete for a listing tool.

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

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

Schema description coverage is 0%, and there are 4 parameters, so the description must compensate. It does explain each parameter inline (bucket_name from bucket_ls, prefix for key filtering, limit for max uploads, target as MinIO target name from config). This fully covers all 4 parameters' semantics and even adds defaults, though the default values already exist 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?

Clear verb+resource: lists in-flight/abandoned multipart uploads. The '[READ]' prefix signals non-mutating behavior, and the description distinguishes this from sibling tools like remove_incomplete_uploads (which mutates). The title/name align perfectly with the described 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?

The description explains the truncation envelope and instructs re-running with a higher limit when truncated=true. It references bucket_name 'from bucket_ls' as a source for the argument, providing linkage to sibling tools. However, it doesn't explicitly contrast with remove_incomplete_uploads or object_ls when deciding which to call.

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

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

No annotations provided, so description carries full burden. '[READ]' prefix explicitly signals read-only operation, which is valuable given many siblings are mutation tools (set_lifecycle, bucket_delete, etc.). Discloses that it produces a cause + action analysis with reclaimable estimate. Would benefit from noting it performs network calls to list buckets, but overall disclosure is good.

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?

Compact and front-loaded with the '[READ]' tag and one-line summary before the Args block. The three gap categories are enumerated cleanly. The trailing 'Args' section adds marginal value since it partially restates schema, but the space cost is low. Efficient overall.

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 analysis tool with 2 simple params, the description covers the core: output type (per-bucket gaps), the three gap kinds, reclaimable estimate, cause + action. No output schema exists, so some description of return richness would help, but the enumerated gap types give the agent enough to interpret results. Slightly incomplete on output format 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 0%, so description must compensate. It explains both params ('limit: maximum buckets to analyze', 'target: MinIO target name from config'), which is genuinely useful. However, description falls to the score-2 level because limit's default semantics and target's fallback behavior are only minimally explained; target says 'omit for the default' but doesn't clarify what the default is. Slight improvement over nothing but still thin.

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?

Specific verb ('finds') + resource ('ILM gaps per bucket') + clear scope. Distinct from siblings: it's an analysis tool that identifies lifecycle gaps (no noncurrent expiry, incomplete multipart no-abort rules, no lifecycle at all) rather than a status check or configuration action. Clearly differentiates from get/set lifecycle 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?

Describes what conditions trigger use (detecting stale bytes, invisible space from incomplete multipart, missing lifecycle) through enumerated gap categories. Doesn't explicitly name sibling alternatives, but the three specific gap scenarios make when-to-use clear. No explicit when-not-to-use, but context is reasonably established.

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

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

No annotations are provided, so the description carries the full burden. The [READ] prefix signals a read operation—helpful—but it does not disclose behavior like whether it requires admin privileges, how it behaves when nodes are unreachable, what 'drive counts' entails, or whether it aggregates across targets. This is thin for a no-annotation tool.

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

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

The description is compact and efficient—a one-line purpose plus a single parameter explanation. The [READ] tag and bold lead-in pack utility into minimal bytes. Slight room for improvement in front-loading the purpose more prominently, but it's 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 simple read tool with a single optional parameter, the description is mostly adequate. It conveys the node-level scope and the target parameter behavior. Gaps: no output schema to describe return values (though it's a leaf info tool, so low risk), no mention of admin/permission requirements, and no differentiation from similar health/status siblings. Given the minimal complexity, this is near-sufficient but with clear gaps.

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

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

Schema description coverage is 0%, so the description must fully explain the 'target' parameter. It does state 'target: MinIO target name from config; omit for the default,' which adds meaning beyond the schema (which only says string/null with a null default). However, it doesn't explain where targets come from, whether the default is the primary/current target, or behavior if an invalid target is given.

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

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

The description clearly states it's a node-level view showing online/offline nodes plus per-node drive counts, using a specific verb ('view') tied to a concrete resource (nodes). It distinguishes from drive_status and cluster_status siblings by explicitly saying 'node-level', though it doesn't name alternatives 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 implies usage context (node-level vs cluster/drive level) through the '[READ]' label and node-focused framing, but does not explicitly state when to use this vs drive_status or cluster_status, nor when not to use it. The guidance is implied by the node-scoping rather than stated.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It explicitly labels the operation as [READ][risk=low], states the report nature, and explains the independent stacking of retention and legal hold. This goes beyond a simple one-liner, though it does not disclose details like error behavior or return format, keeping it just shy of a 5.

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

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

The description is well-structured and front-loaded: a tag line, a clear purpose statement, a behavioral note, and then a concise Arg list. Every sentence carries necessary information with no redundancy. It is appropriately sized for a 4-parameter read-only tool.

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

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

The description is adequate for a read-only status tool, covering purpose, parameter semantics, and key behavioral nuance. The absence of an output schema means the description should ideally hint at the return value, and it does mention 'reports whether deletable and what blocks it,' but it does not elaborate on possible blockers or error cases. Overall, it is complete enough for the tool's simplicity, but not exhaustive.

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

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

The schema has 0% description coverage, so the description fully compensates by explaining every parameter in the Args section. It tells where to obtain bucket_name and object_name (from other tools), clarifies that version_id selects a specific version with omission meaning current, and explains target as a MinIO target with a default. This adds significant meaning beyond the raw schema.

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

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

The description clearly states that the tool reports whether an object version is deletable and what blocks it. The phrase 'Retention + legal hold for one object version' and 'Reports whether the version is deletable right now and what blocks it' uses a specific verb (reports) and resource (object version), fully distinguishing it from sibling setter tools like set_object_retention and set_legal_hold.

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 tool is used to check lock status (e.g., before deletion) but does not explicitly state when to use it vs alternative tools. It explains the behavioral nuance of independent stacking, but lacks explicit guidance such as 'use this to inspect before modifying locks' or 'instead of diagnose_retention_gaps for this specific object version.' Usage context is implied rather than expressly stated.

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

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

No annotations are provided, so the description carries the full burden. It clearly discloses truncation behavior, explains that 'lastModified' and 'versionId' can be null, and describes the return envelope structure. It also signals the read-only nature with [READ]. Minor gap: doesn't discuss auth/permission requirements, but the return-format disclosure is strong.

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?

Well-structured with a leading [READ] tag, return envelope preview, behavioral warning paragraph, then a clean Args block. Every sentence earns its place—no filler, front-loaded with the most critical information about truncation.

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 listing tool with 4 params, this is quite complete. It covers the return format, truncation semantics, null field behavior, and all parameter meanings. It lacks an explicit example call and doesn't mention ordering/sorting behavior, but the essential usage context is well covered.

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

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

Schema description coverage is 0%, so the description must compensate fully. It does: bucket_name is explained (from bucket_ls), prefix 'Key prefix filter; empty for whole bucket', limit has min/max AND default stated, and target explains it's a MinIO config target with omit-for-default guidance. This adds meaning beyond the bare schema definitions.

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

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

The description states a specific verb+resource: 'Objects under prefix in a truncation-aware envelope'. It clearly distinguishes from siblings like bucket_ls (bucket listing vs object listing). The [READ] tag and the explicit note about never being a full walk add precision.

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

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

The description gives explicit guidance on when to use and how to behave: if truncated is true, it's the normal case and the agent should 're-run with a higher limit or a narrower prefix instead of treating the page as the whole bucket'. This is actionable if-then 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?

No annotations are provided, so the description carries the full burden. It discloses the destructive nature ('no undo', 'parts themselves are unrecoverable once aborted'), the [risk=medium] marker, the age-based protection, and what priorState records. It doesn't mention authentication/permission requirements, but the core behavioral risks are fully disclosed.

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

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

The description is compact and front-loaded with a bold imperative line, then a concise behavioral warning, then a clean Args section. No wasted prose. Slightly longer than strictly necessary due to the priorState detail, but that adds genuine value for a destructive operation.

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

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

For a destructive mutation tool with no annotations and no output schema, the description covers the essential risk profile, parameters, safety guardrails, and state side-effects. Could add permission requirements, but for a 4-param tool with 0% schema coverage this is a strong, near-complete package.

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

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

Schema description coverage is 0%, so the description must carry all parameter meaning. It does: bucket_name (from bucket_ls), older_than_days (0=all), dry_run (preview without aborting), and target (MinIO config target, omit for default). Each of the 4 params gets meaningful explanation beyond raw names.

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+resource ('Abort abandoned multipart uploads (reclaims their parts)') and clearly scopes what it does. It distinguishes from the read-only sibling `incomplete_uploads_ls` by framing this as the destructive write counterpart. It doesn't name a sibling explicitly, so not a full 5.

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

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

The description explicitly states the age guardrail ('Only uploads at least older_than_days old are touched (default 7), protecting in-flight uploads') and provides a dry_run preview path ('preview the matching uploads without aborting'). It's clear when to use it and how to safely preview before committing.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure and does so excellently. It clearly warns that deletion is IRREVERSIBLE, explains that MinIO retains no recoverable copy of the secret, and describes priorState capturing status/policy attachments for potential reconstruction. The dry_run behavior and self-credential refusal are also disclosed, providing comprehensive transparency.

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

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

The description is well-structured, front-loading the critical warning about irreversibility and risk. It efficiently covers all key behavioral aspects and parameter details without redundancy. The use of a brief Args block for parameters maintains clarity and scannability.

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

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

Given the tool's destructive nature and lack of output schema, the description provides a remarkably complete picture: it explains the irreversibility, what priorState captures, how dry_run works, and a specific error condition. This covers the essential operational and safety context needed by an AI 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?

The schema provides only names and types with no descriptions (0% coverage), so the description fully compensates. Each parameter is explained with meaningful context: access_key is sourced from iam_users, dry_run executes guards without deleting, and target refers to a MinIO config name with a default omission. This added meaning is essential for correct use.

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

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

The description explicitly states 'Delete an IAM user' with a clear verb and resource. It distinguishes the tool from siblings like create_user and set_user_status by highlighting the deletion and irreversibility. The additional context about the credential removal makes the purpose unambiguous.

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

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

The description provides clear context for when to use the tool (delete an IAM user) and includes important constraints such as refusal when targeting its own credential and the use of access_key from iam_users. However, it does not explicitly mention alternatives or when NOT to use this tool, falling short of a score of 5.

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

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

No annotations are provided, so the description carries the full burden. The [READ] tag effectively communicates read-only behavior, and the admin credentials requirement is disclosed. However, it doesn't detail what happens if credentials are insufficient, what the response format looks like, or any rate limits/failure modes—modest but not critical gaps given the simple nature of the 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?

The description is compact and front-loaded, with the core purpose stated first, then the credential requirement, then parameter details. No wasted words. The only minor critique is that the [READ] tag formatting is slightly unusual, but it communicates 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 simple tool with 1 optional parameter and no output schema, the description covers the core essentials: what it returns at a high level, the credential requirement, and parameter semantics. It could be more complete by describing the output shape or naming the specific admin fields, but given the low complexity, this is a reasonable level of coverage.

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

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

Schema description coverage is 0%, so the description compensates by explaining the 'target' parameter: 'MinIO target name from config; omit for the default.' This fully explains the parameter's purpose and default behavior, covering the only parameter in the schema. This is sufficient semantic guidance.

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

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

The description clearly identifies the tool as 'Admin server info' with a [READ] tag, and specifies it returns mode and servers/pools summary. It's distinguished from siblings like drive_status, node_status, and cluster_status by naming the specific scope (server-level info + pools summary). However, it doesn't name alternative tools for positioning.

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 notes 'Needs admin credentials,' which is a clear prerequisite/usage constraint. The [READ] prefix implies it's for inspection rather than mutation, distinguishing it from write tools. It gives the context for when to use it (admin server info) but doesn't explicitly state when NOT to use it or name alternative tools for related queries.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does so excellently. It discloses mutability (WRITE), reversibility ('prior policy JSON'), the risk of making a bucket public, and a subtle failure mode: it refuses policies whose explicit Deny on s3:PutBucketPolicy covers the tool's own access key, explaining why via 'an explicit Deny beats every Allow' and noting it is enforced even under dry_run. This is rich, beyond-schema 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?

Efficiently front-loaded with a bracketed WRITE/risk tag, a one-line summary, and a reversibility note. The behavioral caveats are justified and the Args section is compact and clean. No wasted 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?

A mutation tool with no annotations, no output schema, and four parameters—yet the description covers purpose, risk, reversibility, a failure-refusal edge case, the dry_run interaction, and all parameter semantics. It is complete for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate for the schema, and it does for three of four parameters: bucket_name ('from bucket_ls'), policy_json ('must contain Statement'), dry_run ('preview without applying'), and target ('MinIO target name from config; omit for the default'). Every parameter is explained, adding meaning the bare schema lacks.

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?

Clear verb+resource: 'Replace the bucket policy.' It explicitly frames this as a WRITE operation of medium risk and distinguishes it from the sibling delete_bucket_policy and bucket_policy_get. The reversal note ('prior policy JSON') and the public-exposure warning further sharpen the 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?

The description states when to use it (replace a bucket policy) and gives an actionable follow-up ('check bucket_exposure_audit after changing policies'). It doesn't explicitly contrast with siblings beyond delete_bucket_policy/policy_get, and doesn't state when not to use it, but provides clear operational context and caveats.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does well by declaring [WRITE] with risk=medium, stating reversibility, and noting the admin credential requirement. However, it doesn't disclose what the response looks like, whether effects are immediate/propagated, or the error behavior. The dry_run flag adds valuable transparency for a mutating 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?

The description is tightly organized with a header line for risk/reversibility, a credential note, and a clean Args block where each parameter gets exactly one line of explanation. No wasted words; every sentence earns its place.

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

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

For a 4-parameter write operation with 0% schema coverage and no output schema, the description covers the key behaviors: how to clear via 0, the dry_run safety mechanism, credential requirements, and reversibility. It lacks return-value details and edge-case behavior, but for a quota-setting tool with dry_run safety, this is reasonably complete.

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

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

Schema description coverage is 0% and there are no enums to help, so the description must compensate. It does: bucket_name specified as 'from bucket_ls', size_bytes clarified as '0 clears', dry_run explained as 'preview without changing', and target explained as 'MinIO target name... omit for default'. This adds meaning far beyond the bare schema types.

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 with a specific verb+resource ('Set or clear the bucket hard quota'), explicitly notes both operations (set >0, clear 0), and distinguishes it from siblings like bucket_quota_get, set_bucket_policy, and set_versioning by focusing specifically on quota as the resource. The operation is unambiguous.

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

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

The description explicitly notes credential requirements ('Needs admin-capable credentials') and includes a dry_run capability for previewing changes. It implies context for when to use vs quota_get but doesn't explicitly name alternative tools or state when not to use. The [WRITE] tag and admin requirement serve as effective usage gating.

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 [WRITE][risk=high] tag and detailed explanation of reversibility, the exception that objects written under COMPLIANCE cannot be shortened, and the refusal condition when no object lock provide comprehensive behavioral disclosure beyond the schema and annotations (which are absent).

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

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

The description is well-structured with an intro line and an Args section, every sentence carries critical info, no redundancy.

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

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

Given the tool's complexity and the absence of an output schema or annotations, the description covers all important behaviors, prerequisites, and side effects, making it essentially self-contained.

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

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

Scores 5 because the description compensates for the 0% schema coverage by explaining every parameter: bucket_name requires object lock, mode explains GOVERNANCE vs COMPLIANCE semantics, days/years mutual exclusivity, dry_run preview, and target for MinIO config.

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?

Clearly states 'Set the bucket's DEFAULT retention' with a specific verb and resource. The term 'DEFAULT' distinguishes it from object-level retention tools like set_object_retention.

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

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

Provides clear context: applies to newly written objects, requires object lock enabled, and explains undo behavior. However, 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.

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

With no annotations provided, the description carries the full burden. It discloses that this is a write operation with medium risk, that it is reversible, and that dry_run previews changes without applying them. It also notes the object-lock prerequisite, though it does not cover permissions or error 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?

The description is front-loaded with a WRITE/risk tag and a one-line summary, followed by concise behavioral context and a tight Args list. No sentence is wasted; the format is scannable and information-dense.

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

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

For a tool with 6 parameters, no output schema, and no annotations, this description is remarkably complete. It covers every parameter, explains the core behavior, prerequisites, interaction with retention, and reversible nature. The agent has enough context to decide when to invoke and how to construct arguments.

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 has zero description coverage, and the description fully compensates by explaining every parameter: bucket_name requires object lock enabled, object_name is the key from bucket_objects, hold_on semantics are explicit, version_id defaults to current version, dry_run previews, and target is the MinIO target. This goes well beyond the bare schema titles.

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

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

The description opens with a specific verb and resource: 'Turn a legal hold on/off.' It clearly distinguishes legal hold from retention, noting it is the one WORM control reversible by design, which differentiates it from sibling tools like set_object_retention.

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

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

The description provides clear context for when to use this tool, explaining legal hold behavior and its interaction with retention ('lifting the hold does not make an object deletable while its retention still runs'). It does not explicitly name alternative tools, but the contrast with retention is sufficient to guide tool 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?

Discloses that the tool REPLACES existing rules and captures prior config for undo. Warns that undo restores the rule, not the data, and objects expired before undo are permanently deleted. Also explains MinIO's refusal of certain lifecycle rules, going well beyond any 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 front-loaded with the core action and risk tag, then uses concise sections for usage, exclusions, and warnings. Every sentence carries actionable signal, and the Args section maps directly to schema without redundancy.

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

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

For a complex 7-parameter mutation tool with no annotations or output schema, the description covers purpose, behavior, parameter semantics, and caveats. It even explains the interplay with undo_apply and warns about data loss, making it highly complete.

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

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

Schema coverage is 0%, but the description provides meaningful semantics for all 7 parameters, e.g., 'expire_days: Expire current objects after N days' and 'lifecycle_xml: Full lifecycle configuration XML to apply verbatim.' It also notes bucket_name comes from bucket_ls and dry_run previews without applying.

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 'Replace the bucket lifecycle,' a specific verb+resource, and explicitly states it REPLACES any existing rules. This clearly distinguishes it from siblings like delete_lifecycle and bucket_lifecycle_get.

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

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

Explicitly provides exclusion guidance: 'Aborting abandoned multipart uploads is NOT available here... Use remove_incomplete_uploads instead.' Also explains the two usage modes (day-count knobs vs lifecycle_xml) and the undo restores context, making alternatives 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?

With no annotations provided, the description carries the full burden and exceeds it: it discloses no-undo, irreversibility, COMPLIANCE's immutability, refusal of shortening/downgrading, the acknowledge_irreversible requirement, and dry_run behavior. This is far beyond any schema or annotation could convey.

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 lengthy but every sentence earns its place by adding critical safety or operational detail. It is well-structured with a warning prefix, explanatory prose, and a clear Args list, all front-loaded with the most important caveat: 'NO UNDO EXISTS.'

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

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

For a high-complexity mutation tool with no annotations and no output schema, this description covers safety, parameter semantics, failure modes, dry_run behavior, and edge cases. It gives the agent everything needed to invoke the tool correctly and understand the irreversible consequences.

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

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

Schema description coverage is 0%, but the Args section compensates completely: bucket_name requires object lock, mode explains GOVERNANCE vs COMPLIANCE and out-of-band escape, days/version_id/dry_run/target all get concrete behavioral meaning. Every parameter is given semantic value beyond its type.

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 '[WRITE][risk=critical] Put retention on one object version,' clearly stating the verb (put), resource (retention), and scope (one object version). This distinguishes it from sibling tools like set_default_retention and set_legal_hold, which operate at different levels.

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 strong context for when to use the tool: setting retention on a specific object version, with detailed mode implications and refusal conditions. However, it does not explicitly name alternative tools like set_default_retention or say 'use this instead of X,' so it stops short of a 5.

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

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

No annotations are provided, so the description must fully disclose behavior. It does so by stating the write risk, reversibility, the refusal edge case, and the fact that dry_run does not bypass the refusal. This is substantial and goes beyond basic mutation semantics.

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

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

The description is organized with a purpose statement, a behavioral note, and an Args block. Each sentence adds value, and the structure makes it easy to scan. There is no filler or redundant 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?

Despite lacking an output schema and annotations, the description covers all necessary invocation details: purpose, parameters, behavior, and edge cases. The dry_run behavior under refusal is a subtle detail that would be hard to discover otherwise, making this notably 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?

With 0% schema description coverage, the description fully compensates by explaining each parameter's meaning and purpose. It clarifies that enabled=true/false maps to enabling/disabling, dry_run provides preview, access_key is sourced from iam_users, and target defaults to the configured target.

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

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

The description clearly states the tool's function: 'Enable or disable an IAM user.' This is a specific verb+resource that distinguishes it from sibling tools like create_user or remove_user. The additional context about reversibility and the refusal edge case further clarifies its 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?

The description provides clear context on when to use the tool and includes an explicit exclusion (refuses when targeting the access key used for authentication). It also directs users to get access_key from iam_users. However, it does not explicitly name alternative tools for similar actions, leaving some gap in explicit comparison.

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

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

With no annotations provided, the description carries the full burden. '[WRITE][risk=medium]' and 'Reversible → prior state' convey that this is a mutating operation with rollback potential. However, it doesn't disclose behavioral details: what happens to existing versioning state, whether changing to Suspended affects existing versions, whether permissions/special access are needed, or error conditions. The medium risk label hints but doesn't explain the consequences of changing versioning state.

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 with a clear arg-by-arg breakdown and an upfront risk tag. Every parameter is documented. A slight deduction for the meta-brackets '[WRITE][risk=medium]' which are unconventional formatting, though they convey useful operational context 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 4-parameter tool with no annotations and no output schema, the description documents all params and states reversibility. Yet it omits key context: what the response looks like, whether bucket_versioning_get should be used to verify, prerequisites (bucket existence is implied via bucket_ls), and behavioral consequences of Suspended on ongoing operations. The reversibility note is helpful but the tool would benefit from stating verification steps and edge cases.

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

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

Schema description coverage is 0%, so the description must document all 4 parameters. It does so: bucket_name (sourced from bucket_ls), status (explicit enum values 'Enabled'/'Suspended'), dry_run (preview behavior), and target (MinIO target name, default behavior). This fully compensates for the missing schema descriptions across all 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 states a clear verb+resource: 'Enable or suspend bucket versioning' with the '[WRITE][risk=medium]' prefix adding operational context. It distinguishes this from siblings like set_bucket_policy, set_lifecycle, and bucket_versioning_get (read counterpart). 'Reversible → prior state' clarifies the change semantics.

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 notes the operation is reversible to prior state, which implies a safe undo path, and indicates a risk level of medium. However, it doesn't explicitly state when to choose this vs. the read-only sibling bucket_versioning_get, nor does it state when one might prefer 'Enabled' vs 'Suspended'. The dry_run parameter offers preview capability, which is useful guidance, but no when-not-to-use guidance is given.

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

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

With no annotations provided, the description carries the full burden, and it does reasonably well: it flags '[WRITE][risk=medium]' behavior, states the inverse runs under its own governed tool and audit tier, explains one-time-only application, and mentions the dry_run preview capability. It doesn't note required permissions or what the response format is, but the core behavioral traits are disclosed.

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

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

The description is efficient — front-loaded with the risk marker and core purpose, followed by concise parameter explanations. The structure with an Args section is standard and scannable. Slightly verbose in the first paragraph (re-explaining audit behavior) but generally tight with no wasted words.

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

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

For a write/undo operation with no annotations and no output schema, the description covers the essential aspects: the action, the dry_run escape hatch, one-time semantics, and parameter provenance. It could note the response shape or error conditions, but given the moderate complexity (3 params, no nested objects), this is largely complete for safe tool invocation.

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

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

Schema description coverage is 0%, so the description must explain all parameters and does so: undo_id is sourced from undo_list or _undo_id in write results, dry_run previews without executing, and target passes through to the inverse tool. This adds meaning well beyond the bare schema types and titles, covering all three 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 clearly states the tool applies a recorded undo by dispatching its inverse tool. It identifies the resource (undo records) and action (apply), and distinguishes from siblings like undo_list by mentioning undo_id comes from such listing. However, it doesn't explicitly contrast with sibling tools or clarify what happens to the undo record after application beyond 'can only be applied once.'

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

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

The description provides clear usage context: apply a recorded undo, pass dry_run=True to preview, and a token can only be applied once. It gives practical guidance on when to use dry_run. However, it doesn't explicitly call out when NOT to use this tool or name alternative actions, though the 'can only be applied once' constraint is a useful operational guardrail.

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

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

No annotations are provided, so description carries full burden. It discloses key behaviors: `truncated` is measured by fetching an extra row, not guessed; `effectVerified=false` means the change is probable not confirmed; `target` is unused. This is far beyond what structured annotations would provide, giving agents crucial decision-relevant context about response handling and safety.

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 thorough but well-structured with a clear opening, a return format example, behavioral notes on `truncated` and `effectVerified`, and an Args section. Every sentence adds value; no filler. Front-loaded with the core purpose, then semantic details.

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

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

For a tool with no output schema and no annotations, the description provides a complete picture: return format, field semantics, edge-case handling, and parameter usage. It also integrates with sibling `undo_apply` by referencing it. This is fully self-contained for an agent to decide when and how 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 coverage is 0%, so description must compensate. It explains `limit` (default 50, capped at 500) and `target` (unused but accepted for uniformity), which fully covers both parameters' meaning and constraints. A slight deduction because it doesn't explicitly mention that `limit` is an integer max rows, but that's clear from 'Max rows to return' and the schema.

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

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

The description opens with '[READ] List recorded, not-yet-applied undo tokens (most recent first)', specifying the verb 'List', the resource 'undo tokens', and the state (recorded, not-yet-applied). It also distinguishes from sibling `undo_apply` by noting it lists tokens for that tool. This is a specific, clear purpose that differentiates it from siblings.

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

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

Explicitly states when to use: to list undo tokens and to obtain `undoId` for `undo_apply`. It also gives guidance on truncated results and the `effectVerified` field, telling users when to re-run with higher `limit` and to check live state before applying. This covers both usage context and alternatives (`undo_apply`), and provides behavioral exclusions (e.g., not to report unverified effects as confirmed).

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

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

With no annotations provided, the description carries full burden. It discloses the truncation behavior ('truncated' flag, do not present as complete breakdown), which is valuable behavioral transparency. It also reveals the returned envelope shape. Does not mention rate limits or auth, but the truncation disclosure is the most important behavioral trait 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 compact, front-loaded with the [READ] marker and main purpose, then provides the return format and args. Every sentence adds value. It could be slightly more polished but is efficient overall.

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?

No output schema exists, so the description needs to explain return values — it does with the envelope example showing buckets/returned/limit/truncated. With 0% schema coverage, the 2 params are documented. The main gap: no example invocation and no guidance on interpretation of 'returned' vs 'limit' semantics beyond truncation. Adequate but not comprehensive for a tool likely used in capacity monitoring workflows.

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

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

Schema description coverage is 0%, so the description must compensate. It explains both parameters: limit (max rows, default 25) and target (MinIO target name from config, omit for default). This adds meaning beyond the raw schema. However, the explanation is minimal — no format examples, no constraints on limit range, nothing about what happens with different target values.

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

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

The description states a specific verb+resource: per-bucket usage (bytes + objects), ordered by size, in an envelope. It clearly differentiates from siblings like bucket_ls (listing) and bucket_info (single-bucket details). However, it doesn't explicitly name an alternative tool for comparison, and the 'in an envelope' phrasing is slightly vague without context.

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

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

The description provides clear context of when to use — per-bucket usage summary. It doesn't explicitly name alternatives or say 'use X instead', but the [READ] prefix and the structure make the tool's role clear among the sibling set of read/bucket tools. No explicit exclusions are given.

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