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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so safety is fully covered elsewhere. The description adds nothing beyond that: no error behavior when the account does not exist, no note on sensitivity of the returned data, no return shape. With the annotations doing all the work, the description is pure repetition.

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?

There is zero wasted wording and the phrase is front-loaded, but that is because there is essentially no content. It is under-specified rather than efficiently concise.

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 simple and the annotations are rich, but the one thing an agent must know to call it correctly, the identifier format for "account," is absent from both schema and description. There is no output schema, so the description also leaves the return value entirely undefined.

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% for the single required parameter "account," which is constrained only by a string length. The description never clarifies whether "account" is a username, an ID, a path, or a qualified name. With one undocumented parameter, the description needs to compensate and does not.

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?

Tautological: description restates name/title.

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 when-to-use guidance and no mention of the obvious alternative, accounts_list, or of any prerequisite. An agent must infer from the name alone that this fetches one account rather than enumerating them.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered structurally. The description adds nothing beyond that — no mention of pagination behavior (despite a cursor parameter), result ordering, or whether the list is bounded by limit defaults.

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?

It is maximally short and front-loaded with no filler, but at five words it is under-specified rather than efficient. There is no wasted wording to cut, yet the single sentence carries almost no 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 paginated list tool with two undocumented parameters and no output schema, the description should at least explain pagination and what an account record contains. Annotations cover safety, but the agent still lacks the context needed to page through results correctly.

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

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

Schema description coverage is 0%: neither limit (default 100, max 500) nor cursor is described in the schema, and the description does not compensate at all. There is no hint that this is a paginated endpoint or how to iterate with the cursor.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of alternatives like account_get for single-account retrieval, and no prerequisites or scope conditions. The agent must infer usage purely from the name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, and idempotentHint=false, which covers the safety profile. The description adds no behavioral context beyond that — no statement about required permissions, whether settings are environment-scoped, or whether the call can fail for an unconfigured rollout.

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?

It is a single short sentence with no padding, so it is trivially concise. However, it consumes its only sentence restating the title rather than front-loading any useful information, so the brevity reflects under-specification rather than efficiency.

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

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

With no output schema, the description carries the burden of explaining what a caller receives back, and it says nothing about the shape or content of the settings object. For a zero-param read tool the call is mechanically simple, but an agent still cannot tell what this returns or why it exists relative to settings_get.

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 tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The empty schema is self-explanatory and the description does not mislead about inputs.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of when to prefer settings_get or any other sibling. The only implied usage is 'call this to get agent rollout settings', which is circular.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered structurally. The description contributes no additional behavioral context such as whether secrets are masked, whether the token must be active, or what happens for an unknown/revoked token.

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 text is short but only because it is under-specified rather than economical; it is a bare repetition of the title with no front-loaded scoping or qualification.

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

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

With no output schema and an undocumented parameter, the description carries the full burden of explaining the return shape and the token argument, and it addresses neither. Only the annotations provide any reliable information about 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% and the single parameter 'token' is not explained anywhere. It is critically ambiguous whether 'token' means a token identifier/UUID or the raw secret value, which materially changes how an agent must populate it.

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

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

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the closely related api_tokens_list alternative. An agent must infer the get-vs-list distinction purely from the tool names.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description contributes nothing further — no mention of pagination behavior, ordering, whether secret values are excluded from the metadata, or rate limits. It does not contradict the annotations, but it adds zero 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 single-line description is free of waste and front-loaded, but it is under-specified rather than concise — there is only one sentence and it merely echoes the title. A slightly longer description could have carried usage and pagination context at minimal cost.

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

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

With no output schema, no parameter descriptions, and a mutation-free listing contract, the description should explain what metadata fields come back and how to page. Neither is present, leaving the agent unable to predict the response shape or pagination loop for a two-parameter list 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% for both parameters: 'limit' and 'cursor' have types, defaults, and bounds but no prose explaining what they mean or how paging works. Because coverage is low, the description carries the burden of compensating, and it says nothing about page size semantics or cursor round-tripping.

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?

Tautological: description restates name/title.

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

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

There is no guidance on when to use this tool versus api_token_get, oauth_grants_list, or any other sibling. An agent must infer that this is the collection-level counterpart to the single-token getter, and nothing states whether listing is paginated or scoped.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the description does not need to restate safety. It adds genuinely new behavior: the caller must be authenticated and hold namespaces/read on global '*', and results are unfiltered by per-namespace grants — an authorization and result-set nuance that would otherwise surprise 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?

Two short sentences, the purpose front-loaded and the caveat second. The first line duplicates the title verbatim, which is slight waste, but nothing else is padded.

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

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

With no parameters, no output schema, and full annotation coverage, the description covers access requirements and filtering behavior well. Its remaining gap is the return payload: there is no output schema, so the description should say what a 'backend' record contains or roughly how many/what fields come back.

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 zero parameters, so the baseline is 4; there is no parameter semantics to explain. The description correctly avoids inventing parameters such as namespace filters that do not exist, implicitly confirming the call is unfiltered.

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

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

States a specific verb and resource ('List available infrastructure backends') and adds a scope note distinguishing it from namespace listing. An agent can tell what it enumerates, though the description does not contrast it against other 'list' siblings like providers_list or clusters_list that might appear to overlap.

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 names a comparison point ('unlike namespace listing, this endpoint does not filter items by per-namespace grants'), which implies when this is the right choice versus namespaces_list. However, there is no explicit 'use this when' statement, no exclusions, and no guidance for an agent choosing among the many other *_list 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is known. The description adds nothing on top: no statement about whether a missing drill errors or returns empty, no permission requirements, no indication of idempotentHint=false implications. No contradiction with annotations.

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

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

It is short, but this is under-specification rather than conciseness — five words that carry zero information beyond the tool name. There is no front-loaded statement of behavior or scope.

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 single-resource get tool with three parameters and no output schema needs the description to explain what is returned and how to identify a drill. Instead the agent learns nothing, and with no output schema there is no fallback source of return-value semantics.

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

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

Schema description coverage is 0% for the three parameters; only the nested NamespaceName $def has any prose. The description gives no meaning for 'cluster' or 'drill' (format, where the drill identifier comes from, whether namespace defaults or is required for scoping), so it fails to compensate for the coverage gap.

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

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

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to or from the obvious alternatives (backup_drills_list for enumeration, backup_get for backups). Usage is only inferable from the tool name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered elsewhere. The description contributes nothing about ordering, whether results span all namespaces by default, or how the cursor behaves, which are the traits an agent actually needs 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 single four-word sentence is not concise in the useful sense — it is under-specification. There is no front-loaded statement of scope or behavior because there is no content at all beyond the name.

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 paginated, cluster-scoped list tool with no output schema and zero parameter documentation, the description omits everything an agent needs: default scoping when namespace is omitted, pagination termination, and result shape. This is essentially a bare stub.

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 for four parameters and provides none of it. Only 'cluster' is required, yet nothing explains whether omitting 'namespace' lists across all namespaces or whether 'limit'/'cursor' form a resumable pagination loop — the parameter names alone are only partially self-explanatory.

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?

Tautological: description restates name/title.

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 when-to-use guidance is given: nothing says to use this to enumerate drills across a cluster/namespace versus calling backup_drill_get for a specific drill. There are no stated preconditions, no mention of pagination workflow, and no exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed-world scope, so safety is fully covered. The description adds two genuinely useful facts beyond them: that retained backups remain readable after source cluster deletion, and that authorization follows the cluster name; however, "the same cluster-name authorization" is cryptic (same as what?) and nothing is said about error or not-found behavior. With annotations doing the heavy lifting, this lands at adequate-with-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?

Two short sentences, front-loaded with the core purpose, and no filler or repetition of the title. It is compact to the point of being sparse given the undocumented parameters, but nothing written is wasted.

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 and no param documentation, so the description carries the burden of explaining both return content and identifier semantics; it only gestures at the return ("metadata and status"). The retention and authorization notes partially compensate for the complexity of a get tool, but an agent could still not reliably construct a call or interpret the result from this text alone.

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 the description adds no parameter meaning whatsoever: it never says whether "backup" is a name, ID, or generated label, what happens when "namespace" is omitted, or how cluster-name authorization interacts with the namespace argument. The only parameter documentation anywhere is the $defs description on NamespaceName, which the description does not build on. For a low-coverage schema this is a clear shortfall against the requirement to compensate.

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

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

The description gives a clear verb+resource pair ("Read backup metadata and status") and names the object precisely, so an agent knows this is a single-backup read rather than a list. It does not explicitly differentiate itself from near siblings such as backups_list, backup_drill_get, or control_plane_backups_list, so the agent must infer the get-vs-list distinction from the tool names alone.

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

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

There is no statement of when to use this tool instead of backups_list or the backup_drill/control_plane backup variants. The one usage-adjacent fact is the retained-backup case after cluster deletion, which is framed as a capability rather than a routing rule, and nothing says what to do if the backup is not found or which of the three parameters is required for which lookup path.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuine non-obvious behavior: retained records live under the deleted source cluster name, authorization is evaluated against that name, and a missing cluster with no retained records returns 404 — useful for interpreting failures, though nothing is said about pagination behavior.

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

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

Two short paragraphs, front-loaded with the purpose and followed by the retention caveat; no filler. The second paragraph is slightly compressed to the point of ambiguity with 'that cluster name', but overall it is 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 four-parameter paginated list tool with no output schema and zero schema description coverage, the description never explains pagination (limit/cursor) or what a backup record contains, which an agent needs to page correctly and to interpret results. The retention/404 semantics are a good addition but do not close the gap.

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

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

Schema description coverage is 0% and only the namespace field carries any inline text, so the description must carry the burden. It hints that 'cluster' can be a deleted cluster name for retention lookups, but says nothing about limit, cursor, or namespace scoping, leaving three of four parameters unexplained.

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

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

The description names a specific verb and resource ('List backup inventory'), which is clearer than the title alone and separates it from singular getters like backup_get. It does not, however, distinguish itself from near siblings such as backup_drills_list, control_plane_backups_list, or restores_list, which an agent could easily confuse with it.

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

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

Usage is only implied: the retention paragraph tells the agent that listing backups for a deleted cluster still works if you pass the old cluster name, which is a real usage scenario. There is no explicit statement of when to prefer this over backup_get or the drill/control-plane listing siblings.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety and side-effect profile is fully covered structurally. The description contributes nothing beyond that: no statement about errors for missing storage, visibility across namespaces, or whether secrets/sensitive fields are redacted.

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 words with zero redundancy, but the brevity comes from under-specification rather than economy — the single sentence is literally the title, so nothing is front-loaded because nothing is present.

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

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

This tool is not materially more complex than that: two parameters with a documented namespace regex, no nested objects, and a closed-world annotation set on a read-only lookup. The description is thin but not misleading, and the structural fields carry most of the load.

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%: the required "storage" parameter is a bare string with only length bounds and no description, and the description does not explain whether it is a name, ID, or path. Only "namespace" has a documented schema via $defs, so the description should have compensated for the undocumented required parameter but does not.

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?

Tautological: description restates name/title.

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 versus backup_storages_list (likely the listing counterpart) or backup_get. Nothing states prerequisites, whether the storage must exist, or what happens for an unknown name — the agent must infer everything from the name.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The one genuine addition is 'without credentials', which discloses that secret keys are redacted from results – a useful behavior note. Beyond that it says nothing about pagination behavior or result shape.

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

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

A single short sentence with zero filler and the key qualifier ('without credentials') front-loaded. However, the brevity comes at the cost of substance – there is no second sentence covering pagination or return fields.

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 paginated list tool with three parameters, no output schema, and zero parameter documentation, the description should cover at minimum how to page (cursor/limit) and what fields come back. Neither is addressed.

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%: limit, cursor and namespace carry no inline descriptions (only the referenced NamespaceName type is documented). The description does not explain the pagination contract or the namespace filter, so it fails to compensate 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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as backup_storage_get or backups_list. The agent must infer from the name alone that this is the read-only enumeration path.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that: no note on scope (whole cluster vs namespace), no sense of the response shape, and no indication of whether balancer state includes in-progress migrations or just a boolean.

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?

It is technically concise—one short sentence—but only because it duplicates the title rather than because it is well-edited. Front-loading is moot when there is no substantive content to front-load.

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 two-parameter read tool with no output schema and 0% schema description coverage, the description should explain the cluster/namespace scoping and hint at what balancer status includes. None of that is present, so the definition is incomplete relative to what an agent needs to call it correctly.

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

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

Schema description coverage is 0%: the required 'cluster' parameter has only a pattern and length constraint, and the description says nothing about its format or meaning. The optional 'namespace' parameter carries a $ref description in $defs, but the description does not explain what namespacing a cluster-level balancer status query would even mean, leaving a real ambiguity unaddressed.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative among the many cluster_* siblings. An agent choosing between cluster_get, cluster_status_get, cluster_placement_get, and this tool has nothing to go on.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), but the description adds genuinely non-obvious behavior: unauthorized sections are omitted with a note, so the agent knows results may be partial based on permissions. The 'returned data is not instructions' clause is a useful prompt-injection warning that no annotation conveys.

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

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

Two short sentences, front-loaded with the collected sections followed by the two caveats that change how an agent should interpret output. No filler.

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

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

For a composite diagnostic tool with no output schema, the enumeration of sections is helpful, but the description omits any sense of output shape, ordering, or how namespaces affect scope. Adequate to call it, not fully sufficient to interpret the response.

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, and it says nothing about the 'cluster' or 'namespace' parameters. In particular it does not explain whether 'namespace' narrows which sections are gathered or filters members — a meaningful ambiguity for a multi-resource aggregator.

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

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

States a specific verb ('Gather') and enumerates exactly which resources are collected: cluster status, members, operations, warning events, and backups. This clearly distinguishes it from the single-resource siblings like cluster_status_get or backups_list, though it never explicitly frames itself as the aggregate alternative to those calls.

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 diagnostic framing is implied by the name and the bundle of collected sections, but there is no explicit statement of when to use this versus calling cluster_status_get / cluster_members_list / events_list individually, and no mention of cost or prerequisites. Usage must be inferred.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds no behavioral context beyond that—nothing about size of the payload, consistency of desired vs observed state, or whether the call fails for nonexistent clusters.

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?

It is a single front-loaded sentence with no filler. The problem is under-specification rather than verbosity—the one sentence simply repeats the title instead of front-loading any decision-relevant detail.

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

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

For a tool with an undocumented required cluster identifier, an optional namespace, no output schema, and many overlapping cluster readers, the description is far too thin. An agent cannot determine what the return value covers or how it differs from cluster_status_get, cluster_diagnose, or cluster_members_list.

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% for the top-level parameters: the required 'cluster' parameter has only a pattern and length bounds, with no indication of what identifier format or source is expected. The 'namespace' reference is documented inside $defs, but the description adds no meaning for either parameter and does not explain the optional namespace scoping.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no prerequisite, and no mention of any alternative. With 90+ siblings including an obvious overlap like cluster_status_get, the agent is left to guess which read tool to call, and the description does nothing to resolve that ambiguity.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so most of the safety profile is covered. The description contributes nothing beyond them: no mention of what happens for an unknown member, whether the read is eventually consistent, or what the status payload contains.

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

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

One short sentence with zero padding and the scope word 'one' up front, so nothing is wasted. However, the brevity comes from under-specification rather than economy, leaving no structure to guide the caller.

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 would need to say what a 'member status' returns; it does not. For a read tool requiring two identifiers whose formats are undocumented, the definition is too thin to let an agent invoke it confidently.

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%; only the nested NamespaceName $def has a description. The description does not explain whether 'member' is a name, ID, or node address, nor what 'cluster' identifies. With three parameters and no schema help, the description should have compensated and does not.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of cluster_members_list as the alternative for enumerating members, and no statement of prerequisites such as whether the cluster must be reachable or the member must still exist. The agent must infer all routing decisions from the tool name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered externally. Beyond that, the description says nothing about whether results cover all members or a filtered subset, whether the output is a snapshot in time, or how replica lag is measured, leaving the behavioral burden on the schema.

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

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

The text is a single short fragment with no waste, but its brevity comes from omission rather than discipline; nothing is front-loaded about scope or filtering. It is not bloated, just under-specified.

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 simple (two parameters, no output schema), but a complete definition should still state that it lists members for the given cluster and what the optional namespace does. With zero annotation gaps covered by prose and no parameter explanation, an agent is missing scope-critical information.

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 reported at 0%, and the description adds no meaning for either parameter. The required 'cluster' argument is never mentioned, nor is whether 'namespace' narrows the member list, so the agent gets no help interpreting the inputs.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of when to prefer cluster_member_get for a single member, and no prerequisites such as needing the cluster name. The agent must infer everything about selection from the tool name alone.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds nothing beyond that — nothing about aggregation semantics, expected cost of wide ranges, or how a large step/range combination affects 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?

A single front-loaded sentence fragment with zero filler, so nothing needs trimming. Its failure is under-specification rather than verbosity, which is penalized in the other dimensions.

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 metrics query tool with four parameters, zero schema descriptions and no output schema, the definition is far too thin. It gives no indication of what a returned time series looks like, what the aggregation is across, or how to interpret the required cluster plus optional namespace scoping.

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% across four parameters, so the description is the only place meaning could be added, and it supplies none. It does not explain 'cluster' (the required scoping key), 'namespace', or the duration syntax and defaults of 'step' and 'range', leaving the agent to reverse-engineer the regex patterns.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no exclusions, and no named alternative in a sibling list that contains at least two plausible substitutes (prometheus_metrics_get, cluster_status_get). The agent must infer the choice from the tool name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description contributes nothing beyond that: no ordering, pagination semantics, retention window, or meaning of the phase filter.

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 text is a single four-word phrase with no waste, but it is under-specified rather than concise. Brevity here reflects a missing description, not an efficient one.

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 five-parameter listing tool with no output schema and no parameter documentation, the definition should explain filtering, pagination via cursor, and return shape. None of this is present, so the definition is not sufficient to invoke the tool correctly.

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

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

Schema coverage is 0% for five parameters, and the description documents none of them. The meaning of cluster, phase, cursor, and limit (default 100, max 500) is left entirely unstated, and the description does not even hint that filtering or pagination exists.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of the closely related operations_list sibling, and no guidance on filtering or prerequisites. An agent must guess which listing tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, destructiveHint=false, so the safety profile is fully covered. The description adds nothing beyond that — no indication of whether detection is computed live or cached, whether warnings are exhaustive, or what scope/namespace filtering does.

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?

It is a single short, front-loaded sentence with no filler, so it is not verbose. However, its brevity comes from redundancy with the title rather than from economical communication, so it earns only a middling score.

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

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

With no output schema, the description is the only place return-shape information could live, and it says nothing about what 'co-location' or 'placement warnings' results contain. Combined with undocumented parameters and no sibling routing, the definition is too thin for an agent to call this correctly the first time.

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% for the top-level properties: 'cluster' carries only a regex pattern with no prose, and 'namespace' only inherits the $ref description. The description supplies no meaning for either parameter, so it fails to compensate for the coverage gap — an agent cannot tell whether omitting namespace scopes to all namespaces or to 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?

Tautological: description restates name/title.

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

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

There is no guidance on when to call this versus the numerous related cluster tools (diagnose, members_list, member_get, status_get). No prerequisites, no exclusions, no alternative named.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so safety is covered. The description adds genuinely useful behavior beyond that: results are filtered per cluster on namespace/name read permissions, and a global '*' grant must not cause scoped users to be blocked from listing permitted clusters — a non-obvious authorization nuance an agent would not infer from structured fields.

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

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

Only two sentences with no filler, and the core purpose is front-loaded, which is good. But the second sentence is a dense, jargon-heavy implementation constraint ("a global '*' check must not prevent scoped users...") that reads like a ticket acceptance criterion rather than agent-facing guidance, and it pushes out more useful content like pagination.

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 three-parameter list tool with no output schema, the definition covers the tricky part — permission-filtered results — but omits pagination behavior and any sense of result shape or ordering. An agent could invoke it, but would likely mishandle large result sets or misunderstand what the namespace filter does.

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 parameter meaning, and it largely does not. It references namespace/name permission scoping but never explains the namespace filter parameter's effect, and says nothing at all about limit (default 100, max 500) or cursor-based pagination, leaving two of three parameters undefined anywhere in the 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 opens with a specific verb and resource ("List readable clusters") and the qualifier "readable" distinguishes it from cluster_get and other single-object siblings. The second sentence, however, drifts into an internal permission-check requirement rather than clarifying what the tool returns, which slightly muddies an otherwise clear 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?

There is no explicit guidance on when to call this versus cluster_get or cluster_status_get, nor any mention of how to page through a large cluster set. The only usage-relevant signal is implicit: the tool returns only clusters the caller may read, which tells an agent the results are permission-scoped but not when to reach for it.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds no behavioral context of its own — nothing about whether "observed" status is live-queried or cached, how stale it may be, or what happens when a cluster is unreachable.

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?

Four words is short, but here brevity is under-specification rather than efficiency — the sentence is front-loaded only because there is nothing behind it. Every sentence earns its place only vacuously, since the sole sentence duplicates the title.

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 two-parameter read tool with no output schema and 0% parameter documentation, the description should carry the burden of explaining the parameters and the observed-vs-desired distinction. It does neither, leaving the definition incomplete relative to the sibling surface it must be distinguished from.

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% at the top level: the required "cluster" parameter has only a regex pattern and no stated meaning, and "namespace" is an optional filter whose role is never mentioned. The description supplies no clarification at all, so the agent cannot tell what "cluster" identifies or when to pass a namespace.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no prerequisites, and no naming of alternatives, despite many closely related siblings (cluster_get, cluster_diagnose, cluster_metrics_get, cluster_placement_get, cluster_balancer_get) whose boundaries an agent must infer on its own.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing on top of that — not what the policy governs, not whether a default policy is always present, and not what happens if none exists. Note idempotentHint=false on a parameterless getter is unusual, and the description does not clarify it.

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?

It is a single short sentence with no wasted words, but it is pure restatement of the title rather than a concise explanation, so the brevity reflects under-specification rather than efficiency.

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

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

There is no output schema, so the description should convey what the returned policy contains or its singleton nature, and it does not. For a getter with no arguments the call itself is trivial, but the agent gets no context about the resource being fetched or how it relates to the backups list.

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 zero parameters and 100% schema coverage there is nothing for the description to disambiguate, so the baseline is 4. The description neither helps nor harms parameter understanding.

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

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

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of the closely related control_plane_backups_list sibling, and no stated prerequisites or conditions. The agent gets no help deciding between this and the list tool.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered without description text. The description adds nothing beyond that: it does not mention pagination behaviour, ordering, default result count, or how the control-plane set is scoped, which are the behaviours an agent actually needs here. It does not contradict the annotations.

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

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

The single sentence is short but only because it is under-specified, not because it is efficient. It carries no front-loaded useful information beyond the title, so brevity here costs rather than saves.

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 paginated list tool with two undocumented parameters, no output schema and no annotation detail on returns, the description should explain what is listed, ordering, and paging. None of that is present, so an agent cannot reliably invoke it beyond guessing defaults.

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% for two parameters (limit with a 1-500 range and default 100, and cursor), and the description supplies no meaning for either. Pagination via cursor is entirely undocumented, so the agent gets no help on how to page or what limit governs.

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?

Tautological: description restates name/title.

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

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

There is no usage guidance at all: no statement of when to call this instead of backups_list or backup_drills_list, no prerequisites, and no exclusions. The agent must infer the choice purely from the tool name.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: the result is "independent of administrative accounts read policy," telling the agent this call succeeds without account-listing privileges. It doesn't describe what identity fields come back, which matters since there is no output schema.

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

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

Two short sentences, front-loaded with the action and followed by the scoping constraint. The opening clause duplicates the title verbatim, which is minor waste, but nothing else is 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 zero-param, read-only, annotated tool the description covers purpose and the key behavioral edge case (no admin read permission needed). The one real gap is the absence of any hint about the returned identity shape, which the missing output schema leaves entirely to the caller's guess.

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 tool takes zero parameters, which is the baseline-4 case; there is nothing for the description to disambiguate. It correctly reinforces that the call is not parameterized by user or account identifier.

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 gives a specific verb+resource ("Read the authenticated identity") and adds the scope qualifier "returns only the caller," which separates it from account_get / accounts_list and the many per-service *_user_get tools. It stops short of naming a specific sibling to contrast with, so differentiation is implied rather than explicit.

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?

"Self-service: returns only the caller" implies when this is the right pick (you want your own identity, not a managed account), but there is no explicit when-to-use/when-not statement and no alternative named despite a crowded sibling set of identity-read tools. Usage is inferable but not stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered by structured data. The description adds nothing beyond that: it does not say what happens when the role does not exist, what 'custom' excludes (e.g. built-in roles), or what fields are returned.

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

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

It is a single short sentence with no wasted words, but that brevity is under-specification rather than conciseness — the sentence simply restates the title and carries no additional information for the caller.

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 four-parameter read tool with no output schema, the description should explain the resource being fetched and its identifiers or the not-found behavior. None of that is present, so it is not complete enough to call reliably without probing sibling tools.

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% for cluster, database, and role, and the description supplies no meaning for any of them. An agent gets no hint about identifier formats, whether cluster/database must already exist, or what the optional namespace parameter is for beyond the referenced $defs pattern.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no statement of prerequisites, and no mention of which sibling to pick when the engine or resource type is ambiguous. The only implied guidance is that it is a single-item read rather than a list.

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

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

The description adds one sentence regarding RBAC resource usage, providing valuable architectural context beyond the annotations. However, it does not disclose operational behaviors such as pagination limits or specific failure modes, keeping the score moderate.

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

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

The description is concise, but the first sentence is a simple restatement of the title, offering no functional value that wasn't already captured in the name and title.

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 of a listing tool involving a 'cluster' and 'namespace' parameter, the description is incomplete. It doesn't explain the scope of the listing (e.g., does it list globally, or is it limited to a namespace?) beyond what is already implied by the inputs.

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 the description fails to add any meaning to the four input parameters (cluster, namespace, limit, cursor). It does not explain what criteria define these custom roles relative to the provided schema fields.

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 repeats the title and clearly states the tool's function (list custom roles). However, it does not differentiate these 'custom' roles from other specific database roles listed among the siblings, like postgres_roles_list, making the scope slightly ambiguous.

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 minimal guidance on when to use this tool. It only states the core function without comparing it against alternatives like database_role_get or database_users_list, leaving the user to infer usage boundaries.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered structurally. The description contributes nothing beyond that: it doesn't say whether credentials or secrets are returned, what happens for a nonexistent user, or how the namespace scoping affects visibility.

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 single sentence is short but it is under-specification rather than conciseness: it duplicates the title without conveying any information an agent does not already have. There is no front-loaded scope statement or qualifying detail.

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

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

For a tool with four undocumented parameters, no output schema, and no parameter descriptions, the description leaves nearly everything unresolved. At minimum it should identify which database engine this 'application user' belongs to and whether sensitive material is returned.

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% across four parameters, and three are required, so the description carries the full burden of explaining cluster, database, and username. It supplies no meaning for any of them, nor for the optional namespace, whose constraints live only in a $ref'd definition an agent may not resolve at selection time.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no prerequisite conditions, and no mention of alternatives. An agent must infer from the name and sibling list that this fetches a single user rather than a list, and nothing indicates scope (application vs. mysql/postgres/rabbitmq users).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the useful behavioral note that password fields are omitted from the output, but says nothing about pagination, ordering, or whether listing spans all namespaces by default.

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 single short sentence is front-loaded and free of filler, which is good. But its brevity comes at the cost of under-specification: it restates the title verbatim and provides no additional structure or detail.

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

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

For a paginated, cluster/namespace-scoped listing tool with four undocumented parameters and no output schema, the description leaves out the information an agent needs to call it correctly — required scoping, pagination semantics, and how it differs from the numerous other user/role list tools.

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 four parameters (cluster, namespace, limit, cursor) are undocumented in the schema. The description does not mention any of them — it does not explain that cluster is required, that namespace narrows scope, or that limit/cursor drive pagination, so it fails to compensate for the coverage gap.

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

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

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g., whether a cluster or namespace is required to scope results), and no pointer to database_user_get or the sibling user-list tools. Usage must be inferred entirely from the name and title.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds nothing beyond that: no word on whether results are scoped per cluster or namespace, no pagination behavior for the cursor/limit pair, and no note about scoping to the caller's own keys.

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?

It is short, but this is under-specification rather than conciseness — the single line duplicates the title and carries no information an agent could act on.

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 paginated list tool with four undocumented parameters, no output schema, and no description of return shape or ordering. The definition is entirely inadequate 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% and the description mentions no parameters at all. Three of the four parameters (limit, cursor, cluster) are bare types with constraints only, and the agent gets no explanation of what cursor is for or how namespace filtering interacts with the required cluster argument.

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?

Tautological: description restates name/title.

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

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

There is no guidance whatsoever on when to use this tool, what prerequisites exist, or which sibling to pick instead. An agent must guess whether this lists keys for a cluster, a namespace, or both.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered elsewhere. The description contributes nothing beyond that: no mention of what identifying a role requires, how scoping via namespace works, or what happens when the role is 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?

It is short, but the brevity comes from under-specification rather than economy: the single sentence duplicates the title verbatim and front-loads no useful constraint. There is no wasted filler, but there is also no substance for the sentence to earn its place with.

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, and the tool takes three parameters (two required) with an interesting namespace scoping model that is left unexplained. For a lookup tool returning a role definition, the description should at minimum state what entity is retrieved and how the inputs identify it, which it does not.

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% for the three top-level parameters; cluster and role are required and carry only pattern/length constraints with no stated meaning. The description does not compensate at all, leaving it unclear whether "role" is a role name, an ID, or a path segment, or how namespace scoping interacts with cluster.

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?

Tautological: description restates name/title.

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 when-to-use, when-not-to-use, or alternative is mentioned. There is an obvious sibling (elasticsearch_roles_list) for enumerating roles, and the description gives no signal that this tool is for fetching one role given cluster and role name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that — no mention of pagination behavior, default result size, or what happens when a cluster or namespace does not exist.

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 text is a single short phrase with no wasted words, but that brevity comes at the cost of substance — it is under-specified rather than concise. There is no front-loaded explanation of scope, pagination, or required inputs.

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 paginated list tool requiring a cluster identifier and optionally scoped by namespace, the description is far too thin: it omits pagination mechanics and scoping semantics. Annotations cover the read-only safety profile, which prevents a lower score, but an agent would still have to infer most invocation behavior from the schema.

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

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

Schema description coverage is 0% and there are four parameters, yet the description explains none of them. It does not clarify that 'cluster' is required, that 'limit' caps results at 500 with a default of 100, that 'cursor' is a pagination token, or that 'namespace' scopes the listing.

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?

Tautological: description restates name/title.

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

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

There is no explicit guidance on when to use this tool versus alternatives; the plural name weakly implies a collection listing while elasticsearch_role_get fetches a single role, but that inference is left entirely to the agent. No prerequisites, scoping context, or exclusions are mentioned.

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

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

Annotations declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is already known. The description adds nothing beyond that: no statement about what happens when the user or cluster does not exist, no note on auth scope, and no return-shape expectation.

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?

It is brief, but that brevity is under-specification rather than economy: four words repeat the title and convey no extra meaning. Nothing is front-loaded because there is no content to front-load.

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 and one of three parameters is undocumented, with two required parameters carrying only regex patterns. Given the dense family of sibling *_get/*_list tools, the description needs to identify the resource precisely and does not.

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% for the three parameters; 'cluster' and 'username' have no descriptive text in either the schema or the description. Only 'namespace' is documented via $defs, and the description does not compensate for the two undocumented required parameters at all.

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?

Tautological: description restates name/title.

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 when-to-use guidance, no prerequisites, and no reference to the obvious alternative elasticsearch_users_list. The only hint at single-item retrieval is the required 'username' parameter, which is inference from the schema rather than stated 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 annotations establish that the operation is read-only, idempotent, and non-destructive, and the description does not conflict with them. It adds no behavioral context beyond that profile, such as cluster scoping, pagination behavior, or how namespace affects the 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 wording is short and front-loaded, but its brevity results from omitting all operational detail rather than communicating efficiently. Duplicating the title adds no value.

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

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

The schema supplies basic types, constraints, and a default limit, while the annotations establish read safety, so a minimal invocation is partly inferable. However, with no output schema and no explanation of cluster scope or cursor pagination, the definition remains incomplete for reliable selection and use.

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

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

With 0% schema description coverage, the description needed to explain cluster, namespace, limit, and cursor, but it mentions none of them. It provides no additional meaning about required cluster scope, namespace selection, result limits, or cursor-based pagination.

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?

Tautological: description restates name/title.

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

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

There is no explicit when-to-use guidance or routing to elasticsearch_user_get when a single known user is needed. "List" implies collection retrieval, but no prerequisites, alternatives, or when-not conditions 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new context: authorization is enforced per event class and filters compose conjunctively with exact matching for actor/resource. It says nothing about retention/durability limits, result ordering, or how cursors behave, which are the remaining behavioral questions for a paged log.

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

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

Two sentences, front-loaded with purpose then permissions then filter semantics; every clause after the first carries information. The only waste is the duplicated title sentence, which consumes space without adding meaning.

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

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

With 9 undocumented parameters, no output schema, and pagination parameters (limit/order/cursor) present, the description leaves an agent unsure about return shape, page traversal, and default ordering. For a tool of this surface area, permission notes alone are not enough.

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% across 9 parameters, so the description must carry the semantic load, but it only explains three of them (namespace, actor, resource) and one composition rule. Nothing is said about type, cluster, operationId, limit, order, or cursor — arguably the parameters most likely to be misused on a paged log.

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 sentence names a specific verb and resource (list / durable authorization-filtered event log) and the follow-up enumerates the three event scopes (cluster, namespace lifecycle/mutation, global audit), which sharpens what kind of records come back. However, the first sentence is a verbatim restatement of the title, and it never differentiates this from nearby list tools such as operations_list or member_logs_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 gives per-scope permission prerequisites (events:read vs audit:read on specific resource paths), which implicitly tells the agent when a call will succeed. It offers no explicit when-to-use/when-not-to-use guidance and never points at an alternative tool for a related need.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description contributes nothing beyond that — no indication of what 'health' means (liveness vs readiness vs per-component status), whether it can be slow or fail during an outage, or how it relates to cluster-level health endpoints.

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?

It is a single front-loaded phrase with zero waste, but it is under-specified rather than concise — the brevity comes from having no content rather than from tight writing. Acceptable in form, empty in substance.

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

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

With no output schema to explain return values, the description is the only place the agent could learn what this call yields, and it says nothing. For an operational health check used in incident triage, that omission leaves the agent unable to interpret or trust the result.

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

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

The tool takes zero parameters and schema coverage is 100%, so there is nothing for the description to clarify. Baseline 4 applies for a parameterless tool.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no exclusions, and no named alternatives anywhere in the description. The agent must infer from the tool name alone that this is a liveness/readiness check rather than a diagnostic.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds nothing beyond that: no mention of how log lines are fetched (streamed vs snapshot), what ordering is used, whether logs persist after a process restarts, or any rate/size constraints.

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 single sentence is short and front-loaded but earns no place: it duplicates the title verbatim and conveys no information an agent does not already have from the name. Conciseness here reflects under-specification rather than efficiency.

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

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

With 7 parameters, no output schema, and pagination plus time-window inputs, this tool needs substantially more description than one duplicated sentence. Nothing tells the agent how to page with cursor, how since interacts with lines, or what the returned log records look like, leaving the definition inadequate for correct invocation.

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

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

Schema description coverage is only 14%, so the description is expected to compensate for the six undocumented parameters (lines, since, cursor, member, cluster, process). It only echoes 'member process', giving no meaning for cursor-based pagination, the 'since' timestamp semantics, or the default 100 / max 10000 lines behavior; the single documented parameter (process) already has its description 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?

Tautological: description restates name/title.

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

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

There is no guidance on when to use this tool versus alternatives: nothing distinguishes it from events_list or cluster_diagnose, and no prerequisites (cluster reachability, permissions on the member's namespace) are mentioned. The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description contributes nothing beyond that — no mention of what retrieval returns, whether missing databases error or return empty, or any cross-namespace scoping 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?

It is a single short sentence, so there is no verbosity, but this is under-specification rather than conciseness. The one sentence duplicates the title and earns no additional information for the agent.

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 three-parameter get tool with no output schema and near-zero parameter documentation, the description should explain what identifier combination is required and what object is returned. None of that is present, leaving the agent to guess at both inputs and result shape.

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 essentially 0%: 'cluster' and 'database' are bare strings with only pattern/length constraints, and only 'namespace' carries a description via $defs. The description does nothing to explain what 'cluster' identifies (cluster name? ID?) or what form a 'database' value takes, so the two required parameters remain semantically opaque.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative is named. An agent must infer from the name alone that this fetches a single database rather than listing databases, which is exactly the ambiguity mysql_databases_list creates.

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

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

Annotations already establish readOnly, idempotent, non-destructive, closed-world behavior, so safety is covered. The description adds nothing beyond that: no indication of whether results are cluster-wide or namespace-scoped, and no pagination, ordering, or volume characteristics.

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?

It is a single short sentence with no wasted words, but that is because it carries no content. This is under-specification rather than conciseness, and nothing is front-loaded beyond the bare action.

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

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

With two undocumented parameters, no output schema, and a mutation-free read tool, the description should at minimum state the required cluster scope and what the namespace filter does. It leaves an agent unable to know what it must supply to call the tool correctly.

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

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

Schema description coverage is 0% for both parameters. The description never mentions the required 'cluster' argument or the optional 'namespace' filter, so it does not compensate for the schema gap at all.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use information, no mention of alternatives (e.g. mysql_database_get for a single database, postgres_databases_list for other engines), and no note about required scoping. The 'list' verb only implicitly suggests enumeration.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds one genuinely non-obvious behavioral constraint (at least one filter must be supplied) that the schema does not enforce, but says nothing about result shape, volume, or what happens with an unknown user/database.

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

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

Two sentences, front-loaded with the action and immediately followed by the hard constraint. The first line largely restates the title, which is the only wasted space.

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

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

For a read-only list tool with full annotation coverage and no output schema, the essentials are present, but an agent still cannot tell what a 'grant' record contains, whether results are scoped by cluster/namespace, or how the required cluster parameter relates to the filters.

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 only clarifies 'user' and 'database' as filters and the one-of requirement; 'cluster' is required yet never explained, and 'namespace' scoping is not addressed in the description at all, leaving half the parameters undocumented.

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

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

States a specific verb and resource ('List MySQL grants') plus the two filtering dimensions, which implicitly separates it from postgres_grants_list and from the mysql_users_list / mysql_databases_list siblings. It never names an alternative explicitly, but the engine and object type are 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 second sentence gives a real invocation rule ('At least one of user or database is required; both may be supplied'), which is useful. There is no guidance on when to reach for this tool versus mysql_user_get, permissions_get, or postgres_grants_list, so usage context is only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds no behavioral context beyond that — no note about failure modes for missing users, required permissions, or scope (namespace/cluster boundary).

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?

It is a single short sentence with no filler, but its brevity is under-specification rather than conciseness — the same six words appear in the title and add no 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 read tool with three parameters, no output schema, and no parameter documentation, the description leaves an agent without the information needed to call it confidently or distinguish it from sibling lookups.

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 two of the three parameters (user, cluster) carry only regex patterns, not descriptions. The description does nothing to explain what these identifiers mean, so it fails to compensate for the coverage gap.

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

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

Tautological: description restates name/title.

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

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

There is no guidance on when to use this versus mysql_users_list or the generic database_user_get. The agent must infer the get-vs-list distinction purely from the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds no behavioral context of its own — no mention of scope (cluster-wide vs namespace-scoped), whether results include system users, or whether the list is paginated.

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 single sentence is tight and front-loaded with the verb, but it is under-specified rather than genuinely concise — the brevity comes from omitting information, not from economy of expression.

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 two-parameter listing tool with no output schema, the description should at minimum say what is listed and how cluster/namespace scope the results. Neither is addressed, so an agent cannot confidently predict the response shape or the effect of omitting 'namespace'.

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%: 'cluster' has no description at all, and 'namespace' only inherits documentation from the $defs reference. The description does not compensate — it says nothing about what 'cluster' identifies or that 'namespace' optionally narrows the listing to a single project namespace.

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?

Tautological: description restates name/title.

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

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

There is no guidance on when to use this tool versus mysql_user_get, database_users_list, or the equivalent users_list tools for other backends. The agent must infer that this is the MySQL-specific enumerator from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: it does not say what 'token status' or 'relay health' entail, what happens for an unknown namespace, or whether partial results are possible.

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 single-phrase form is front-loaded and free of filler, but it is under-specified rather than genuinely concise; the three-part resource list is a list of nouns without any connective guidance.

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

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

With no output schema, no annotation gaps, and only one parameter, the tool is simple enough that a short description could suffice. Still, the reader is left without any picture of the return shape for the three reported aspects, which a reader of a compound 'getter' would reasonably want.

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?

There is one required parameter whose meaning the description never elaborates; the only constraint text lives in the $defs schema and is reported as 0% description coverage. Nothing in the description clarifies that the tool is scoped to a single namespace, or what happens with the reserved default namespace.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance at all: no statement of the scenario that selects this getter over namespaces_list or health_get, no prerequisites, and no exclusions. The agent must infer usage purely from the tool name.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-obvious behavior beyond that: per-item permission filtering on the namespace name occurs before pagination (so pages can be short or empty), and no global wildcard grant is needed to call it. What is missing is any statement about result ordering or what a namespace record contains.

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

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

Two short sentences, front-loaded with the core action and followed by the key caveat. The first sentence largely repeats the title, which is mild redundancy, but there is no filler or hedging.

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

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

For a read-only list tool with annotations and only two optional parameters, the definition covers the important access-control surprise but leaves pagination semantics and the shape of returned namespace objects unexplained, and there is no output schema to fill that gap. Adequate to call correctly, incomplete for interpreting results.

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 schema documents neither limit nor cursor beyond types, defaults, and bounds. The description alludes to pagination existing but gives no meaning for limit/cursor, no max-page behavior, and no indication of whether filtering affects the effective page size relative to the limit. With low coverage the description should compensate and does not.

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

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

States a specific verb and resource ("List readable project namespaces") and adds the scope qualifier "readable," which distinguishes it from a raw namespace listing such as namespace_get. It does not explicitly name a sibling to route against (e.g. temporal_namespaces_list or namespace_get), so it falls short of the 5 bar.

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

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

Usage is only implied: the note that results are filtered by namespaces/read tells an agent this is a visibility-scoped enumeration, but there is no explicit "use this when..." or exclusion pointing to namespace_get or temporal_namespaces_list. An agent must infer the routing from the tool name alone.

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

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

The annotations already establish readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one genuinely useful domain fact — that every Community user has full administrative privileges — which tells the agent the returned identity is always privileged. It does not say what happens for a nonexistent user or what the response contains.

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

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

Two short sentences, front-loaded with the operation and followed by the one piece of context worth stating. Nothing is padded, though the second sentence could be tied more explicitly to why an agent should care.

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 three-parameter lookup with no output schema and zero parameter descriptions, the definition leaves too much unsaid: it never explains the cluster/namespace scoping, the identifier format for 'user', or what a successful read returns. The privilege note is helpful but does not fill those 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% for the top-level parameters: 'cluster' (with a strict lowercase pattern) and 'user' carry no descriptions, and the description adds no meaning for either. Only 'namespace' is documented, via the referenced NamespaceName definition, so the description fails to compensate for the coverage gap.

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

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

The description states a specific verb and resource: 'Read a Neo4j Community user.' That is enough to distinguish it from the plural sibling neo4j_users_list, though the singular/plural split is left implicit rather than named. It does not mention the cluster or namespace scoping that the schema requires.

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

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

There is no explicit guidance on when to use this tool versus neo4j_users_list, database_user_get, or other per-backend user getters in the sibling set. Usage is only inferable from the verb 'Read' plus the singular resource name, and no prerequisites or exclusions are 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?

Beyond the read-only and non-destructive annotations, the description discloses that Community users have full administrative privileges and that the managed neo4j administrator is omitted. These are useful security and result-visibility details, although other read behavior such as result formatting is not described.

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

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

Three short sentences front-load the operation and then add the privilege and visibility caveats without filler. The wording is easy to scan and appropriately sized for a simple list 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 purpose, privilege implications, and an important result exclusion are covered, while annotations establish safe-read behavior. Missing cluster/namespace targeting semantics and limited information about the returned representation leave avoidable gaps, particularly because there is no output schema.

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

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

The description never explains cluster or namespace, how namespace affects the listing, or what happens when the optional namespace is omitted. With reported 0% schema description coverage, it adds no parameter meaning and does not compensate for the documentation 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 opening line states a specific verb and resource: listing Neo4j Community users. It clearly conveys the basic operation, but does not explicitly differentiate this tool from neo4j_user_get or the broader database_users_list.

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

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

There is no explicit guidance on when to enumerate users, when to retrieve a single user instead, or how this tool differs from database_users_list. The hidden-administrator note limits the expected results but does not provide meaningful tool-selection 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 annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false and idempotentHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that: it does not say what happens when the channel does not exist, what identifier form is accepted, or what the response contains.

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 text is four words with zero waste, but that brevity comes from under-specification rather than economy; it is a verbatim echo of the title and carries no front-loaded information beyond the resource name.

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?

Although this is a simple one-parameter read tool, there is no output schema, so the description should at minimum indicate what a channel object looks like or how the identifier is formed. Neither is present, leaving the agent guessing on both input format and return shape.

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 the single parameter 'channel' is a bare string with only length bounds. The description does not clarify whether 'channel' is a name, an ID, or a slug, so it fails to compensate for the complete absence of schema documentation.

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

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

Tautological: description restates name/title.

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

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

There is no when-to-use guidance and no mention of the obvious alternative, notification_channels_list, which would be the natural choice for enumeration. At best an agent can infer from the singular resource name that this retrieves one channel, but nothing is stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered without the description. Beyond that, the description adds nothing: no pagination behavior, no ordering, no indication of what happens when the collection is empty or how cursor exhaustion manifests.

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?

It is a single short sentence with no wasted words, and the key concept is front-loaded. However, the brevity comes from omission rather than discipline, leaving the definition under-specified for an agent.

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 paginated list tool with no output schema and zero parameter documentation, the description should explain paging and what a channel record contains. Nothing an agent needs beyond the annotations is present.

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

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

Schema description coverage is 0%, so the description carries the burden for both parameters and says nothing about them. The names limit and cursor and their defaults/bounds (1-500, default 100) imply pagination, but the description never confirms or explains the paging contract.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance, no mention of the sibling notification_channel_get for fetching a single channel, and no prerequisites or exclusions. The agent can only infer usage from the verb "List" in the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description contributes one genuinely useful behavioral fact beyond that — the result set is scoped to the caller's own grants unless the caller is an administrator — but says nothing about result volume, pagination, or what fields are exposed.

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

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

A single short sentence with the resource up front and the scoping caveat in parentheses — zero waste and well front-loaded. It is essentially a restatement of the title, so it is concise but adds little new phrasing.

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 zero-parameter, non-destructive read with no output schema, the description covers what is listed and whose grants are visible, which is close to sufficient. It omits any indication of what a grant record contains (client name, scopes, dates) and whether results are paginated, so it falls just short of fully self-sufficient.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing for the description to disambiguate. The scope note correctly implies the result set varies by caller role rather than by an input argument.

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?

Tautological: description restates name/title.

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

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

Usage is implied by the purpose: call this to enumerate connected OAuth applications. There is no explicit when-to-use/when-not guidance, no mention of alternatives (e.g., api_tokens_list for API tokens), and no prerequisites, so the agent must infer context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds no behavioral context beyond that — nothing about what a connection record holds, whether secrets/credentials are redacted, or whether it errors on unknown connections.

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?

It is short, but it is short because it is under-specified rather than economical — there is no sentence structure or front-loaded information, just an identifier. There is nothing to trim, but nothing earning its place either.

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 three-parameter lookup with a required `cluster` plus `connection` and an optional `namespace`, the description supplies nothing: no identifier format for `connection`, no note on namespace defaulting, and no output schema to fall back on. It is completely inadequate relative to the tool's shape.

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 the description names none of the three parameters. The agent gets no meaning for `cluster` (no pattern explanation in prose), `namespace` (a $ref whose constraints live only in $defs), or `connection` (a bare unbounded string with no hint of its identifier format).

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?

Tautological: description restates name/title.

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

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

There is no guidance at all about when to use this tool, when not to, or which sibling to prefer. With `openbao_database_connections_list` present in the sibling set, the agent must infer that this is the single-item variant purely from naming convention.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that — no note on scoping behavior, pagination, result volume, or what happens if the cluster has no connections.

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?

It is a single front-loaded sentence with zero filler, which is structurally sound, but the brevity is under-specification rather than discipline — the same word count could have carried the cluster/namespace scoping.

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 list tool with a required cluster selector, an optional namespace filter, and no output schema, the definition should say what a required cluster means and roughly what is returned. None of that is present, so the description is not complete enough to invoke confidently without inspecting the schema.

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

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

Schema description coverage is 0%: the required "cluster" parameter has only a regex/max-length constraint and no prose, and the description supplies no meaning for either cluster scoping or the optional namespace filter. With two parameters and no compensating explanation, the description leaves the agent to guess what "cluster" identifies.

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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance at all: no mention of prerequisites, no exclusions, and no pointer to openbao_database_connection_get for fetching a single connection. An agent must infer usage purely from the name.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description does add beyond that: authorization is scoped to the operation's persisted namespace/cluster object, and the ID is globally unique and must be resolved first — useful auth/sequencing context, though phrased cryptically. It says nothing about behavior when the operation is not found or how a durable operation's state evolves.

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

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

Two short sentences, no filler, and the operation subject is front-loaded. The second sentence is dense with internal jargon ("persisted namespace/cluster object") in a way that costs clarity more than it costs 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?

There is no output schema and the description never indicates what is returned — status, progress, timestamps — nor whether the caller should poll or hand off to `wait`. For a tool whose entire value is inspecting a long-running durable operation, that return-semantics gap leaves the agent under-informed about how to use the result.

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

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

Schema description coverage is 0% for the single `operation` parameter, so the description must carry the semantic load. It does contribute that the value is a globally unique ID requiring prior resolution, but it gives no format, source, or example of where such an ID comes from (presumably operations_list), leaving the parameter only partly illuminated.

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?

"Read a durable operation" is essentially the tool name and title restated, adding only the adjective "durable." It never explains what an operation object is or how this differs from sibling readers like operations_list and cluster_operations_list, so an agent gets no discriminating signal.

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

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

The second sentence supplies a real prerequisite — the globally unique operation ID must be resolved before calling — which implies the fetch-single-resource context. However, there is no explicit when-to-use versus operations_list, no mention of the related `wait` sibling for polling, and no stated conditions under which this call is inappropriate.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the description only needs to supplement. It does add that results are filtered by cluster RBAC object and include the global collection, which is genuine context, but it says nothing about pagination via limit/cursor or what 'durable' means in practice.

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

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

Two short sentences, front-loaded with the action and followed by the scoping rule; no filler. The repetition of the title as the first line is mildly redundant but harmless.

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 paginated list tool with five undocumented parameters, no output schema, and no explanation of page size limits, cursor iteration, or valid phase values. The RBAC filtering note is helpful but far from what an agent needs to call this correctly.

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

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

Schema description coverage is 0% for five parameters, so the description carries the full burden and largely fails: limit, cursor, phase, cluster and namespace are never mentioned. The phrase 'cluster RBAC object' only loosely gestures at the cluster parameter's meaning.

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

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

States a specific verb and resource ('List ... operations') and adds a scope qualifier ('durable', RBAC-readable), which is more than a restatement of the name. It does not distinguish itself from near siblings such as operation_get or cluster_operations_list, so an agent must infer the difference.

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 statement of when this list should be preferred over operation_get or cluster_operations_list, and no prerequisites or exclusions. Only the implicit 'listing' semantics of the name convey usage.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile needs no restating. The description adds real context beyond that: records persist after cluster deletion, a background janitor retries with backoff, and results are permission-filtered per cluster — the last point is important because it tells an agent an empty list may reflect authorization rather than absence. It stops short of describing result shape or ordering.

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?

Front-loaded with the title line then a tight definitional paragraph. Every sentence carries information; the only redundancy is the first line echoing the tool title verbatim, which costs a few tokens without adding meaning.

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 listing with one optional filter and no output schema, the description supplies the essential domain context (what makes a volume orphaned, why records linger, who can see what). It leaves the namespace filter's semantics and any pagination/ordering behavior unexplained, which is the remaining gap.

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

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

The schema is reported at 0% description coverage, and the description adds nothing about the single optional `namespace` parameter — not what it filters, nor whether omitting it returns all namespaces. That gap matters for a list tool with exactly one knob.

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

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

States a specific verb and resource (list orphaned platform volumes) and immediately defines the term of art: volumes whose owning runtime is absent and whose deletion requests to Zerops have failed. That definition is not restated from the name and lets an agent distinguish this from generic storage or cluster listings without opening the schema.

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

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

The qualifying condition for what appears in the list is clear, which implies the diagnostic use case (lingering storage after runtime/cluster disappearance). However, there is no explicit when-to-use versus siblings (e.g. namespaces_list, clusters_list, backup_storages_list) and no statement about when this tool is not the right one.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description's real contribution is the authorization requirement for cross-subject evaluation, which is genuinely useful. It never states the outcome form (an allow/deny decision) or whether an unauthorized check returns an error versus a denial, which leaves a behavioral gap beyond the annotations.

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

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

Two sentences, no filler, and the self/other-subject constraint is front-loaded. The only waste is the first line echoing the title rather than using that space to explain the 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?

With no output schema, the description carries the burden of explaining what comes back, yet it never says whether the result is a boolean decision, an error, or an effect list. For an evaluation/decision tool with a nested request object and a wildcard action, the absence of result semantics and object-format expectations is a notable 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?

There is one top-level parameter (`body`) wrapping a nested CanRequest, and schema description coverage is 0% apart from the `subject` property, which already carries the exact statement about rbac read permission. The description therefore duplicates the one documented field and adds nothing about `resource`, `action` (including the `*` wildcard), or `object` format.

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 by restating the title verbatim ("Evaluate an authorization tuple") and never explains in plain terms that the tool answers whether a given subject may perform an action on an object. The second sentence does add scope (self-check vs. other-subject check), but the core operation stays framed in opaque jargon that isn't disambiguated from sibling tools like `check`-style or `rbac_*` tools.

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

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

It gives one useful context cue: a caller can check its own permissions, and checking another subject requires 'rbac read' authorization. That is a permission prerequisite rather than selection guidance; there is no statement of when to use this versus related tools like `rbac_*` or any allow/deny-tool alternative, but the caller-vs-subject distinction does orient an agent's choice.

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?

While annotations cover safety (readOnlyHint: true), the description adds valuable context by specifying that it resolves permissions for the 'current subject and its OIDC groups,' clarifying the data focus beyond mere operation 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 definition is extremely concise, using two sentences to cover purpose, scope, and differentiation. There is zero wasted language, and the structure is logical.

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 zero parameters, the description is completely sufficient for an agent to determine applicability and function accurately.

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 tool has zero parameters, meaning the description cannot elaborate on input parameters. Baseline for 0 parameters is 4, and the description adds context about the scope of the retrieved data.

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 specific language ('Resolve caller permissions and role inheritance') defining the action and the exact resource. It clearly states the tool's function without ambiguity.

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 exceptional guidance by defining its scope ('Self-service') and, critically, contrasting its behavior with sibling tools ('Lists elsewhere are filtered per object'), instructing the agent on when to use it and when to avoid 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?

Goes well beyond the readOnly/idempotent/non-destructive annotations by disclosing concrete failure semantics: 409 invalid_state for initializing clusters lacking a ready replica set or backup storage, and 400 invalid_request with reason 'unsupported' for engines without PITR. It also explains availability behavior during scaling, upgrades, resource changes, joins and reloads, and that live agent/storage failures can still affect availability.

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?

Front-loaded with the purpose, then error and availability semantics in three compact sentences with no filler. The opening clause merely restates the title verbatim, which is minor redundancy rather than bloat.

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?

Error paths and availability caveats are thoroughly covered, but with no output schema the description should characterize the returned interval (e.g. time bounds, whether it is empty) and it only says 'latest continuous backed interval'. Combined with the unaddressed namespace parameter, the definition is adequate but incomplete for a read tool with no output schema.

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

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

Schema description coverage is 0% for the top-level properties, so the description should compensate but says nothing about 'cluster' (the required identifier) or 'namespace' (optional scoping and its default behavior). Only the $defs entry for NamespaceName carries any documentation, so an agent gets no added meaning from the description for the parameters that matter.

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

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

States a specific verb and resource ('Read the continuous restorable PITR window') and clarifies it returns the latest continuous backed interval, which is a meaningful scope statement. It does not name any sibling (e.g. backup_get, restores_list, backup_storage_get) or explain how it differs from those backup-oriented reads, so differentiation is left to the caller.

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

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

Usage is only implied: an agent can infer this is the tool for checking restorable coverage of a cluster. There is no explicit 'use this when…' statement, no guidance versus backup_get or restores_list, and no stated prerequisites (though prerequisite failures are described as 409s).

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