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

The '[READ]' prefix and description of surfacing status clearly indicate a read-only operation with no side effects. While no annotations are present, the description adequately conveys non-destructive behavior. A higher score would require explicit mention of safety or lack of mutations.

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

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

Two concise paragraphs with a clear header, details, and an 'Args' section. Every sentence adds value 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?

The description lists what information is surfaced (rank state, client/standby counts, flag), which is helpful given no output schema. However, it does not specify the format (e.g., list, dictionary) or whether pagination applies, leaving minor ambiguity for 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?

The only parameter 'target' has zero schema description coverage. The description adds value by explaining it is a Ceph target name from config and that omitting uses the default. This fully compensates for the schema's lack of description.

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

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

Description clearly states it reads per-filesystem MDS ranks with specific status fields including the 'MDS behind on trimming' flag. This distinguishes it from sibling tools like cluster_status or mon_status which cover different subsystems.

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 context for use by highlighting the 'notorious' flag that precedes metadata stalls, implying use when investigating metadata performance. However, it does not explicitly state when to avoid this tool or name alternatives 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?

No annotations provided, so description carries full burden. It indicates a read operation with no side effects, but lacks details on error handling, authentication, or potential outcomes when target is invalid. Basic transparency but could be improved.

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

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

Description is concise with a clear header, explanation of what is retrieved, and parameter documentation. No unnecessary words, though slightly terse. Could benefit from a line break for readability.

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 simplicity (1 optional param, no output schema), the description adequately covers what the tool does and its single parameter. It lacks prerequisites or return format hints, but overall sufficient for a straightforward status read.

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 0% description coverage, so description adds value by explaining that 'target' is a Ceph target name from config and can be omitted for default. This provides context beyond the schema's type-only definition.

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

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

Description clearly states it is a read operation to retrieve active mgr, its standbys, and enabled modules. The verb 'READ' is explicit, and the resource 'mgr' is specified. It distinguishes from siblings like mon_status or cephfs_status.

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?

Description does not provide explicit when-to-use or when-not-to-use guidance. It implies usage for checking mgr status but no alternatives or exclusions. The context hints at usage for default or specified target, but no comparison to other status tools.

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

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

The description marks itself as [READ] and explains what data it reveals (mons in/out of quorum, epoch). Without annotations, it carries the transparency burden and does so adequately. It does not mention permissions or additional side effects, but for a read-only tool this is sufficient.

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 lead '[READ]' prefix, a brief purpose line, a use-case sentence, and a single parameter line. No wasted words, and the most important information is front-loaded.

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

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

Given the tool's simplicity (one optional parameter, no output schema, read-only), the description fully covers its purpose, when to use it, and the parameter. It is complete for an agent to decide and invoke correctly.

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

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

The description explains the sole parameter 'target' as 'Ceph target name from config; omit for the default.' This adds meaning beyond the minimal schema (which lacks a description). With only one optional parameter, this is clear and sufficient.

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 monitors quorum status (mons in/out of quorum and monmap epoch). It uses a specific verb 'Monitor' and resource 'quorum', and distinguishes from siblings like mgr_status, osd_tree, etc., by focusing on monitor-specific health flags (MON_DOWN, clock-skew).

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

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

It explicitly states when to call: 'when health flags MON_DOWN or a clock-skew warn'. It implies usage context but does not explicitly name alternative tools for comparison, missing a full when-not-to-use guide. However, the guidance is clear and actionable.

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 disclose behavioral traits. It marks the tool as read-only with '[READ]' but does not explain what commit/apply latency entails, required permissions, or output format. The description is minimal for a tool with no annotation support.

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

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

The description is extremely concise with a one-line summary and a one-line parameter explanation. Every sentence serves a purpose with no fluff, making it efficient for an AI agent to parse.

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

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

Given the simplicity of the tool (one optional parameter, no output schema), the description is still incomplete. It does not describe the output format or what values (e.g., avg, max latency) are returned. This lack of context could hinder an agent's ability to use the output correctly.

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

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

The input schema has 0% description coverage, but the tool description adds a brief explanation of the 'target' parameter ('Ceph target name from config; omit for the default'). This provides some value beyond the schema, but lacks detail on valid values or 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?

The description clearly states the tool reads per-OSD commit/apply latency, sorted slowest first, to find the slow disk. It uses a specific verb and resource, and is distinct from siblings like osd_df or osd_tree.

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 explicit guidance on when to use this tool versus alternatives. The description does not mention when not to use it or suggest other tools for similar tasks, which is a gap given the large number of sibling tools.

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

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

No annotations provided, so description carries full burden. It explicitly states it is a WRITE operation with high risk, irreversible, and details the actions (destroy, crush rm, auth del). Also mentions need for approver. No contradiction.

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

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

Description is concise and well-structured: summary, usage guidelines, parameter explanations. No superfluous text.

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

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

Covers prerequisites, risk, preview, approval, and parameters. However, no mention of return values or preview output format. Given high risk, it is very complete but slightly missing output 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%, but the description adds an 'Args' section explaining all three parameters: osd_id (from osd_tree), dry_run (preview), target (omit for default). This provides crucial context beyond the 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 'Purge an OSD (destroy + crush rm + auth del). Irreversible.' This specifies the verb and resource, and distinguishes it from other OSD tools like osd_mark_in/out or osd_reweight. No tautology.

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

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

Explicit guidance: 'Pass dry_run=True to preview. Requires an approver... Drain first... before purging.' It mentions prerequisites and alternatives (drain using other tools), and implies when not to use (if not drained or without approver).

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 exist, so the description carries the burden. It declares a read operation ('[READ]') and lists output fields, but fails to mention any behavioral traits like permissions, idempotency, or potential side effects. Adequate but not detailed.

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

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

Extremely concise: two lines plus an args section. Front-loaded with '[READ]' and main purpose. Every sentence earns its place with no redundancy.

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

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

Despite no output schema, the description lists key output fields, providing partial completeness. However, it does not mention the tree structure or differentiate from other OSD tools like osd_df, leaving some gaps for a tool with many siblings.

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: 'Ceph target name from config; omit for the default.' This adds meaningful context beyond the schema's type-only definition.

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 all OSDs and lists specific fields (up/in state, weight, host, device class). The verb '[READ]' and resource are specific, and it implicitly distinguishes from mutation tools like osd_mark_in or osd_reweight.

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 explicit guidance on when to use this tool vs alternatives like osd_df or osd_perf, nor any exclusions or prerequisites. The description only implies a read operation but provides no context for 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?

The description marks the tool as '[READ]' indicating a read-only operation, which is important for behavioral transparency since no annotations are provided. It discloses that the tool returns stuck PGs and 'surfaces the OSD ids', giving insight into the output. No details on return format or side effects, but for a simple diagnostic tool this is sufficient.

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

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

The description is extremely concise with no wasted words. It front-loads the tool's purpose in a single line followed by usage guidance and parameter explanation. Every sentence contributes value, and the structure is logically 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?

Given the tool's simplicity (one optional parameter, no output schema), the description provides sufficient context: purpose, when to use, parameter meaning, and read-only indication. It does not elaborate on the output format, but the title and description imply a list of PGs with OSD IDs, which is adequate for this diagnostic 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?

The only parameter 'target' is described as 'Ceph target name from config; omit for the default.', which adds meaning beyond the schema's type and default. This helps the agent understand what value to provide. Since schema coverage is 0%, the description fully compensates by explaining the parameter's purpose.

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

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

The description clearly states the tool lists stuck PGs with implicated OSDs, using the verb 'dump' and specifying the resource 'Stuck PGs' with qualifiers (inactive/unclean/stale/undersized/degraded). It distinguishes itself from sibling tools like 'pg_summary' or 'osd_tree' by focusing on stuck PGs and implicated OSDs.

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

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

The description explicitly says 'Use this when a PG is not recovering — it surfaces the OSD ids to investigate.', providing clear context for when to use the tool. It does not explicitly mention when not to use it or name alternatives, but the usage guidance is clear and actionable.

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 states '[READ]' indicating no side effects and describes the output (histogram + list). However, it does not disclose any permissions needs, performance implications for large clusters, or the exact format of the list. Basic transparency is present but lacks depth.

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 title, a sentence explaining usage, and an Args section. It is front-loaded with purpose. While very concise, it could be slightly better organized by separating the Args into a proper list or using bold for emphasis, but it remains efficient and clear.

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 low complexity (1 optional parameter, no output schema), the description explains purpose and parameter adequately. However, it omits details about what 'every PG that is not active+clean' means exactly, potential error conditions, or how the histogram is returned. For a health summary tool, a bit more context about interpretation 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?

The sole parameter 'target' has no schema description (0% coverage). The description adds meaning: 'Ceph target name from config; omit for the default.' This tells the agent where the value comes from and that it is optional, effectively compensating for the schema gap.

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

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

The description opens with '[READ] PG state histogram + every PG that is not active+clean.' This clearly specifies a read operation and the exact resource being summarized: histogram of PG states and listing of non-healthy PGs. The rhetorical question 'are my PGs healthy?' reinforces the tool's purpose, and it is distinct from siblings like pg_dump_stuck or pool_ls.

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

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

The description explicitly says 'Call this to answer "are my PGs healthy?"' which is a clear usage context. It does not provide explicit when-not-to-use or alternatives, but the context and sibling list imply this is the primary summary tool for PG health, making the guidance effective.

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 a '[WRITE][risk=medium]' tag, which provides some behavioral context. However, it does not disclose side effects, conflict behavior, or permission requirements. Since no annotations are provided, the description partially compensates but leaves gaps.

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, with a clear structure: a header line followed by a list of arguments with explanations. No unnecessary words or repetition.

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

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

The description covers parameters well and the write operation is clear. It does not describe return values, but overall it provides sufficient context for a straightforward creation tool. Minor improvement could be a note on typical output.

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 explains all 5 parameters with details (defaults, application options), providing significant meaning beyond the input schema which has 0% description coverage. This fully compensates for the schema gap.

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

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

The description clearly states 'Create a replicated pool', which is a specific verb and resource. It distinguishes from sibling tools like pool_delete, pool_ls, and set_pool_pg_num, as it is the only creation tool.

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

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

No explicit guidance on when to use or when not to use. The purpose is clear but lacks context about prerequisites or scenarios where alternatives are preferable. Usage is implied by the create action.

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

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

No annotations provided. Description includes '[READ]' indicating non-destructive read operation, adding basic behavioral context. No details on auth, rate limits, or side effects, which is acceptable for a simple read 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?

Two sentences: first front-loads purpose and output, second explains the parameter. No unnecessary words or repetition. Highly efficient.

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

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

Given the tool's simplicity (one optional param, read-only), the description fully covers purpose and parameter. Lists return metrics (used/avail bytes, percent, objects, usable capacity) even though no output schema is provided.

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 description explains the only parameter: 'target: Ceph target name from config; omit for the default.' This adds meaning about what the parameter is and its default behavior, compensating for missing schema descriptions.

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

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

Description starts with '[READ] Per-pool usage: used/avail bytes, percent, objects, usable capacity.' Clearly states it's per-pool usage and lists specific metrics, distinguishing it from siblings like osd_df (OSD-level) and pool_ls (listing).

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 explicit guidance on when to use this tool vs alternatives. Only mentions 'omit for the default' for target parameter, implying usage context but not comparing to other similar tools like osd_df or pool_ls.

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 labels the tool as '[READ]' indicating it is non-destructive and lists the fields returned. However, it lacks additional behavioral context such as performance implications, authorization requirements, or rate limits.

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

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

The description is extremely concise, with two short sentences that convey the purpose and parameter information 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 simplicity and lack of output schema, the description covers the main functionality and output fields. It does not address potential filtering or pagination, but these may not be critical for this operation.

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

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

The only parameter 'target' is described as 'Ceph target name from config; omit for the default.' This adds meaning beyond the schema's type definition, especially since schema description coverage is 0%.

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

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

The description starts with '[READ]' and explicitly states 'All pools: size/min_size, pg_num, autoscale mode, application, quota.', clearly identifying it as a read-only listing tool. It distinguishes itself from sibling tools like pool_create, pool_delete, 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?

No explicit guidance on when to use this tool versus alternatives. The description mentions an optional 'target' parameter but does not elaborate on scenarios or provide comparisons to sibling tools.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions [WRITE][risk=medium] but does not describe failure modes (e.g., duplicate name, pool constraints), permissions, or side effects beyond creation. This leaves significant gaps 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 extremely concise with a tag line and structured arg list. Every sentence adds value, no redundancy. Front-loaded with risk and action type.

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

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

While the description covers purpose and parameters, it omits return values (no output schema) and behavioral context like idempotency or error handling. For a create tool, an agent may need to know what happens on success or failure.

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 compensates well by explaining pool_name ('from a pool listing'), name ('New image name'), size_bytes (unit), and target ('omit for the default'). This adds context beyond bare schema 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 clearly states 'Create a new RBD image in a pool' with a specific verb (create) and resource (RBD image). It distinguishes from sibling tools like rbd_image_delete and rbd_ls, and includes a [WRITE][risk=medium] tag for 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 intended usage is implicit (create an image), but there is no explicit guidance on when not to use or alternatives among sibling tools. The description lacks when-to-use vs when-not-to-use language.

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 exist, so the description fully discloses behavioral traits: WRITE operation, high risk, irreversibility, and requirement for approval. This satisfies the transparency need.

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

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

Highly concise and well-structured: a summary line followed by usage notes and a clear argument list. No superfluous information.

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

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

For a deletion tool with no output schema, the description covers the key aspects: action, risk, approval, and parameters. It could mention potential errors (e.g., image in use), but overall it 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 coverage is 0%, but the description explains all four parameters: pool_name, image_name (from rbd_ls), dry_run, and target (optional with default). It adds meaning beyond the schema 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 clearly states 'Delete an RBD image and ALL its data. Irreversible.' It uses a specific verb and resource, and the destructive nature distinguishes it from read-only siblings like rbd_ls.

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 guidance on dry run for preview and mentions the prerequisite of an approver. However, it does not explicitly compare to other delete tools like pool_delete or rbd_snapshot_delete.

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 explicitly labels the tool as '[WRITE][risk=high]' and states 'Irreversible.' It also reveals the approval requirement, offering comprehensive transparency about the tool's destructive nature and prerequisites.

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 header line with risk and action, followed by essential notes on dry_run and approval, then a compact Args list. Every sentence serves a purpose without redundancy.

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

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

Given the tool's destructive nature and five parameters, the description covers all critical aspects: operation type, risk, irreversibility, preview option, authorization requirement, and parameter explanations. No output schema is needed as the action only deletes with no meaningful return value.

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 compensates by listing all five parameters in the Args section and providing brief, clear explanations (e.g., 'dry_run: If True, preview without deleting'). While types are already in the schema, the descriptions add meaningful context for correct usage.

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 'Delete an RBD image snapshot. Irreversible.' The verb and resource are explicit. While it doesn't explicitly differentiate from siblings like rbd_snapshot_create or rbd_image_delete, the purpose is unmistakable and specific to snapshot deletion.

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

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

The description advises using 'dry_run=True to preview' and notes that it 'Requires an approver (CEPH_AUDIT_APPROVED_BY).' These guidelines provide crucial context for safe usage, though it does not explicitly mention when not to use it or list alternative tools.

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

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

The description mentions 'Partial-safe if the bucket call fails', which adds behavioral context. However, without annotations, it fails to specify if the tool is read-only, required permissions, or other side effects. The 'READ' tag is informal and not part of 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 succinct, with clear sections: a heading, operation description, safety note, and parameters. Each sentence adds value, though the structure could be slightly more formal.

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 simplicity (one optional parameter, no output schema), the description provides adequate context but lacks information about output format or return values. It mentions 'Flags buckets' but does not detail what the output looks like.

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 explains the only parameter 'target' in detail: 'Ceph target name from config; omit for the default.' This adds significant meaning beyond the schema, which only specifies type and allows null.

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 performs a READ operation on RGW daemons and a large-omap scan to flag oversized unsharded bucket indexes. It distinguishes itself from sibling status tools by focusing specifically on RGW and a known performance issue.

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 for checking RGW health and large omap issues, but does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. No guidance on prerequisites or scenarios to avoid.

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 [WRITE][risk=medium] indicating it's a potentially risky write operation and notes reversibility. However, it does not detail specific consequences of changing autoscale mode or required permissions, leaving some behavioral ambiguity.

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: one action sentence, a note on reversibility, and three bullet-pointed parameter descriptions. Every element is useful, no waste, properly front-loaded.

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

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

The description adequately covers parameters and risk, but omits any mention of the return value or success/failure response. For a simple setter, this is acceptable but could be improved by stating expected output.

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 coverage, the description compensates fully: explains pool_name source, enumerates allowed mode values ('on', 'off', 'warn'), and clarifies target's default behavior. This adds essential meaning beyond the schema's type-only 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 sets a pool's PG autoscale mode with specific values (on/off/warn), using a specific verb-resource structure. It distinguishes from sibling tools like set_pool_pg_num or set_pool_size by exactly naming the autoscale feature.

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 explicit guidance on when to use this tool versus alternatives, no prerequisites or exclusions. The description only explains what the tool does, not the context of usage relative to other pool management tools.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It mentions '[WRITE]' and 'Reversible → prior pg_num', but fails to disclose important traits such as required permissions, potential data migration, or asynchronous behavior. This is insufficient for a mutation 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 extremely concise, with a one-line summary and a bulleted list of arguments. Every sentence serves a purpose, and there is no redundant or extraneous information.

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

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

Given that this is a write operation with no output schema, the description lacks crucial details such as the return value, potential side effects (e.g., data rebalancing), and performance implications. The mention of reversibility is helpful, but overall the description is incomplete for a mutation 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?

The input schema has 0% description coverage, but the tool description provides explanations for all three parameters. It adds context like 'Pool name (from pool_ls)' and 'Ceph target name from config; omit for the default', which aids understanding beyond the raw 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 'Set a pool's pg_num', which is a specific verb and resource. It distinguishes from sibling tools like set_pool_autoscale, set_pool_quota, and set_pool_size, which modify different pool properties.

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 provide when-to-use or when-not-to-use guidance. However, the tool name and description imply it is for adjusting placement group count, which differentiates it from siblings. No alternatives are mentioned, so the guidance is minimal.

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 bears full responsibility. It discloses the write nature ([WRITE]), risk level (medium), and importantly notes reversibility ('Reversible → prior quota'). However, it does not detail required permissions or potential side effects of modifying quotas, but the core behavioral traits are covered.

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, using a compact one-line tag followed by bullet-like parameter explanations. Every sentence adds value with no redundancy. The structure front-loads the key action and risk, making it easy to scan.

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

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

Given the tool's simplicity (no output schema, few parameters), the description is nearly complete. It covers the operation, parameter details, and a prerequisite hint. However, it could mention expected return values or confirmation behavior, but that is not critical for this 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 fully explain parameters. It does so effectively: pool_name source from pool_ls, max_bytes/max_objects behavior (0 clears, omit unchanged), and target default. This adds significant meaning beyond the raw schema, clarifying default null semantics and usage of 0.

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 'Set a pool's byte/object quota' with a specific verb and resource. It distinguishes this tool from sibling pool modification tools (e.g., set_pool_size, set_pool_autoscale) by focusing on quota management. The [WRITE][risk=medium] tag further clarifies 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 stating 'Pool name (from pool_ls)' as a prerequisite, but it lacks explicit guidance on when to use this tool versus alternatives like set_pool_size or set_pool_pg_num. No when-not conditions or alternative tool comparisons are provided.

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?

Since no annotations are provided, the description carries the full burden. It clearly marks the tool as [WRITE][risk=high], states that it forces mass data movement, mentions reversibility ('Reversible → prior size'), and notes the approval requirement. This provides strong behavioral transparency, though it could mention potential side effects like performance impact.

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

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

The description is concise and well-structured. It starts with the core purpose, then lists critical behavioral notes, and ends with clear parameter explanations in a bullet-like format. Every sentence adds value, with no redundancy.

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

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

Given the complexity (4 parameters, no output schema, no annotations), the description is remarkably complete. It covers all parameters, explains the approval requirement, dry-run capability, reversibility, and the high-risk nature. An agent has sufficient information to decide when and how to use this tool.

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

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

Schema coverage is 0%, so the description must explain all parameters. It does so thoroughly: 'pool_name' is linked to 'pool_ls', 'size' is described as 'New replica count', 'dry_run' is explained with its preview behavior, and 'target' is described as a Ceph target from config. This adds significant meaning 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 primary action: 'Set a pool's replica size'. It also mentions the consequence ('forces mass data movement on a live pool'), which distinguishes it from siblings like 'set_pool_autoscale' or 'set_pool_quota'. The verb 'Set' and the specific resource 'pool's replica size' make 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 explains when to use the tool (to set replica size) and provides important usage context: requires an approver under the graduated-autonomy policy and supports a dry-run mode. However, it does not explicitly state when not to use this tool or suggest alternatives, which keeps it from a perfect score.

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 must fully disclose behavior. It states the action is reversible (records undo) and marks risk as medium. However, it does not mention any side effects, authorization needs, or what happens if parameters are set too low/high. The reversibility is a strong point, but more could be said.

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

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

The description is succinct and well-structured: a risk marker, a one-line summary, a usage context sentence, and a clear parameter list. Every sentence adds value without redundancy. It is appropriately front-loaded.

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

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

Given no output schema, the description covers the tool's purpose, when to use it, reversibility, and parameters. It lacks examples of typical values or error conditions, but for the complexity level (a tuning tool), it is fairly complete and aids 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?

Schema description coverage is 0%, so the description carries the full burden. It explains each parameter: max_backfills, recovery_max_active, and target, noting that omitting leaves the setting unchanged. This adds critical meaning beyond the bare schema.

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

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

The description clearly states it tunes osd_max_backfills and osd_recovery_max_active to control recovery/backfill storms. The verb 'tune' and resource are specific, though it does not explicitly differentiate from sibling tools, most of which are read-only or have different purposes. However, the context (Ceph recovery tuning) helps an AI agent understand its role.

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 context: use it when a recovery storm is starving client IO or when it's calm (back up). It also notes reversibility, but does not mention when not to use it or list alternative tools. The guidance is clear and actionable.

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. The '[WRITE][risk=low]' prefix provides some behavioral context (write operation, low risk). However, it does not disclose whether the scheduling is asynchronous, what side effects occur (e.g., if a scrub is already in progress), or any confirmation of success.

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, using a simple format with clear labeling. Every sentence adds value: the main action in the first line, then parameter definitions. No extraneous text.

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 scheduling command, the description covers the essential action and parameters. However, it lacks information on the return value or confirmation, and does not mention error conditions or prerequisites. Given the simplicity, it is mostly complete but could be slightly more thorough.

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 explain parameters. It does so effectively: pgid is a placement group ID with an example ('2.1a') and source context, target is an optional Ceph target name. This adds significant 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 the tool schedules a deep (data-integrity) scrub on a PG. The verb 'schedule' and resource 'deep scrub on a PG' are specific, and the 'deep' qualifier distinguishes it from the sibling 'trigger_scrub' (regular scrub).

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 purpose and provides context for the pgid (from pg_summary/scrub_status), guiding the agent on how to obtain the parameter. It implies use for data integrity checks but does not explicitly contrast with 'trigger_scrub' or state when not to use this tool.

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