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

readOnlyHint=true already covers the safety profile, so the description's added value is the return contents (tags, scan overview, immutability status), which is genuinely useful. It says nothing about permission requirements, error behavior when the reference does not resolve, or what 'immutability status' looks like.

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 wasted words. The '[READ]' marker is mildly redundant with readOnlyHint but is cheap and useful as a scan cue.

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 0% parameter documentation, the description should at minimum explain the reference format and the role of target/project/repository. It sketches the return payload but leaves the entire calling contract undocumented.

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 four parameters, so the description carries the full burden and adds essentially nothing. It never clarifies that 'reference' accepts a tag or digest, what 'target' selects, or how project/repository scope the lookup.

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

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

States a specific verb and resource ('Get one artifact') and enumerates what it returns (tags, scan overview, immutability status). The singular 'one artifact' implicitly contrasts with the plural harbor_artifacts sibling, though it never names it 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?

No when-to-use or when-not guidance. The '[READ]' prefix signals a read operation but the description never says to prefer harbor_artifacts for listing or harbor_scan_artifact for scanning, leaving the agent to infer routing from tool names 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 readOnlyHint annotation already establishes that this is a read operation, and the description's '[READ]' prefix merely repeats that. It adds no behavioral detail such as pagination semantics for the limit parameter, ordering, or whether scan overviews are summarized vs. full vulnerability data.

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 front-loaded sentence with no filler. Its brevity is appropriate structurally, though the content is too thin for the tool's complexity.

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

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

For a tool with four parameters, 0% schema coverage, no output schema, and only a readOnlyHint annotation, this description is insufficient. An agent cannot reliably infer what 'target' does or how artifacts, tags, and scan overviews are 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, so the description must compensate but does not. It mentions 'repository' only, leaving 'project', 'limit', and especially 'target' (likely a tag or digest selector) entirely undefined for the agent.

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 does identify a list operation over artifacts in a repository, but it bundles 'tags and scan overviews' into the same sentence without clarifying whether they are returned as embedded fields or separate resources. Given siblings like harbor_artifact, harbor_tags, and harbor_vulnerabilities, the scope remains ambiguous to an agent choosing between them.

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 alternative tools named, and no indication of when this should be preferred over harbor_artifact, harbor_tags, or harbor_vulnerabilities. The only contextual hint is the '[READ]' marker, which does not distinguish it from other 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=false, destructiveHint=true and idempotentHint=false, so safety is partly covered. The description adds the pre-check and post-verification discipline, which is genuine operational context. However it never explains why a 'create' is marked destructive (e.g., that re-pointing an existing tag overwrites the prior reference) and never mentions the dry_run escape hatch, which is the single most important behavioral fact for a destructive write.

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 sentence, front-loaded with the [WRITE] marker and the precondition before the postcondition; nothing is padded. It is efficient but so terse that the brevity comes at the cost of coverage rather than being purely a strength.

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 is a 6-parameter destructive write with no output schema and no annotation rationale for the destructive flag, yet the description is a single clause. An agent still lacks the artifact-addressing model, the effect of target, and the meaning of dry_run before invoking an irreversible 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?

Schema description coverage is 0% across 6 parameters, so the description carries the full explanatory burden and fails it. It only echoes the 'tag' parameter and says nothing about project, repository, reference, target (the source being tagged), or dry_run, leaving an agent to guess what 'reference' means and that target may be optional.

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 ('Create a tag') and the [WRITE] prefix flags the mutation class, which separates it from read siblings like harbor_tags and from harbor_delete_tag. It never clarifies that a tag is bound to a project/repository/reference artifact, so the resource is named but not scoped.

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?

'only if its absence was proven' is a real precondition that tells the agent to confirm non-existence first, and 'verify it appeared' is a post-condition. It stops short of naming the alternative (e.g., query harbor_tags to prove absence) or saying what to do when the tag already exists, so it falls short of the explicit when/when-not/alternatives bar.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false, so the safety profile is largely covered. The description does add two facts beyond that: only mutable (presumably non-immutable-rule) tags qualify, and no undo entry is minted, which is meaningful given the undo_list/undo_apply siblings. It does not explain what happens to referring artifacts or how failures surface.

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 sentence, front-loaded with the write marker and the verb, with zero filler. The phrasing 'no safe undo is minted' is slightly cryptic but compact.

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

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

For a destructive, non-idempotent mutation with an undocumented dry_run flag, four required path parameters, and no output schema, this is under-specified. An agent knows it deletes a tag but not what dry_run returns, what the target parameter does, or what a failure/partial-success looks like.

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

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

Schema description coverage is 0% across six parameters, so the description must compensate and largely fails to. The word 'verified' vaguely gestures at 'reference'/'tag' semantics, but project, repository, target, and especially dry_run are never explained in the description or schema.

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

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

The description states a specific verb+resource ('Delete one ... tag') with explicit scope ('one') and a precondition ('verified, mutable'), which cleanly separates it from harbor_create_tag. It does not name a sibling explicitly, 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?

There is no when-to-use guidance, no mention of when to prefer harbor_create_tag or another route, and no instruction on when to set dry_run. The only implied guidance is the 'no safe undo' warning, which is a caution rather than a usage rule.

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, and '[READ]' merely restates that. 'Show partial failures' does add genuine behavioral value, indicating the tool reports degraded probes rather than aborting, but the description never explains what a partial failure looks like, whether probes run in parallel, or how long aggregation takes.

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, front-loaded with the read tag and the core verb, with no filler. It is terse to the point of being telegraphic, which costs a little comprehension, but every word is load-bearing.

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 is an aggregation tool with no output schema, two wholly undocumented parameters, and only readOnlyHint for safety context. An agent knows roughly what it touches but not what to pass or what shape the correlated result takes, so the definition is under-specified 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 neither of the two parameters is mentioned in the description. 'target' in particular is highly ambiguous (a project, registry endpoint, or probe name?) and 'limit' is unexplained, so the description 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?

The description names a concrete activity (correlate health, volume, GC and replication probes) that clearly implies an aggregate diagnostic across the domains covered by sibling tools like harbor_health, harbor_volumes and harbor_gc_history. It does not explicitly name those siblings or state that this tool replaces calling them individually, 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?

There is no when-to-use or when-not-to-use guidance and no mention of the alternative single-domain probes that an agent could call instead. 'Show partial failures' hints at a troubleshooting scenario but never tells the agent when this aggregation is preferable to harbor_health or harbor_volumes.

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 readOnlyHint annotation already covers the safety profile, and the "[READ]" prefix merely restates it. "Current state" is a small amount of added context (it reflects a live snapshot, possibly mid-run), but nothing is said about behavior for unknown/expired IDs or about polling an in-progress run.

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 padding; the resource is stated before any qualifier. The only redundancy is the "[READ]" tag, which duplicates the readOnlyHint annotation.

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 single-resource getter with no output schema, the description is minimally sufficient to call it with a gc_id. However, with no output schema it never characterizes the returned state fields, and it leaves the "target" parameter opaque.

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. "One ... execution" hints that gc_id identifies the run, but the optional, nullable "target" parameter is entirely unexplained in both schema and description, leaving a real ambiguity for the caller.

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 and resource ("Get one Harbor garbage-collection execution's current state"), and the word "one" implicitly distinguishes it from the list-style sibling harbor_gc_history. It stops short of naming that sibling explicitly, but an agent can tell what the tool returns.

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 needing a specific gc_id rather than by any stated rule. There is no explicit when-to-use vs harbor_gc_history (listing runs) or harbor_gc_log (logs for a run), and no prerequisites such as obtaining a gc_id first.

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?

readOnlyHint=true already declares this is a safe read, and the "[READ]" prefix merely repeats that. The only added phrase, "measured truncation," is cryptic — it doesn't say whether results are capped, how truncation is reported, or whether pagination exists, which matters for a listing tool.

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

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

One short, front-loaded sentence with no filler, which is good, but the single qualifier it does include ("measured truncation") is ambiguous rather than informative, so the brevity comes at the cost of clarity.

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 documentation, and an unexplained qualifier, the definition leaves an agent unable to determine what "target" accepts or what the response contains. For a filtered list tool it should at minimum explain the scope 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 0% for both parameters, and the description mentions neither. "limit" and especially "target" (untyped string or null) are completely unexplained, leaving the agent to guess what a target is and how to format 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?

"List garbage-collection executions" gives a specific verb and resource, and the singular sibling harbor_gc_execution plus harbor_gc_log make the listing role reasonably distinguishable. The trailing phrase "with measured truncation" is not self-explanatory, but the core purpose is clear.

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

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

There is no guidance on when to use this versus harbor_gc_execution (single execution detail), harbor_gc_log (logs), or harbor_retention_executions. The agent must infer selection from sibling names 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?

readOnlyHint=true already tells the agent this is a safe read, so the description does not need to restate that. 'Bounded plain-text' is a useful addition signaling the output is truncated text rather than structured data, but it never says how large the bound is, what happens if the log is missing, or whether the log is complete for a given GC run.

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 the operation type front-loaded in brackets and no filler. It is efficient, though the terseness contributes to the gaps in parameter and usage coverage.

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 tool with no output schema and zero schema descriptions, the description should explain what the parameters mean and what the returned text looks like. Neither is covered, leaving the agent to guess at the semantics of 'target' and at log truncation behavior.

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 supplies only names and types for gc_id and target. The description does not explain that gc_id identifies which GC run's log to fetch, nor what 'target' selects (a phase, a registry, a sub-step?). With the schema silent, the description needed 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?

The description gives a specific verb and resource: 'Read the bounded plain-text log of a GC execution.' The '[READ]' tag plus 'log' distinguishes it reasonably from harbor_gc_execution, which appears to cover execution records rather than logs. It stops short of naming that sibling explicitly, so differentiation is implied rather than stated.

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

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

There is no guidance on when to choose this tool over harbor_gc_execution, harbor_gc_history, or the other log tools such as harbor_scan_log and harbor_replication_task_log. The agent must infer that this is the log-fetching counterpart 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?

Beyond the `readOnlyHint` provided in the annotations, the description provides critical behavioral context regarding the output structure, specifically that missing component health will still be visible, aiding the agent in interpreting 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 definition is perfectly concise, front-loading the action and resource, and using a semi-colon efficiently to add a secondary behavioral detail without any fluff.

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

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

For a low-complexity, read-only tool with a single optional parameter, the description is highly complete, covering the 'what' and a key 'how' regarding partial data.

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 parameter 'target' is defined vaguely in the schema; the description adds no semantic meaning, constraints, or examples of valid input values, merely listing the parameter's existence.

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

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

The description clearly identifies the tool's function as getting 'Harbor component health,' providing a specific and unambiguous purpose that distinguishes it from other management tasks.

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 tool provides a functional note about incomplete data ('unknown components remain visible'), but it does not offer explicit guidance on when to use this tool relative to other related health or diagnostics tools within the Harbor ecosystem.

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, and the description adds nothing beyond restating read-only status with '[READ]'. It does not disclose pagination behavior, how the 'target' filter restricts results, or what the returned rule objects contain.

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 read-only marker front-loaded. It is efficient, though its brevity is achieved by omitting information rather than by tight editing.

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 tool with no output schema and no parameter documentation, the description is too thin for an agent to invoke it confidently. Nothing explains what 'target' filters or what a rule looks like, which an agent needs before calling.

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 three parameters, so the description carries the burden but explains none of them. 'for a project' loosely maps to the required 'project' param, while 'limit' and 'target' are left entirely undefined.

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 a specific resource ('tag immutability rules') scoped 'for a project', which is distinguishable from siblings like harbor_retention_policy or harbor_labels. It stops short of naming the nearest alternative, so it is not 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?

The '[READ]' prefix signals a read operation, but there is no guidance on when to choose this over sibling tools such as harbor_retention_policy or harbor_tags, and no stated preconditions. Usage is only implied by the verb.

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 readOnlyHint annotation already tells the agent this is a safe read, so the "[READ]" tag adds nothing. "Measured truncation" hints that results may be capped and reported, but it does not say how truncation is signalled, what the default window is, or how to retrieve the rest.

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 the operation front-loaded, which is efficient. But the brevity is achieved by dropping necessary information, and "measured truncation" is an obscure phrase that costs comprehension rather than saving it.

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, minimal annotation coverage, and two undocumented parameters with defaults, so the description must carry most of the load and does not. It leaves undefined what a label record contains, what `target` scopes to, and how truncation is surfaced to the caller.

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 neither `limit` nor `target`. An agent gets no guidance on the default page size of 50, on what values `target` accepts, or on how the two interact, so the parameter burden is entirely 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?

"List Harbor labels" names a specific verb and resource, so the basic operation is identifiable. However, the trailing phrase "with measured truncation" is unexplained jargon, and nothing distinguishes this from sibling listing tools such as harbor_tags or harbor_artifacts.

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 only usage signal is the "[READ]" prefix, which merely restates the readOnly annotation. There is no statement of when to call this instead of harbor_tags, harbor_artifacts, or the other listing siblings, and no prerequisites or scope conditions are given.

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

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

With readOnlyHint=true already declaring the safety profile, the description's "[READ]" prefix just repeats the annotation and adds no new behavioral context. It says nothing about what happens when the name is not found, whether "target" changes the lookup scope, or what object is 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?

One short sentence, front-loaded with the resource and the read nature of the call, with no wasted words. It is arguably too terse rather than bloated, so conciseness itself is fine.

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 single-entity read with a readOnly annotation and no output schema, the definition is minimally viable, but it leaves an undocumented "target" parameter and the name-vs-ID ambiguity unresolved. An agent could call it, but not with full confidence about the second argument.

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, yet it only hints that the name field might also accept an ID. The second parameter, "target" (nullable, default null), is completely unexplained in both schema and description.

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

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

"Get one Harbor project" states a specific verb and resource, and "one" implicitly contrasts with the list-oriented sibling harbor_projects. The "by name or ID" phrase slightly muddies things since the schema's required field is only "name", but an agent can still tell what this tool retrieves.

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 [READ] tag implies a safe lookup, but there is no guidance on when to use this versus harbor_projects or harbor_project_summary, nor any stated preconditions such as project existence or permissions. The agent must infer the selection rule entirely.

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?

readOnlyHint=true already declares the safety profile, so the leading '[READ]' tag adds nothing. The description does contribute the scope caveat about MCP governance audit, but says nothing about ordering, pagination, or result volume for what is a log-listing endpoint.

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 read tag and the disambiguation clause are both immediately visible. Brevity here edges toward under-specification rather than verbosity, so it is efficient but thin.

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, 0% schema description coverage, and an undocumented 'target' parameter, the definition leaves too much unresolved for a log-retrieval tool. An agent cannot tell what 'target' filters or how 'limit' interacts with paging.

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 the burden for three parameters. It only implies 'project' via 'a project's audit logs' and gives no meaning at all for 'limit' (default 50) or 'target', leaving two of three parameters 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?

States a specific verb and resource ('List a project's Harbor audit logs') and adds a scope boundary excluding the MCP governance audit. That boundary distinguishes it from a related concept rather than from a named sibling tool, 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?

The 'not the MCP governance audit' clause is an explicit when-not, which is real guidance. However, no sibling in the list (e.g., harbor_project, harbor_scan_log, harbor_gc_log) is named as the alternative for related log lookups, so routing is only partially resolved.

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 readOnlyHint annotation already establishes the safe-read profile, and the '[READ]' prefix merely repeats it. The one piece of added behavior, 'measured truncation', is cryptic: it does not say how truncation is surfaced, whether a limit is enforced, or what happens to omitted members.

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, and the core purpose appears first. The '[READ]' tag is redundant with the annotation, which is the only wasted token.

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 only a readOnly hint, the description needed to explain the required project argument, the meaning of 'target', and how truncation is reported. It does none of these, leaving an agent to guess at invocation 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% across three parameters, so the description must carry meaning and largely does not. 'Project' is at least implied by the purpose, and 'limit' is loosely hinted at by 'truncation', but 'target' is left completely undefined in both schema and description.

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

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

The description gives a specific verb and resource: list a Harbor project's members. That is unambiguous and distinct from sibling tools such as harbor_robot_accounts or harbor_projects. It does not explicitly contrast itself with any sibling, 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?

There is no statement of when to use this tool versus alternatives, nor any prerequisites such as project existence or required permissions. The only contextual cue, 'measured truncation', is not explained as a usage condition.

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, so the safety profile is covered. The description adds two pieces of behavioral context beyond that: results are limited to projects 'visible' to the caller (permission scoping) and results may be truncated in a 'measured' way, though neither is explained well enough to act on.

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 read-only marker front-loaded and zero filler. Nothing is wasted, though the brevity comes at the cost of semantics captured in 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?

With no output schema and 0% parameter documentation, the description should explain what a project record contains, whether truncation is reported in the response, and what 'target' filters. It does none of these, leaving an agent unable to call the tool 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% for both parameters, so the description carries the full burden and fails: 'target' is never mentioned and its meaning is entirely opaque, and 'limit' (default 50) is only indirectly gestured at by 'truncation'. This is a real gap for an agent deciding what to pass.

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 visible Harbor projects'), which clearly separates the list operation from the singular sibling harbor_project. However, the trailing phrase 'measured truncation' is unexplained jargon that blurs rather than sharpens the stated purpose.

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

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

The '[READ]' tag implies a read-only listing, but there is no guidance on when to use this versus harbor_project or harbor_project_summary, and no stated prerequisites or exclusions. The agent must infer usage 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?

readOnlyHint=true already declares the safety profile, so the '[READ]' prefix adds little. The description does not disclose whether the summary is scoped by registry target, whether it aggregates across repositories, or how expensive the call is — modest added value beyond annotations.

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

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

A single front-loaded sentence with no filler and the operation tag leading. It is appropriately sized, though its brevity comes at the cost of the missing details noted elsewhere.

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 multi-resource aggregate tool with an undocumented optional parameter and no output schema, the definition says almost nothing about what the summary contains or how scope is determined. An agent could call it, but not predict the result or understand 'target'.

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

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

Schema description coverage is 0% with two parameters, so the description must compensate. 'For a project' implies the required 'name' is the project name, but the optional 'target' parameter is left entirely unexplained — no hint whether it is a registry endpoint, an instance selector, or a filter.

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 ('Get') and a concrete resource ('repository, artifact and storage summary for a project'), and the '[READ]' tag signals operation class. It is distinguishable from granular siblings like harbor_repositories or harbor_artifacts, though it does not explicitly contrast with harbor_statistics or harbor_project.

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 mention of alternatives such as harbor_statistics or harbor_project. An agent must infer that this is the aggregate overview tool purely from the word 'summary'.

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?

readOnlyHint=true already establishes the safety profile, and the '[READ]' prefix merely restates it, adding no new behavioral context. Nothing is said about quota semantics (hard vs. soft limits, what a returned usage number means) or how results are paged given the defaulted limit.

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 no filler and the verb front-loaded. It is efficient rather than verbose; the problem is under-specification, which is penalized in other dimensions, not 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?

With no output schema, no annotation coverage beyond readOnlyHint, and two fully undocumented parameters, the description leaves too much unresolved for an agent to call it confidently. At minimum it should define what 'target' scopes to and what the response contains.

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 but explains neither parameter. 'target' in particular is opaque — it could be a project, registry, or repository — and the defaulted 'limit' of 50 is never acknowledged, so the agent cannot infer scoping or result size.

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 ('registry quota usage and limits'), and the '[READ]' prefix marks it as non-mutating. None of the listed siblings deal with quotas, so an agent can place it without confusion, though the description never explicitly contrasts it with project- or repository-scoped siblings.

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

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

The '[READ]' tag implies this is a safe lookup call, which weakly implies when to use it. There is no statement of when to prefer this over harbor_project, harbor_projects, or harbor_statistics, and no mention of prerequisites such as needing a project context.

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

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

The "[READ]" tag merely restates the readOnlyHint=true annotation already supplied, so it adds no new structured context. Nothing is said about what "state" comprises, what happens with an unknown execution_id, or permission requirements, which would be the valuable additions given annotations already cover 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?

A single short sentence with the read tag front-loaded; nothing is wasted. It is terse rather than padded, with under-specification being penalized in 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?

With no output schema and no parameter documentation, the description should have indicated what a replication execution's state includes (e.g. status, trigger, start time) and clarified the target parameter. For a lookup tool this leaves the agent guessing at the response 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 mentions no parameters at all. The non-obvious "target" parameter is left completely unexplained, and even execution_id's required/singular semantics come only from the schema, not the prose.

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 and resource ("Get the current state of one replication execution"), and the singular "one" implicitly separates it from the sibling list tool harbor_replication_executions. It is clear about what is fetched, though it does not name the sibling it contrasts with.

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 such as harbor_replication_executions for listing or harbor_replication_task_log for per-task detail. Usage is only inferable from the word "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?

The [READ] prefix merely restates readOnlyHint=true, adding nothing beyond the annotation. The description says nothing about pagination behavior, default page size, ordering, or what happens when no filters are supplied for a read-only listing tool.

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

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

A single, front-loaded sentence with no filler. The only redundancy is the [READ] tag, which duplicates the readOnlyHint annotation.

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

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

For a simple list tool this is under-specified: valid status values, the meaning of 'target', and the response shape are all absent, with no output schema or parameter descriptions to fall back on.

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, yet it only clarifies the status filter (calling it "upstream status"). The 'target' and 'limit' parameters are entirely undefined, and 'target' is genuinely ambiguous without explanation.

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 and resource ("List replication executions") plus an explicit optional filter, which is enough to distinguish it from the singular harbor_replication_execution sibling. It stops short of naming the sibling tools it is not, so it lands at 4 rather than 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?

"Optionally filtered by upstream status" implies the main usage pattern, but there is no explicit when-to-use guidance, no pointer to harbor_replication_execution for single-record lookups, and no note about how this relates to harbor_replication_tasks or harbor_replication_task_log. Usage must be inferred from the name and sibling 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 readOnlyHint annotation already establishes the safe-read profile, so the redundant "[READ]" prefix adds nothing. The phrase "measured truncation" gestures at a pagination/cap behavior but is too vague to tell an agent what actually gets truncated, when, or how to detect 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?

The single front-loaded sentence is tight and wastes few words, though the bracketed "[READ]" token duplicates the annotation and the trailing "with measured truncation" is an ambiguous fragment that doesn't earn its place.

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

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

For a list tool with two undocumented parameters and no output schema, the description should at minimum explain the filtering parameter and the truncation semantics. It leaves both unexplained, so an agent cannot confidently call it or interpret what comes 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?

Schema description coverage is 0% — neither "limit" nor "target" has documentation, and the description says nothing to compensate. It never clarifies whether "target" is a name filter, URL, or registry identifier, which is exactly the gap the description should fill.

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 ("List replication policies"), which lets an agent distinguish it from the singular harbor_replication_policy sibling. However, it never names or contrasts with siblings like harbor_replication_execution or harbor_replication_tasks, leaving differentiation to inference.

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: nothing explains when to pick this list tool versus harbor_replication_policy (single policy) or harbor_replication_executions. 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?

Annotations already declare readOnlyHint=true, and the "[READ]" prefix merely restates that with no added context. Nothing is said about what a missing or invalid ID returns, whether the response includes execution history, or what the undocumented "target" field does — behavior beyond the annotation is left undisclosed.

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, correctly leading with the read-only marker and the action. It is efficient, though its brevity edges into under-specification rather than tight precision.

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 only a readOnlyHint annotation, the description should explain the return shape and the unexplained "target" parameter for a two-parameter lookup tool. As written, an agent knows the tool fetches something but not what it gets back or what the second parameter 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 the burden, yet it only glosses policy_id as "Harbor ID" and says nothing at all about the optional "target" parameter. An agent cannot determine from either source what "target" filters or means.

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 ("Get a replication policy") and adds the lookup key ("by its Harbor ID"), which implicitly separates it from the plural sibling harbor_replication_policies. It never names that sibling explicitly, so the differentiation is inferred rather than stated.

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

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

There is no guidance on when to use this single-policy lookup versus harbor_replication_policies or harbor_replication_executions, and no mention of prerequisites such as needing a known policy ID. The agent must infer the use case entirely from the name and the word "Get".

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

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

The readOnlyHint annotation already covers the safety profile, and the description adds real value beyond it by disclosing that the return is plain text and 'bounded' (i.e. possibly truncated), which an agent needs to know. It stops short of saying how the bound works, whether truncation is flagged in the output, or what happens on an unknown task id.

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, correctly leading with the mode tag, then verb, then resource. It is efficient, though its brevity is arguably under-specification rather than tight editing.

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?

Placeholder.

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 all three parameters, so the description carries the full burden and does not meet it: execution_id, task_id, and target are never explained. The description only obliquely implies a task must be identified; nothing clarifies what 'target' selects or how execution_id relates to task_id.

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

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

The description states a specific verb+resource ('Read the ... log of a replication task') and flags the mode with a '[READ]' prefix, so an agent can distinguish it from write-side siblings like harbor_replication_policy. It does not name the near-identical log siblings (harbor_retention_task_log, harbor_gc_log, harbor_scan_log), so differentiation is implied by the noun rather than stated.

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

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

There is no guidance on when to use this versus harbor_replication_execution, harbor_replication_tasks, or the other *_log tools, and no prerequisite is given even though execution_id and task_id must be obtained elsewhere. The only usage signal is the weak '[READ]' tag and the word 'bounded', which implies truncation but not selection criteria.

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

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

readOnlyHint=true already declares this is a safe read, and the "[READ]" tag merely restates that. Beyond the annotation, the description adds only the scoping fact that results belong to a single execution; it says nothing about pagination despite a limit parameter, what a task record contains, or behavior when the execution has no tasks.

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, front-loaded sentence with no filler, which is good structure. However, the brevity crosses into under-specification — the sentence is too small for the parameter surface it must cover rather than efficiently dense.

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

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

For a simple read-only list tool with no output schema and a minimal annotation set, the description reasonably conveys what it returns (tasks belonging to one execution). The gap is the unexplained limit/target parameters, which a fuller definition should have 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%, so the description carries the burden, but it only hints that execution_id identifies the execution. The limit parameter (default 50) and the target parameter — likely a registry endpoint filter — are entirely unexplained in both schema and description, leaving two of three parameters 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?

States a specific verb and resource ("List tasks") scoped to "one replication execution," which distinguishes it from harbor_replication_executions (executions, not tasks) and harbor_replication_task_log (singular log). The scope is clear enough to select it over siblings, 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?

The description implies usage (inspect the tasks of a replication run) but gives no explicit when-to-use guidance, no prerequisites, and no mention of the clearly related sibling harbor_replication_task_log or harbor_replication_executions. The agent must infer the routing decision 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 readOnlyHint annotation already declares this is a safe read, so the '[READ]' tag in the description adds nothing new. Beyond that, the description is silent on pagination behavior despite a 'limit' parameter, on what 'target' means, and on 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?

A single short sentence with the resource and scope front-loaded and no filler. It is efficient, though its brevity is partly the source of the specification gaps rather than a virtue of tight writing.

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

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

For a three-parameter tool with no output schema and zero schema descriptions, the description is too thin: it never explains 'target' or 'limit', says nothing about result shape or pagination, and offers no routing guidance among the many sibling repository-related 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%, so the description must compensate, and it largely does not: 'project' is only loosely implied by 'inside a Harbor project', while 'limit' and the ambiguous 'target' are entirely unexplained. An agent is left guessing at the meaning and format of two of three parameters.

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

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

The description gives a specific verb and resource ('List repositories') plus a scope ('inside a Harbor project'), which is enough to distinguish it from siblings like harbor_artifacts or harbor_tags. It stops short of explicitly naming the alternative tools for nested resources, so it is clear but not maximally differentiated.

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

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

There is no guidance on when to call this versus harbor_artifacts, harbor_tags, or harbor_project. The only hint is the word 'List' and the parenthetical '[READ]', which implies a read operation but says nothing about exclusions, prerequisites, or pagination workflow.

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?

readOnlyHint=true already declares the safe-read profile, and the "[READ]" prefix merely restates it. The phrase "with measured truncation" hints at a behavioral trait but never explains it – whether it truncates results, reports a total count, or honors the limit – and nothing is said about ordering or return 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 front-loaded sentence with no filler, which is structurally efficient. It is terse to the point of under-specification, but the wording itself contains 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 three-parameter tool with no output schema and zero schema descriptions, the description leaves an agent unable to interpret two of three parameters or the truncation behavior it advertises. It covers the tool's identity but not enough 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%, so the description must carry the parameter burden, and it does not. Only policy_id is obliquely implied by "one retention policy"; the limit parameter and the target parameter are entirely unexplained in both schema and description.

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

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

"[READ] List executions of one retention policy" gives a specific verb (list) and resource (retention policy executions), which separates it from siblings like harbor_retention_policy, harbor_retention_tasks, and harbor_retention_task_log. It does not explicitly name an alternative sibling, 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?

There is no when-to-use guidance, no statement of when to prefer harbor_retention_policy or harbor_retention_tasks instead, and no mention of prerequisites. The only implied usage is that a policy id is required, which is left for the agent to infer.

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, and the '[READ]' prefix merely restates that. Beyond safety, the description says nothing about what is returned, whether a missing id errors or returns empty, or any permission requirements.

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 padding. The '[READ]' tag is redundant with readOnlyHint and is the only wasted token, so it is efficient without being maximally informative.

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 single-resource read with no output schema and only two parameters, the description covers the core operation but leaves the 'target' parameter and return behavior unaddressed. Adequate minimum, but with clear gaps.

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

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

Schema description coverage is 0% across two parameters, so the description must carry the load. It clarifies only that policy_id is the 'actual Harbor policy id' (not a name or index), while the 'target' parameter is never mentioned and remains entirely 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: 'Get one retention policy' by 'its actual Harbor policy id'. This clearly distinguishes a single-policy fetch from the list-style siblings such as harbor_retention_tasks or harbor_retention_executions, though it does not name those siblings 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 named alternatives. The phrase 'by its actual Harbor policy id' implies the tool requires an already-known id (versus listing), but that routing logic 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?

The readOnlyHint annotation already establishes that this is a safe read operation, so the description does not need to repeat that. It adds that the log is 'bounded plain-text', which is useful behavioral context, but it does not explain what 'bounded' means in practice, whether output is truncated, or what happens when no log exists.

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

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

The description is a single front-loaded sentence with the [READ] tag, specific verb, and resource. There is no redundant or wasted wording.

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 four parameters, three of them required, no schema descriptions, and no output schema, the description should explain parameter relationships and clarify the return format. It says only that the tool reads a bounded plain-text log, which is not enough for an agent to confidently supply policy_id, execution_id, task_id, and optional target.

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 provides no meaning for policy_id, execution_id, task_id, or target. It only identifies the overall resource, leaving all four parameters undocumented in both the schema and the description.

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

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

The description gives a specific verb, 'Read', and resource, 'bounded plain-text log of a retention task', so an agent knows this retrieves log output rather than retention task metadata. It does not explicitly name sibling alternatives such as harbor_retention_tasks or harbor_replication_task_log, which keeps it 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?

The description implies that this tool is used to read a retention task log, but it gives no explicit when-to-use guidance, no prerequisites, and no comparison to adjacent tools like harbor_retention_tasks or other log tools. An agent must infer the selection criteria 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=true, so safety is covered. The description adds one real piece of behavioral context — that results include per-task failures — but says nothing about pagination behavior via limit, ordering, or what happens when an execution has no tasks.

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 the read-mode tag first and the scope second; nothing is wasted. Its brevity is partly under-specification rather than pure efficiency, but structurally it is clean.

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 requiring two integer identifiers with zero schema documentation and no output schema, the description should explain the required ID pairing, the target filter, and pagination via limit. None of that is present, leaving real ambiguity about how 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% and there are four parameters, so the description carries the full burden — yet it explains none of them. It does not clarify the policy_id/execution_id pairing, what 'target' filters, or how 'limit' (default 50) truncates results.

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 tasks of a retention execution') and adds scope ('including per-task failures'). It is clear what it returns, though it never distinguishes itself from nearby siblings such as harbor_retention_task_log or harbor_replication_tasks, so an agent must infer which is the right one.

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 '[READ]' tag and 'of a retention execution' phrasing imply this is a read-only lookup that requires an existing execution, but there is no explicit when-to-use/when-not guidance and no pointer to harbor_retention_executions as the source of execution_id. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds genuine value by disclosing that secrets in the response are redacted, which tells the agent not to expect usable credentials. However, it omits the truncation behavior implied by the default limit of 50, which materially affects whether all robot accounts 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?

A single tight sentence with the read-only marker and the key resource up front, and the redaction fact attached. 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?

For a two-parameter list tool with no output schema and zero parameter documentation, the description should explain what 'target' scopes and whether results are capped or paginated. It supplies neither, so an agent could call it and misread a truncated result as the complete set of robot accounts.

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 both parameters are undocumented. The description never mentions "limit" or "target", leaving the meaning of "target" (project scope? robot account target?) completely unexplained, which is exactly the gap the description should fill.

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 ("List") and resource ("robot account metadata"), plus the scope caveat that returned secrets are redacted. No sibling tool covers robot accounts, so there is no ambiguity to resolve; it only falls short of 5 because it does not state scope (e.g., per-project vs global, pagination).

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 preconditions (e.g., admin permission needed to read robot accounts), and no alternatives mentioned. The "[READ]" tag hints at read-only intent but the agent must infer when this tool is the right 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?

Annotations already declare readOnlyHint=true, and the "[READ]" prefix merely restates that, adding no new information. Beyond that the description says nothing about how fresh the "latest" scan is, whether it errors when no scan exists, or what shape the metrics take — meaningful gaps for a metrics-reporting tool with 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?

It is a single short, front-loaded sentence with no filler, which is good, but the "[READ]" tag is redundant with the annotation and the brevity comes at the cost of substance rather than from 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, an undocumented optional parameter, and a sibling whose name overlaps almost exactly, the definition leaves the agent guessing on both what is returned and when to choose it. For a scan-metrics tool in a crowded scan-related sibling group, this is under-specified.

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

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

The sole parameter "target" has 0% schema description coverage and is never mentioned in the description, so the agent cannot tell whether it scopes by project, repository, or registry endpoint, nor what the null default means. The word "registry-wide" hints at default scope but conflicts with the existence of a target parameter without explaining how it narrows things.

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] Get metrics from the latest registry-wide scan." has a verb (get) and a resource (metrics from a registry-wide scan), which is better than a tautology, but "metrics" is never defined (vulnerability counts? scan durations? criticality breakdown?) and there is a close sibling, harbor_scheduled_scan_metrics, that the description does nothing to distinguish from.

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 at all — nothing tells the agent to prefer this over harbor_scheduled_scan_metrics, harbor_scan_log, harbor_statistics, or harbor_vulnerabilities. The only implicit cue is "latest" versus historical scans, which the agent must infer.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so safety is covered elsewhere. The description's one added insight — 'accepted does not mean scan completed' — correctly discloses asynchronous fire-and-forget behavior, which is genuinely useful and not in the annotations. It says nothing about why the call is destructive or what dry_run changes.

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, and the async caveat is well placed. It is arguably too short rather than verbose, 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?

This is a destructive, non-idempotent mutation with five undocumented parameters and no output schema, yet the description is one clause long. It omits what a scan does, what 'target' selects, and what dry_run returns, leaving the definition 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% across five parameters, and the description mentions none of them. The agent gets no meaning for project, repository, reference, target, or dry_run beyond their bare names.

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

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

The description gives a specific verb and resource ('Start an artifact scan'), which distinguishes it from read-only siblings such as harbor_scan_log or harbor_statistics. It doesn't explicitly name an alternative, but the action is unambiguous.

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

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

There is no statement of when to call this versus harbor_scan_all_metrics or harbor_scan_log, and no prerequisites (e.g., that the artifact must already exist) are given. Only the implicit '[WRITE]' tag signals a mutation 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, so the "[READ]" prefix adds little, but "bounded" does convey a real behavioral trait: the log is truncated rather than complete. The description does not say how the bound works, whether pagination exists, what permissions are needed, or how a missing/expired report is signalled.

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 wasted words; the resource and lookup key come before any qualification. The bracketed "[READ]" tag is mildly redundant with the readOnly annotation but does no harm.

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 tool with no output schema and only a readOnly annotation, the definition leaves too much open: how to source a report ID, what "bounded" means in practice, and how project/repository/reference combine. It is enough to attempt a call but not enough to call it 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% across five parameters, so the description carries the full burden, yet it only explains report_id implicitly. Nothing is said about project, repository, reference, or the optional target, leaving an agent to guess how these identify the artifact whose scan log is read.

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

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

The description pairs a specific verb ("Read") with a specific resource ("a bounded artifact scan report log") and a lookup key ("by report ID"). This distinguishes it from sibling logs such as harbor_gc_log, harbor_replication_task_log, and harbor_retention_task_log, though it never explicitly names those alternatives.

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?

"By report ID" implies a prerequisite (a report ID obtained elsewhere) and "bounded" hints that the output is scoped, but there is no explicit statement of when to use this tool versus the other log/scan tools. Usage must be inferred from the name and the required parameters.

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, so the [READ] tag is redundant. The description does add real behavioral scope beyond the annotation: only the latest scan, and registry-wide rather than per-project or per-artifact. It says nothing about freshness, resolution, or failure states of the scheduled scan.

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 front-loaded sentence with the operation and scope stated immediately and no filler. Nothing could be removed without losing 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?

With no output schema and no annotation detail beyond read-only, the description leaves the return value entirely undefined—an agent cannot tell what 'metrics' contains or how to interpret them. For a simple read tool the argument side is fine, but the result side is a real 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 single optional 'target' parameter has 0% schema description coverage, and the description never explains what a target is or what omitting it does. The description provides no compensating semantics for the one parameter that needs them.

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 ('Get metrics') and resource ('latest scheduled registry-wide scan'), and the qualifiers distinguish it from the sibling harbor_scan_all_metrics. It is clear what the tool fetches, though the exact difference from harbor_scan_all_metrics is left implicit.

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 harbor_scan_all_metrics, harbor_scan_log, or harbor_vulnerabilities. The [READ] prefix hints at a read-only context but no conditions, prerequisites, or exclusions are given.

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

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

The readOnlyHint annotation already establishes this is a non-mutating call, and the "[READ]" prefix reinforces rather than contradicts that. The description adds the registry-wide aggregation scope, which is useful behavioral context, but says nothing about what the response contains (fields, format, whether counts are filtered) and there is no output schema to cover that.

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

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

A single front-loaded sentence with a scope qualifier and zero filler; the [READ] tag is arguably redundant given the annotation, but it does not bloat the text. It is efficient, though its brevity comes partly from omitting needed information rather than from tight editing.

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

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

For a tool with no output schema, the description should at least sketch what counts are returned, and it should explain the undocumented "target" parameter. Neither is covered, so an agent cannot tell what "target" filters or what shape the return takes.

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 parameter, "target", with 0% schema description coverage, so the description is the only place its meaning could be established — yet "target" is never mentioned. With a single optional parameter and no output schema, this is the one detail the agent needs and it is absent.

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?

"Get registry-wide project and repository counts" names a specific verb (get) and resource (project/repository counts) and states the scope (registry-wide), which distinguishes it from listing siblings like harbor_projects and harbor_repositories. The purpose is clear without opening the schema, though the phrasing is terse.

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: "registry-wide" suggests this is the aggregate/summary call rather than a per-project listing, so an agent can infer it should be preferred when only totals are needed. However, no sibling is named and there is no explicit when-not-to-use guidance versus harbor_projects, harbor_repositories, or harbor_project_summary.

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

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

The [READ] prefix is consistent with readOnlyHint=true, so no contradiction, and the description usefully discloses that immutable status is included in the result. However, it says nothing about pagination via limit, the meaning of target, or ordering, which are the behaviors an agent would still need to guess.

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 zero filler; the [READ] marker and the verb-resource-object structure make it scannable at a glance.

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 five undocumented parameters, no output schema, and only a readOnly annotation, this definition is too thin. An agent cannot infer what target or limit do, or what shape the returned tag list takes, without opening the schema and guessing.

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 must compensate and largely does not. Only 'for an artifact' loosely hints that reference identifies the artifact; project, repository, target, and limit are left entirely undefined.

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 ('List') and resource ('tags') scoped to 'an artifact', and adds the returned attribute (immutable status). That clearly separates it from harbor_create_tag and harbor_delete_tag, though it doesn't explicitly reference those siblings.

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

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

There is no explicit when-to-use guidance, no mention of prerequisites (e.g., needing an artifact reference), and no pointer to alternatives such as harbor_artifacts or harbor_immutable_rules. Usage is only implied by the word '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?

Annotations already declare readOnlyHint=true, so the safety profile needs no restating. The description adds modest value by revealing the source endpoint (system-info), which hints at the data's nature, but says nothing about return shape, freshness, or failure behavior when the endpoint is unavailable.

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 sentence, front-loaded with the read tag and the resource, with no filler. It is efficient; the terseness is a completeness problem rather than a verbosity problem.

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 and the sole parameter is undocumented, so the description is the only place that could explain the return payload and the target argument — and it does neither. For a tool an agent must call blind, this is under-specified.

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 single optional "target" parameter has 0% schema description coverage and the description never mentions it at all. An agent has no way to know what a target is (host, registry instance, storage backend?) or what omitting it does.

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?

"Get Harbor storage volume usage" gives a specific verb plus resource, and naming the system-info endpoint makes the data source concrete. It is distinguishable from most siblings (e.g. harbor_health, harbor_statistics, harbor_quotas), though the description never explicitly states how it differs from those overlapping usage/quota tools.

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

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

The "[READ]" tag implies a safe retrieval operation but no when-to-use guidance is given. With harbor_statistics, harbor_quotas and harbor_health in the sibling list, an agent gets no signal about which to pick for storage-usage questions.

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 readOnlyHint annotation already covers the safety profile, and the description adds a genuinely useful behavioral detail: 'stored' indicates no scan is initiated. It does not say what happens when no report exists (empty result vs error) or how large reports are returned, leaving real operational gaps for a zero-argument-documented tool.

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

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

One front-loaded sentence with no filler, and the [READ] tag flags the operation type immediately. The tag is largely redundant with readOnlyHint, but it costs almost nothing.

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 tool requiring three opaque path identifiers, plus an undocumented 'target', with no output schema, needs far more than one sentence of guidance. Critical details such as identifier formats and the shape/content of the returned report are absent.

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 four parameters (project, repository, reference, target), yet the description only alludes to 'an artifact' without mapping any of these identifiers. With none of the required identifiers (project/repository/reference) or the optional 'target' explained anywhere, an agent must guess the expected 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?

States a specific verb ('Get') and resource ('Harbor's stored vulnerability report for an artifact'), which cleanly separates it from the scan-triggering sibling harbor_scan_artifact. It stops short of naming that sibling explicitly, so the differentiation is implied rather than stated.

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

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

The word 'stored' hints that this retrieves an existing report rather than triggering a scan, which implies the when-to-use condition. However, no alternative is named and no precondition (e.g. the artifact must already have been scanned) is spelled out.

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

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

Annotations already declare destructive=true, idempotent=false, readOnly=false; the description adds that the inverse executes through its own governed tool and risk tier (audit behavior) and that tokens are single-use. Useful beyond the annotations, though it doesn't say what the inverse might mutate.

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 [WRITE][risk=medium] tag front-loads the mode and risk, and the body is tight. The Args block partially restates the schema titles, but each line adds semantics, so little 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?

No output schema, but the description explains the dispatch model, the dry-run preview path, and the one-time token constraint, which covers the essentials for a mutation tool. It could clarify failure behavior (e.g., applying an already-used token) to be fully complete.

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

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

Schema description coverage is 0%, so the description must carry the load, and it documents all three params: undo_id's source, dry_run's preview semantics, and target's pass-through role. The 'target' explanation ('when it accepts a target') is a bit thin but directionally complete.

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 ('apply') and resource ('a recorded undo') plus the mechanism (dispatching its inverse tool). This clearly distinguishes it from the sibling undo_list, which only enumerates tokens.

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

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

Gives concrete guidance: undo_id comes from undo_list or an _undo_id in a write result, use dry_run=True to preview, and a token can only be applied once. It stops short of saying when not to use it or when preview is mandatory, but the context is clear.

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

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

Annotations only declare readOnlyHint, yet the description discloses substantial behavior: an extra row is read so 'truncated' is measured rather than inferred, effectVerified=false means the reversed change is probable not confirmed, and it warns against reporting an unverified restore. This is well beyond what the annotation covers.

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 purpose, then usage, then a non-obvious implementation note, then args. The paragraph on effectVerified is long but every clause carries decision-relevant information; nothing is 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?

No output schema exists, so the description supplies the return shape itself (original tool, inverse tool, human note, truncated, effectVerified) plus the truncation semantics. Nothing an agent needs to call and interpret this tool 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 0%, so the description must carry the burden — and it does: limit is documented with default 50 and a cap of 500 (the cap is absent from the schema), and target is explicitly marked unused and explained as CLI uniformity.

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 recorded, not-yet-applied undo tokens') with ordering scope ('most recent first') and the [READ] marker. It is immediately distinguishable from its sibling undo_apply, which it names.

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

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

Explicitly routes the agent onward ('Use the undoId with undo_apply') and gives a conditional check before applying when effectVerified is false. It doesn't state an explicit when-not-to-use case for undo_list itself, but the workflow context is clear.

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