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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds the concrete contents of the summary, which is genuine value for a tool with no output schema, though it says nothing about missing-cluster errors or namespace/context fallbacks.

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 tight sentence that front-loads the action and resource and then lists the payload. Nothing 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?

With no output schema, the field enumeration usefully stands in for documented return values, and annotations carry the safety profile. It is nearly sufficient, losing a point only for leaving the distinction from get_cluster_status and error behavior unstated.

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

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

Schema description coverage is 100% and all three parameters (name, context, namespace) are documented in the schema, including defaults. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb+resource ('Summary of a PerconaPGCluster') and enumerates the content returned (state, PostgreSQL size, PgBouncer, version, standby, host). It does not explicitly distinguish itself from the nearby sibling get_cluster_status, so it stops short of a 5.

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

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

No when-to-use guidance, no prerequisites, and no alternative named. With get_cluster_status and get_connection_info among siblings, the agent is left to infer when a summary is preferable.

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 structurally. The description adds the content shape of the status object, which is useful, but says nothing about failure modes (e.g. cluster not found) or how the raw output differs from formatted alternatives.

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 with an em-dash list of contents; nothing is wasted. It is slightly terse for a tool with no output schema, which keeps it from a 5.

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

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

With no output schema, the description carries the burden of describing return values; it names the top-level sections but not their structure or nesting, which is only partially sufficient for an unstructured status object. Nothing about errors or empty results is covered.

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

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

Schema description coverage is 100%: name, context, and namespace are each documented in the schema. The description adds no additional meaning, syntax, or defaults beyond that, so the baseline 3 applies.

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

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

The description names a specific resource (the `.status` of a PerconaPGCluster) and enumerates what it contains — Patroni members, PostgreSQL/PgBouncer readiness, host, conditions. This makes it distinguishable in intent from `get_cluster`, though it never explicitly draws that contrast, so it falls short of a 5.

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

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

There is no guidance on when to call this versus `get_cluster` or `get_connection_info`, both of which likely surface overlapping cluster information. The word 'raw' hints at a lower-level alternative but the condition for choosing it is left entirely to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful non-obvious context beyond that: that only user names are exposed and passwords live in Secrets and are never returned, which prevents an agent from expecting or requesting credentials.

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

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

A single sentence that front-loads the core payload (primary/replica hosts, port, users) and appends only the one caveat that matters (passwords never returned). 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?

With no output schema, the description carries the burden of describing the return and does so adequately — endpoints, port, and user names. It could have clarified structure (e.g., how primary vs replica hosts are distinguished or whether a list is returned), but nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100% — name, context and namespace are each documented inline (including the PERCONA_NAMESPACE default). The description adds no parameter-level detail, so the baseline 3 applies.

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

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

The description names a concrete verb-less but clear retrieval target — connection endpoints for a cluster — and enumerates the returned fields (primary/replica Service hosts, port, declared users), so an agent knows exactly what this returns. It does not, however, contrast itself with close siblings like get_cluster or get_cluster_status, which also operate on a cluster.

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, when-not-to-use, or alternative-tool guidance. The description only states what data is returned; an agent must infer that this is the tool for connectivity details rather than configuration or status.

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, covering the safety profile. The description adds the useful detail that the config spans replicas and pool tunables, but says nothing about permissions, defaults, or failure modes on a nonexistent cluster.

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 tight sentence with the resource and its contents front-loaded and zero filler. The trade-off is that it is a bare noun phrase that never states the action, making it slightly terse.

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

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

With no output schema, the description does the work of naming what is returned (replicas, pool_mode, global pool tunables), and all three parameters are schema-documented. It is nearly complete for a simple read tool, missing only notes on behavior for missing clusters or namespaces.

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

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

Schema coverage is 100%, so name, context, and namespace are already documented in the schema. The phrase 'for a cluster' loosely ties to the required name parameter but adds no format or default detail beyond the schema. Baseline 3 applies.

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

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

States the resource clearly (PgBouncer settings for a cluster) and enumerates the content returned: replicas, pool_mode, and global pool tunables. This separates it well from get_pg_parameters and get_cluster, though the verb is only implied by the 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?

The description is a noun phrase with no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_pg_parameters or get_cluster. An agent must infer its place among the sibling read tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the useful Patroni-specific behavioral fact that direct postgresql.conf edits are reverted, giving real context beyond annotations, but discloses nothing about the returned shape or failure modes.

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 with a tight parenthetical; every clause adds information. Slightly dense but no waste.

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

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

For a simple read tool with full schema coverage and no output schema, the definition is adequate but does not describe what the returned parameters look like. An agent knows what to fetch but not the response format.

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

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

Schema description coverage is 100%, with name, context, and namespace all documented inline, so the schema carries the burden. The description adds no parameter syntax or defaults of its own; baseline 3 applies.

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

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

The description names the exact resource (tuned PostgreSQL parameters) and pinpoints the source path `spec.patroni.dynamicConfiguration.postgresql.parameters`, which lets an agent distinguish it from get_pgbouncer_config and get_cluster. It lacks an explicit retrieval verb, but the resource and source are specific enough to convey purpose.

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

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

Usage is implied rather than stated: the agent can infer this is the read path for PostgreSQL tuning. The 'only correct place to set them' remark hints at write semantics but never says when to prefer this tool over siblings like get_cluster or get_cluster_status, and gives no prerequisites.

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, so the safety profile is fully covered. The description adds useful value by naming the returned fields (state, repo, completion time) with no output schema present, but says nothing about pagination or filtering 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?

A single front-loaded sentence with no filler; the scope and returned fields come before any secondary detail. Appropriately sized for a simple list tool, though slightly terse.

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

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

For a simple read-only list with full schema coverage, complete annotations and no output schema, the description is nearly sufficient: it names the resource and the fields returned. Minor gaps remain around defaults behavior, which the schema already covers.

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

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

Schema description coverage is 100%, so both 'context' and 'namespace' are fully documented in the schema. The description only obliquely references the namespace scoping and adds no format or default-syntax detail beyond the schema.

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

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

States a specific verb ('List') and resource ('PerconaPGBackup resources') scoped to a namespace, and names the fields surfaced. An agent can tell it apart from list_restores and list_clusters by the resource type, though no sibling is explicitly referenced.

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 only states what the tool does; it never says when to reach for it versus sibling tools like list_restores or get_cluster_status, nor any prerequisites or exclusions. Usage is left entirely to inference 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 readOnly, idempotent, non-destructive, and openWorld, so safety is covered. The description adds real behavioral context beyond that: results are constrained by namespace/cluster allowlists and protected clusters are flagged in the output, which tells the agent results may be silently incomplete and that a protection marker should be expected.

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-loaded with what the resource is before the scoping and filtering caveats. No sentence is redundant; the parenthetical and the allowlist note each carry distinct 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?

No output schema exists, but the description compensates by noting allowlist filtering and protected-cluster flagging, which is exactly the return-side nuance an agent needs. Combined with full parameter coverage and rich annotations, nothing material is missing for a 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 coverage is 100%, so the baseline is 3. The description goes slightly beyond the schema on `namespace`: the schema only says it defaults to PERCONA_NAMESPACE when set, whereas the description explains that omitting it widens the query to all namespaces - a meaningful semantic the schema does not state. The `context` parameter is left entirely to 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?

Specific verb (List) + concrete resource (PerconaPGCluster) with a parenthetical clarifying that this spans PostgreSQL and PgBouncer. The singular/plural contrast with the sibling get_cluster is immediately legible, so an agent can route between them without inspecting schemas.

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

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

The description gives an invocation rule ('Omit `namespace` to list across all namespaces'), which is useful, but it never states when to prefer this over get_cluster, list_contexts, or the other list_* siblings. Usage is implied by the verb rather than explicitly scoped, leaving the agent to infer the alternative-selection logic.

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=true, and destructiveHint=false, covering the safety profile. The description adds the useful scoping detail that it reads from the loaded kube-config, but it does not go deeper into behavior such as error cases or connection requirements. This is acceptable for a simple zero-parameter list operation.

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

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

The description is a single clear sentence that front-loads the action and resource. It contains no filler or redundancy and is appropriately sized for the tool's simplicity.

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, read-only listing tool with safety annotations, the description is nearly complete. It clarifies the resource type and source (kube-config). Some extra context about the exact output format could help, but the absence is not a major gap given the straightforward nature of the operation.

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

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

The tool has zero parameters, and the schema coverage is 100% (vacuously). The description adds no parameter meaning, but none is needed; per the baseline for zero-parameter tools, this is well handled.

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

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

The description uses a specific verb 'List' with the resource 'contexts (clusters)' and clarifies the scope as 'available in the loaded kube-config'. This clearly distinguishes it from sibling list tools like list_namespaces and list_pods, which operate on different resource types.

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

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

The description makes the tool's purpose obvious enough that an agent can infer when to use it (when kube-config contexts are needed), but it provides no explicit guidance on when not to use it or how it compares to alternatives. The sibling names imply different resource types, yet no direct routing instruction is given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds that the listing includes each restore's target cluster and state, which is some useful output context but not rich behavioral detail such as pagination or error behavior.

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

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

A single sentence with the resource and scope front-loaded and no wasted words. Nothing is redundant or 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?

For a simple read-only listing tool, annotations cover the safety profile and the schema fully documents both parameters. With no output schema, the description usefully notes that target cluster and state are returned, leaving only minor gaps like pagination or result ordering.

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

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

Schema description coverage is 100%, so both the context and namespace parameters (including their defaulting behavior) are already documented in the schema. The phrase 'in a namespace' hints at the namespace parameter but adds no syntax, format, or defaulting detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb (List) and resource (PerconaPGRestore resources), scoped to a namespace, and specifies what is included (target cluster and state). This clearly distinguishes it from siblings like list_backups or list_clusters, though it does not name them explicitly.

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, no prerequisites, and no mention of alternatives. Usage is only implied by the verb and resource name.

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