Hydracept

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

With no annotations, this description carries the behavioral burden. It honestly discloses that this is an alias with identical quote behavior and clarifies the input/body parameter relation. It does not discuss side effects, permissions, or rate limits, but for an alias/quote operation the key behavioral fact is the equivalence to the canonical tool.

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

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

Two short sentences, no filler. The alias relationship and parameter alias are front-loaded and each sentence adds distinct information.

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

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

The output schema exists, reducing the need to explain return values, and the description points to the canonical tool for further details. Still, it leaves the body content and the meaning of '0.3 retail quote' unstated, and with no annotations an agent would need additional context to construct a correct request.

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's note that 'input' is an alias for 'body' adds real semantic value in resolving the two generic object params. It does not explain capability_key or the expected body structure, but the required capability_key is at least self-descriptive.

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 labels the tool as an HTTP alias of hydracept_quote_capability and states it provides the same 0.3 retail quote, effectively identifying the action as estimating a capability quote. It lacks a standalone verb+resource, but the alias reference and tool name make the purpose unambiguous.

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

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

The description implies the tool is used when an HTTP-facing alias of hydracept_quote_capability is needed, and notes the 'input' parameter alias. However, it does not provide explicit when/when-not guidance or compare with other quoting siblings like request_capability_quote or resolve_capability.

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

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

With no annotations, the description must disclose behavioral traits itself. It states it is a read operation ('Read') and clarifies it never returns an execution quoteId, which is useful. However, it does not mention permissions, side effects, error conditions, or any other behavioral nuances. The output schema likely covers return structure, but behavior beyond that is sparse.

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 exceptionally concise, using two short sentences. It front-loads the primary purpose and adds a critical clarification. Every word earns its place, with no filler.

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

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

For a simple read tool with one parameter and an output schema, the description is mostly adequate. It clearly states the core function and a key exclusion. However, it lacks guidance on when to use this tool versus siblings, and it does not explain the request_id parameter or any prerequisites. These gaps prevent it from being fully complete for an agent deciding to call it.

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

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

Schema description coverage is 0%, so the description must explain the parameter. It does not elaborate on 'request_id' beyond what the schema already provides (the title 'Request Id'). The description adds no semantic detail about what a request_id refers to, its format, or how it relates to the quote.

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

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

The description clearly states the action (Read) and the specific resource (human-paid commission quote for a capability request). It also distinguishes from execution quotes with 'Never an execution.quoteId.', which helps disambiguate from potential siblings that deal with execution quotes.

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

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

The description provides a caution about not using this for execution quotes, but does not explicitly state when to use this tool versus siblings like request_capability_quote or quote_capability. There is no mention of alternatives or conditions that would lead an agent to choose this tool over others.

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

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

With no annotations, the description carries full burden. It discloses that the binding is immutable and that omitting version_id pins the current version, but it does not clarify side effects such as overwriting existing bindings, idempotency, or required permissions. Some transparency but incomplete.

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

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

Three concise sentences that front-load the primary purpose and then add key behavioral details. No redundant phrasing, though the structure could be slightly clearer with explicit parameter mentions.

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

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

Given an output schema exists, return values are not needed. However, the description omits details like what constitutes a compatible route or the exact meaning of catalog-only adapters, and it does not mention authentication prerequisites explicitly, leaving some ambiguity for an agent.

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

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

Schema coverage is 0%, so the description must explain parameters. It explains that project/environment arguments inherit the workspace binding when omitted and that version_id can be omitted to pin the current version, adding value beyond the schema's empty defaults. Alias is clear from the name.

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

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

The description clearly states the tool resolves a project alias to an immutable alias-version binding for persistence in a project recipe, distinguishing it from sibling tools like hydracept_pinned_get or hydracept_pinned_run by specifying the recipe-pinning purpose and the catalog-only adapter restriction.

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

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

It provides contextual hints like omitted arguments inheriting the authenticated workspace binding and the distinction between recipe pinning and generation, but does not explicitly name alternatives or state when not to use this tool. The guidance is implied rather than explicit.

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 are absent, so the description must carry the behavioral disclosure burden. It adds useful context: the result set may include one-shot readiness facts and job_async descriptors may carry a deferredProcessing pricing modifier. However, it does not explicitly state that the tool is read-only, what it returns when called with no arguments, or whether results are paginated or bounded.

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 short, front-loaded with the core operation, and avoids filler. The second sentence packs useful but dense jargon about readiness facts and deferredProcessing; it earns its place but reads as slightly cryptic rather than cleanly explanatory.

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?

An output schema exists, so return structure is covered elsewhere, and the tool has zero required parameters, making a no-argument call feasible. Still, the description does not explain when to prefer this over sibling capability tools or how to constrain a query, so an agent must guess at effective usage.

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 does not explain what key or query mean. 'Find' and 'describe' weakly imply query searches and key selects a specific capability, but this is left to inference rather than stated, and there is no guidance on combining or defaulting the parameters.

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

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

The description states the action family explicitly: 'List, find, or describe capabilities.' The resource is clear and the verbs distinguish read-ish discovery from other operations. It does not explicitly contrast with capability-related siblings like resolve_capability or estimate_capability, so it stops short of full differentiation.

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

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

No guidance is given on when to use this tool versus capabilities-adjacent siblings such as resolve_capability, estimate_capability, or quote_capability. There is also no explanation of how key or query should be used to switch between listing, finding, and describing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the operation does not alter the alias or its immutable history, and that clearing an environment override may reveal an inherited project-wide default. This gives useful side-effect context. However, it does not mention permissions, reversibility, or what happens to the default after clearing beyond the inherited possibility. Partial transparency is present but not exhaustive.

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 three sentences, concise and front-loaded with the core action. Each sentence adds relevant detail: the action, the inheritance behavior, and the non-destructive nature regarding alias/history. No fluff or redundancy, striking a good balance between brevity and necessary context.

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 3 optional parameters, no annotations, and an output schema (not shown but present), the description covers key behavioral aspects but leaves gaps. It explains the inheritance behavior and the potential to reveal an inherited default, but does not explain capability_key usage, error conditions, or the full scope of what is cleared. The presence of an output schema offsets the need to describe return values, but the description is not fully complete for an agent to invoke correctly without prior domain knowledge.

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

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

Schema description coverage is 0%, so the description must compensate for parameter explanations. It addresses project_id and environment by explaining that omitted arguments inherit the workspace binding, but it does not explain the semantics of capability_key at all. The description adds some meaning for two of the three parameters but leaves the third entirely undocumented, failing to fully 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 clearly states the action: 'Clear the project/environment image adapter default.' It specifies the resource (project/environment image adapter default) and the action (clear). It is not a tautology and distinguishes from the sibling 'hydracept_set_adapter_default' by its verb, though it does not explicitly reference the alternative. The nuance about omitted arguments and inherited workspace binding adds clarity.

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

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

The description provides some usage context: it explains behavior when arguments are omitted ('Omitted project/environment arguments inherit the authenticated workspace binding') and notes that clearing an environment override may reveal an inherited project-wide default. However, it does not explicitly state when to use this tool versus alternatives like 'hydracept_set_adapter_default', nor does it mention any exclusions or prerequisites. Guidance is implied but not explicit.

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

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

With no annotations, the description carries the burden and does add meaningful behavioral disclosure: it does not generate or spend money, catalog aliases may reference not-yet-executable registrations, and omitted project/environment bind to the authenticated workspace. It leaves idempotency and overwrite behavior unspecified, but the disclosed traits are material and helpful.

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

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

Three sentences, no filler, with the core purpose first and the most useful behavioral caveats following. Every sentence adds value.

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

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

Given 5 parameters, no annotations, and an output schema, the description covers key invocation semantics but still lacks detail on weight, duplicate-alias behavior, and what the response represents. It is sufficient for basic selection but not fully complete for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that omitted project_id/environment inherit the workspace binding, adapter_id must refer to a registered adapter, and alias is a stable semantic project alias. The main gap is the optional 'weight' parameter, which receives no 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 states a specific action and resource: creating a stable semantic project alias for a registered adapter. It is clear enough, but it does not explicitly contrast itself with similar sibling tools like hydracept_bind_adapter_alias or hydracept_promote_adapter_alias.

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

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

The description provides useful context, such as omitted project/environment arguments inheriting the authenticated workspace binding and catalog aliases potentially referencing non-executable registrations. However, it never states when to prefer this tool over sibling aliasing or binding tools, nor does it offer exclusions.

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

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

With no annotations, the description fully carries the behavioral burden. It explicitly discloses the critical behavior that this MCP does not write local files, clarifying that it returns metadata only. This is a significant and non-obvious trait that would otherwise be unknown to the agent.

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

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

The description is a single, concise sentence that front-loads the core purpose and adds a crucial behavioral clarification. Every word earns its place, with no unnecessary 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?

Given that an output schema exists and the tool is relatively simple, the description covers the essential purpose and behavioral nuance. It could benefit from a bit more context on what 'metadata' includes or how to retrieve the actual artifact, but the output schema likely handles return details, so this is adequate.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. However, it does not mention job_id or artifact_id at all, leaving the agent to infer their roles from the names alone. This fails to add any value beyond the schema's basic titles.

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

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

The description clearly states the tool returns artifact download metadata and content hash, specifying the verb (return) and resource (artifact download). This distinguishes it from siblings like hydracept_job_status or hydracept_get_receipt, which focus on other aspects of job or receipt information.

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 when an agent needs artifact metadata or content hashes, but it does not explicitly mention when to use this tool over alternatives or any exclusions. The 'hosted MCP does not write local files' note hints at a key behavioral consideration but is not framed as a usage guideline.

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

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

No annotations are present, so the description must carry the behavioral disclosure burden. It only says 'Fetch' and 'sealed', implying a read-only, finalized receipt, but does not explain side effects, prerequisites, error behavior, or what 'sealed' means operationally.

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 compact sentence with no redundant words, and the key verb and resource are front-loaded. It is appropriately concise, though it is also quite terse.

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

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

For a one-parameter fetch with an output schema, the description gives the minimal core needed to understand the operation. However, it lacks usage context such as when a sealed receipt becomes available and how to obtain job_id, and no annotations compensate for this gap.

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

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

Schema description coverage is 0%, and the description adds only 'for a job,' which maps to job_id without explaining its format, provenance, or constraints. The schema's title 'Job Id' and string type carry nearly all the real parameter information.

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

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

The description uses the specific verb 'Fetch' with a precise resource ('sealed receipt summary') scoped to 'a job', making the core operation clear. It does not explicitly distinguish itself from siblings like hydracept_job_status or hydracept_job_inspect, but the receipt concept is distinct enough to avoid immediate confusion.

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

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

No guidance is given about when to call this versus alternatives such as hydracept_job_status, hydracept_job_inspect, or hydracept_jobs_find. It also does not explain what job state must be reached before a sealed receipt exists, leaving the selection decision entirely to the agent.

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

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

With no annotations, the description carries the burden and partially meets it by disclosing that the operation is synchronous and read-only, which is important safety-relevant behavior. It does not describe side effects, auth requirements, or error behavior, but the output schema covers return values.

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 efficient sentence that front-loads the core action and scope, then adds the alias clarification. There is no filler or redundancy; every clause earns its place.

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

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

Output schema exists, so return-value documentation is not required, but the tool is a generic invocation gateway with a required capability_key that has no documented valid values or origin. Given the many sibling capability-management tools, the agent is left without enough context to confidently select and populate the invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds one useful semantic detail ('input' is an alias for 'body'), but the required 'capability_key' is left completely unexplained, and the open-ended body/input objects have no guidance on expected shape or values.

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

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

The description states a specific verb ('invoke') and resource ('synchronous capability'), with a qualifier that narrows scope to 'read-only domain/DNS and text'. This is clear enough to distinguish it from async job tools like hydracept_submit_job, though it does not name a specific sibling.

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

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

The description implies when to use the tool: for synchronous, read-only domain/DNS/text capabilities. However, it gives no explicit guidance about when not to use it or which sibling alternatives apply to other cases, leaving the agent to infer the boundary.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not explicitly state whether this is a read-only operation, whether any side effects occur, or if permissions are required. The verb 'inspect' hints at read-only but is not explicit. This gap is significant for a tool without annotation support.

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

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

The description is a single, concise sentence that efficiently enumerates the tool's scope. It is front-loaded with the action and resource, and every listed item adds value. No filler or redundancy.

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

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

For a tool with one parameter and an output schema, the description covers the core functionality. However, it lacks usage guidance and any caveats (e.g., prerequisites, limitations). It is adequate but not comprehensive, especially given the lack of annotations to supplement context.

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%, meaning the schema provides no descriptions for the sole parameter job_id. The description does not mention job_id at all, so it adds no meaning beyond the parameter's name and type. The description must compensate for low coverage but does not.

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

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

The description clearly states the verb 'inspect' and the resource 'one job', listing specific aspects it covers (error, diagnostics, receipt summary, request snapshot, reuse candidate). This is specific enough to distinguish from siblings like hydracept_job_status or hydracept_get_receipt, though it does not explicitly name 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?

The description provides no explicit guidance on when to use this tool versus alternatives. The list of inspected items implies use when detailed error/diagnostics are needed, but no exclusions or direct references to sibling tools are given. An agent must infer the intended context.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It conveys that the tool is a discovery/read-style operation and that it does not need a human-supplied job id, which is useful. However, it does not disclose whether the operation is strictly read-only, how filtering behaves, or what default behavior occurs when no parameters are supplied.

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 tightly-worded sentence with no filler. The primary action and key differentiator are front-loaded, and every word contributes to the agent's understanding of the tool.

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

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

The output schema and lack of required parameters mean an agent can probably make a basic default call successfully. But the description omits parameter-level guidance and does not clarify how to target failed or reusable jobs beyond the vague wording, so the definition is only partially complete for non-default usage.

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, but it only hints at intent categories ('recent, failed, or reusable') without mapping them to the 'intent' parameter. It provides no explanation of 'limit', 'project_id', or 'capability_key', leaving the agent to guess at filtering and pagination behavior.

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

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

The description uses a specific verb ('Find'), a clear resource ('project jobs'), and enumerates the kinds of jobs it can retrieve ('recent, failed, or reusable'). It also explicitly contrasts itself with tools that require a job id, which helps an agent distinguish it from hydracept_job_status and hydracept_job_inspect.

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 phrase 'without asking the human for a job id' gives clear guidance for when to choose this tool over id-based job inspection or status tools. It does not name alternative tools explicitly or provide when-not-to-use conditions, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the disclosure burden and does state the HTTP method, that the request happens once, and the conditional retry behavior. It doesn't cover errors, auth, or terminal conditions, but the disclosed read-only polling loop is the key behavioral trait.

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

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

Two short sentences with no filler: the action is front-loaded and the conditional next step is stated after it. Every word earns its place.

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

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

For a one-parameter endpoint with a response schema available, the description gives the core request and polling contract. It omits non-poll nextAction values and when to stop polling, but an agent can correctly invoke and continue polling based on this text.

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

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

The schema offers only a job_id string with 0% description coverage, and the description maps job_id into the URL path ({jobId}) and relates it to the status/poll response. It doesn't detail format or source of job_id, but enough meaning is added for the single obvious parameter.

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

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

Description names a concrete operation and resource: GET /v1/jobs/{jobId} for job status, with an explicit poll loop. It is clear on its own, though it never names sibling tools like hydracept_job_inspect, so differentiation is left 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?

It gives clear when-to-poll guidance ('if nextAction is poll, wait pollAfterSeconds and call again'), which is actionable. It doesn't state exclusions or alternative tools, but the endpoint/tool name make the primary use case evident.

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

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

No annotations are present, and the description only exposes a GET method, which weakly implies a read-only operation. It does not disclose side effects, whether a lockfile is created or stored, authentication requirements, or failure behavior.

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

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

The definition is extremely brief and technically front-loaded, but it is under-specified rather than concise. The trailing '.' after 'receipt_id=' reads like a placeholder or stub, and no sentence explains behavior or context.

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 one-parameter GET with an output schema, the endpoint line provides the minimum call shape. However, with no annotations, no parameter description, and a large sibling set, the description is not complete enough for reliable tool selection or correct parameter construction.

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

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

The schema has zero description coverage, and the only parameter 'receipt_id' appears in the path with no explanation of its format, provenance, or valid values. The description repeats the query parameter name but adds no semantic meaning beyond what the schema already provides.

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 an explicit HTTP verb and resource path ('GET /v1/provenance/lockfile') and shows the key input, so an agent can infer it retrieves or emits a lockfile for a receipt. It does not explain this in plain language or differentiate itself from siblings like hydracept_verify_lockfile, 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 about when to call this tool, what scenario requires emitting a lockfile, or why it should be preferred over alternatives such as hydracept_verify_lockfile or hydracept_get_receipt. The only context is the endpoint itself, so no explicit usage guidance is provided.

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

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

No annotations are present, so the description carries the full burden of disclosing behavior. It only provides the endpoint, with no mention of side effects, required permissions, return behavior, or what creating a manifest actually entails.

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 short, but it is under-specified rather than concise. It contains no explanatory value beyond the endpoint URI, so it does not earn its place as a useful tool description.

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

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

Even though the input schema is minimal and there is an output schema, the description fails to explain what a manifest is, what 'create' does, or how the body should be structured. This is a fundamental gap for a tool that likely requires domain-specific request content.

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

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

The only parameter is 'body,' an optional object with no schema description and 0% description coverage. The description adds no meaning about the expected structure or content of the body, leaving the agent completely without guidance on how to format the request.

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 is only 'POST /v1/provenance/manifests,' which names an HTTP endpoint but does not explain the tool's purpose in functional terms. It is essentially a restatement of the tool name, and it does not distinguish this from sibling tools like hydracept_manifest_verify.

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

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

The description provides no guidance on when to use this tool versus any of the many sibling tools. There are no context cues, prerequisites, or alternative routing hints, leaving the agent to infer usage entirely from the name and endpoint.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only restates the endpoint and does not say whether verification is synchronous, whether it creates jobs or receipts, whether it mutates state, or what permissions are required. This is insufficient for safe invocation.

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 line with no filler or redundant wording. However, it is terse to the point of underspecification, so it is concise but not a model of a complete tool description.

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

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

The tool is simple and has an output schema, so the return shape does not need to be explained. But with no annotations and a bare endpoint, there is no context about when to use it, what side effects may occur, or how failures behave. This leaves a meaningful gap for an agent deciding whether to call it.

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

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

The schema has one required parameter with 0% description coverage. The URL template shows that manifest_id identifies the manifest being verified, which adds a bit more meaning than the schema title alone, but there is no format, example, or source guidance. For a single simple parameter this is minimally adequate.

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 is a raw HTTP endpoint rather than a plain-language action statement. It does identify a verify operation on a manifest resource, so the purpose is inferable from the path, but it does not explicitly state what verification means or differentiate itself from sibling tools like hydracept_verify_lockfile.

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 about when to use this tool versus alternatives such as hydracept_manifest_create or hydracept_verify_lockfile. The description is not misleading, but it provides none of the context needed to choose between related 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?

With no annotations, the description carries the full behavioral burden. It discloses that omitted project/environment arguments inherit the authenticated workspace binding, that a registered adapter is not necessarily executable, and that credentialAvailability=not_checked means credentials/capacity are still quote-time concerns. These are non-obvious, decision-relevant behavioral facts.

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?

Five sentences, all high-signal: core output list, inheritance behavior, readiness caveat, credential caveat, and onboarding guidance. The description is front-loaded and contains no filler or repetition.

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

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

An output schema exists, so return-value structure is already covered. The description supplies the remaining operational context: workspace binding behavior, routeCompatible requirement, credential semantics, and alias-inspection guidance. For a read-only discovery tool with optional parameters and no annotations, nothing important 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?

The schema has 0% description coverage and only type/default for each optional parameter. The description compensates by explaining the core semantic: omitted project/environment arguments inherit the authenticated workspace binding. It does not document accepted value formats or examples, but for two optional strings the inheritance rule adds meaningful meaning beyond the schema.

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

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

The description opens with a specific verb and resource: 'List the bound project's registered model adapters, semantic aliases, image-generation default, and static routing readiness.' This clearly distinguishes a discovery/listing tool from the many adapter-management, capability, and run siblings. Although the title says 'Choose model adapters', the description itself is unambiguous about listing rather than choosing.

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

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

The description gives concrete when-to-use guidance: check routingReadiness.routeCompatible before selecting an adapter for generation, and new agents should inspect project aliases before searching externally. It does not explicitly name sibling tools as alternatives or state when not to use this tool, so it stops short of a 5.

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

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

The description discloses that the operation is a POST and that items are handled concurrently, each counting as one logical execution. However, no annotations are present, and the description does not explain side effects, failure behavior, meaning of 'pinned,' or whether the operation mutates state, leaving the behavioral burden largely unmet.

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 one terse sentence with the endpoint front-loaded and no filler words. It is structurally efficient and easy to scan, though the extreme terseness sacrifices explanatory 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?

An output schema exists, so return values need not be described, but the input contract is undocumented: the agent is not told how to construct the request body or how 'pinned items' map to the payload. For a bulk execution tool without annotations, this is too incomplete for reliable invocation.

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

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

The only parameter is an opaque 'body' accepting any object or null, and schema description coverage is 0%. The description does not state what the body should contain, how to express pinned items, required fields, or any format hints, so it adds no value beyond the raw schema.

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

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

The description names the exact endpoint and resource ('POST /v1/inference/pinned/bulk') and adds a behavioral gloss ('concurrent pinned items, one logical execution each'). This makes it recognizable as the bulk variant of pinned operations, though it does not explicitly state a plain action verb or contrast with siblings like hydracept_pinned_run or hydracept_pinned_bulk_get.

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

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

There is no explicit guidance on when to use this tool versus the sibling pinned tools. The usage is only implied by the word 'bulk' and 'concurrent'; no alternatives, exclusions, or conditions are provided, so the agent must rely on naming conventions.

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

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

With no annotations provided, the description carries the burden of explaining behavior. It discloses the non-obvious polling protocol and references the response fields nextAction and pollAfterSeconds, which is exactly the behavioral context an agent needs. It does not cover auth, error behavior, or termination conditions, but the core polling semantics are transparent.

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

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

The description is one compact sentence with the endpoint front-loaded followed by the conditional polling rule. No filler or repetition; every clause earns its place.

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

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

For a simple one-parameter GET endpoint with an output schema, the description covers the essential call pattern and the polling logic. It doesn't enumerate return values (the output schema covers that) or discuss error handling, but nothing critical is missing for selecting and invoking the tool.

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

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

There is one required parameter, bulk_id, and the schema coverage in the description is 0%. The endpoint path embeds {bulk_id}, which gives a little context beyond the schema title 'Bulk Id', but the description never explains where the id comes from or what format it takes. For a single obvious parameter this is adequate, not enriched.

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

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

The description names a specific HTTP verb and resource (GET /v1/inference/pinned/bulk/{bulk_id}) and states the one-shot polling behavior, so an agent can see it performs a bulk-result fetch. However, it never names sibling tools such as hydracept_pinned_get or hydracept_pinned_run, so differentiation rests on the endpoint path rather than an explicit contrast.

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

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

It gives a concrete usage instruction: call once, and if the response's nextAction is poll, wait pollAfterSeconds and call again. There is no guidance about when to choose this tool over the pinned_get/pinned_run siblings or when polling should stop, so the usage context is clear but incomplete.

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

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

No annotations are provided, so the description carries the full burden. It only says 'GET', implying read-only, but never explicitly states side effects, error behavior, authentication needs, or anything else. The description provides virtually no behavioral disclosure.

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

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

The description is extremely short, but this is under-specification, not effective conciseness. It contains no useful information beyond the path, failing to earn its place as a helpful description.

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 an output schema present but not described, and a host of sibling tools, this description is completely inadequate. An agent cannot determine what this tool does, what it returns, or when to select it.

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 receipt_id, and the description does not explain the parameter beyond its presence in the URL path. It adds no meaning beyond what the schema already shows (type string, required).

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 is just the HTTP path 'GET /v1/inference/pinned/{receipt_id}', which essentially restates the tool name as a URL. It implies a retrieval operation but does not explain what 'pinned' means or what the resource represents, leaving the purpose vague and poorly differentiated from siblings like hydracept_pinned_bulk_get.

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

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

There is no guidance on when to use this tool versus the many siblings (hydracept_pinned_bulk, hydracept_pinned_run, etc.). No context, no exclusions, no alternative suggestions.

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

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

With no annotations, the description carries the full burden of behavior disclosure. It provides several specific behavioral details: default processing is standard, deferred processing is optional and limited to eligible pins, there is no Flex→Standard fallback, and 429 capacity errors may trigger a retry. It also notes that the operation is a single logical model execution without truncation rewriting. This is substantial transparency for a tool with no structured annotations, though it doesn't address side effects or data safety beyond the retry note.

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

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

The description is compact—three sentences—and front-loads the endpoint and key purpose. It efficiently packs in behavioral details (deferred processing, fallback, retry) without excessive verbosity. The jargon like 'Flex' and 'scientific receipt' might require domain knowledge, but the structure is well organized and avoids redundancy.

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

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

Given the tool has an output schema (which clarifies return format), the description covers the main operational aspects: endpoint, processing modes, retry behavior, and fallback guarantees. It does not detail the body structure beyond hints, but since the body is flexible and no parameters are required, the information level is reasonable. The absence of explicit authentication or rate-limit details is mitigated by the retry mention. Overall, it is fairly complete for an inference call.

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

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

The schema has only a free-form 'body' parameter with 0% coverage, so the description must compensate. It does add meaning by mentioning 'exact pin' and the 'processing=deferred' option, which are likely body fields. However, it does not provide a full schema of expected fields, their types, or required vs optional, leaving the agent to infer the structure. The description gives just enough guidance for a basic call but lacks completeness for a free-form object.

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 identifies the exact endpoint (POST /v1/inference/pinned) and the core purpose: running a pinned inference with a 'scientific receipt'. It distinguishes itself from sibling tools like hydracept_run (generic run) and hydracept_pinned_get (retrieve) by emphasizing 'exact pin' and 'no truncation rewrite', though it doesn't explicitly name those siblings. The verb+resource is clear enough for an agent to grasp the operation.

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

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

The description implies usage for pinned inference runs and mentions an optional processing mode (deferred), but it does not explicitly state when to choose this tool over alternatives such as hydracept_run or hydracept_pinned_bulk. It lacks a clear 'use this when X, otherwise use Y' directive. The mention of 'eligible OpenAI Responses pins' gives some context, but the usage boundaries are implicit rather than explicit.

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

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

With no annotations provided, the description carries the behavioral burden, and it directly discloses the most important trait: 'This does not submit or spend money.' It also implies a safe, non-mutating normalization operation. It does not mention error behavior or idempotence, but the side-effect-free disclosure is substantial for an agent deciding whether to call 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?

Two sentences, with the core outcome front-loaded and no filler. Each sentence earns its place: the first defines the transformation target, the second covers side-effect safety and prerequisite routing.

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

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

The description covers the essential context: what is normalized, the target contract, the safety profile, and the prerequisite tool to consult. An output schema exists, so omitting return-value detail is acceptable. The only gap is a more explicit statement of where the result should be consumed (e.g., passed to hydracept_invoke), though this is largely inferable from the contract name.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaning by identifying the parameter as a 'LoRA picker selection' and instructing that only route-compatible entries should be selected. However, it does not describe the exact properties or shape of the adapter objects beyond pointing to the external contract, leaving the agent to infer the structure.

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

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

The description uses a specific verb and resource: 'Normalize a LoRA picker selection into the exact image.generate.v1 input.adapters contract.' This clearly states what the tool transforms and to what target, and the explicit 'does not submit or spend money' distinguishes it from submission/invocation tools among the 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 description gives a clear usage context: call hydracept_model_adapters first and 'select only route-compatible entries.' It also states this is a preparation step rather than a submission, which implies it should precede hydracept_invoke or hydracept_run. It does not enumerate all alternative tools or list exclusion cases, so it stops short of a 5.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds a useful architectural fact: execution happens in the game checkout, not on this host, which affects how the agent interprets the result. However, it does not disclose polling semantics, whether repeated polling is expected, potential side effects, or what error states may occur.

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

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

Two short sentences, with the primary action front-loaded and a second sentence adding useful architectural context. There is no filler or redundancy, though the second sentence could arguably be folded into a richer overall description.

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 two parameters and a rich set of 33 sibling tools, the description is too thin. It does not explain parameter semantics, when polling is appropriate, how it relates to hydracept_project_request_operation, or what kind of operation lifecycle it monitors. The output schema helps with return values but cannot compensate for the missing guidance on invocation context.

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

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

The input schema has 0% description coverage, and the description mentions no parameters at all. It does not explain the difference between operation_id and project_id, nor provide any guidance on the meaning or required format of these fields. The description adds nothing beyond what the schema already exposes structurally.

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

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

The description states a specific verb ('Poll') and resource ('a project operation'), clearly indicating the tool checks the status of an operation. It is distinguishable from the sibling hydracept_project_request_operation, which creates/requests operations rather than polling them. However, it does not explicitly name or contrast itself with that sibling.

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

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

The phrase 'Poll a project operation' implies the tool should be used after an operation has been initiated, likely by hydracept_project_request_operation. The note that execution happens in the game checkout gives contextual context but does not explicitly state when to use this tool versus alternatives or mention any exclusions.

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

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

No annotations are present, so the description carries the full burden. It discloses a key behavioral fact: the tool only requests an operation; execution happens via a local watcher. This goes beyond the name and clarifies that the call is not synchronous. However, it omits other relevant behavior such as error handling, idempotency, or what happens if the watcher is absent, leaving gaps.

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

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

The description is two sentences with no superfluous content. The purpose is front-loaded in the first sentence, and the execution model is stated succinctly in the second. This is appropriately concise and scannable.

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

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

With five parameters, no schema descriptions, no annotations, and only an output schema (whose content is unknown here), the description is far from complete. It fails to explain what a valid command looks like, what input/context objects should contain, or whether the response is a receipt or a status. An agent cannot reliably construct a correct call from this information alone.

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

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

Schema description coverage is 0%, so the description must compensate for explaining the five parameters. It does not mention any of them (command, input, context, action_key, project_id), leaving agents to guess their meaning and valid values. This is a critical deficiency given the schema provides no descriptions either.

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

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

The description states a clear verb ('POST') and resource ('a project operation'), but the term 'project operation' is underspecified, and it doesn't define what operations are supported. It doesn't explicitly distinguish from nearby siblings like hydracept_project_get_operation; the reader infers the difference from 'POST' vs. 'get' but no further detail is given.

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

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

The description gives no guidance on when to use this tool versus alternatives. It doesn't mention any conditions, prerequisites, or exclusion criteria. The note about 'Hosted MCP does not run the customer repo' describes execution behavior, not usage context, and offers no pointers to other tools for different scenarios.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses multiple nontrivial behaviors: a new immutable alias version is created, omitted project/environment arguments inherit the workspace binding, recipe bindings are unaffected, and active generation defaults have a route-compatibility constraint. This is rich, actionable transparency.

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

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

Three dense sentences, front-loaded with the core action, followed by essential scoping and side-effect information. There is no filler or redundancy.

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

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

The description covers the most important operational semantics: version immutability, workspace inheritance, recipe-binding isolation, and default aliases. The output schema supplies return-value structure. It is not fully complete because parameter semantics are thin and no explicit sibling routing is included, but it is strong for the task complexity.

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

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

Schema description coverage is 0%, so the description must compensate for the five parameters. It only partially clarifies that omitted project/environment inherit the workspace and that the alias moves to an adapter/weight. The meaning of alias, adapter_id, and weight is left mostly to inference from names and schema defaults.

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

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

The description states a specific action: explicitly moving a semantic alias to a new registered adapter/weight by creating a new immutable alias version. It also distinguishes this operation from related siblings by noting that existing recipe bindings do not move.

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

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

The description clearly frames when the tool is appropriate: when an alias should be retargeted via promotion. It adds an important precondition about route compatibility for aliases serving as active generation defaults. It does not explicitly name sibling alternatives such as bind_adapter_alias or create_adapter_alias, so it stops short of a 5.

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

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

Despite no annotations, the description discloses a key side-effect boundary ('Does not reserve or charge funds'), which is valuable for a financial operation. However, it does not reveal whether the call persists a quote request, whether it is idempotent, or what prerequisites/auth are needed, so the full burden is only partially met.

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

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

Three short clauses, no filler, and the essential facts—endpoint, no financial charge, input alias—are front-loaded. Every sentence carries distinct information.

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

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

For a tool with an output schema, return format is covered, but the definition lacks usage context and body semantics. In a crowded sibling set with request_capability_quote and estimate_capability, an agent cannot tell when this tool is the right choice, so it is not complete enough.

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

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

Schema description coverage is 0%, so the description must compensate; it only resolves the duplicate body/input pair by stating they are aliases. It says nothing about what the body payload should contain or what capability_key identifies, leaving two of three parameter semantics underdocumented.

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

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

The description names the HTTP endpoint and the resource ('capability') and clarifies that the operation has no financial side effect ('Does not reserve or charge funds'). It is not a tautology, but it does not explicitly distinguish this quote action from siblings like request_capability_quote or estimate_capability, relying on the endpoint path and the no-funds note.

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

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

No when-to-use guidance is provided. The no-funds statement implies a safe/pre-flight use case, but the description does not name alternatives or conditions, so the agent cannot decide between this and request_capability_quote/estimate_capability.

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

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

With no annotations provided, the description carries full responsibility for disclosing side effects. It does well: it explains validation and freeze behavior for Hugging Face files, content-hash binding for artifacts, the requirement for provider_ref, inheritance of workspace bindings, and instructs inspection of result fields before further action. It stops short of stating whether the registration is persistent, reversible, or requires special permissions, but the provided behavioral specifics are substantial.

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

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

The description is a single, coherent paragraph of moderate length. Every sentence adds relevant information about how to use the tool, from the source_kind variants to the inheritance rule and the required result inspection. It is front-loaded with the core purpose and then drills into specifics, maintaining focus without extraneous detail.

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

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

Given the tool's complexity (11 parameters, three source_kind branches, and a non-trivial output), the description provides a solid foundation: it explains the branching logic, required fields per kind, inheritance behavior, and the crucial post-registration checks. The output schema exists, so the absence of return-value documentation is acceptable. Minor gaps remain for the unaddressed parameters, but these are relatively self-explanatory (e.g., display_name, trigger_words).

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the semantics of source_kind, source_ref, source_file_path, source_provider, project_id, and environment, which covers a significant portion of the 11 parameters. However, display_name, trigger_words, source_revision, base_model_family, and recommended_weight are left unaddressed, meaning the description does not fully compensate for the complete absence of schema-level descriptions.

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

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

The description clearly states the tool registers a reusable project LoRA, which is a specific verb+resource. It immediately distinguishes itself from cost/quote tools by saying 'without generating or spending money' and from other adapter operations by focusing on registration of a source model adapter. The three source_kind variants further specify what counts as an adapter source, leaving no ambiguity about the action.

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

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

The description does not explicitly name alternative tools or state when to use this one over them. It implies usage through the phrase 'without generating or spending money' and by detailing the exact source_kind handling, but it never tells the agent 'use this instead of X when Y'. The absence of explicit alternatives or exclusion conditions leaves the routing decision under-specified.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the tool is non-destructive and non-spending, and explains provider-specific behavior: for Hugging Face, it checks a pinned commit/file without advancing; for Hydracept artifacts, it rechecks immutable content and safetensors structure. It also notes that provider-native refs are opaque and remain declared. This is a strong disclosure for a validation tool.

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

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

The description is concise and well-structured. It starts with a clear action statement, then provides provider-specific details, and ends with a usage trigger. Each sentence serves a purpose, and the critical non-spending aspect is front-loaded. No filler or redundancy.

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

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

Given the tool's simplicity (one parameter, no nested objects) and the presence of an output schema, the description fully covers what an agent needs to know: the action, the non-spending guarantee, provider-specific behavior, and when to use it. The output schema likely covers return format, so no need to describe that here. This is complete for a validation tool.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter 'adapter_id'. The description implicitly defines the parameter as the identifier of the registered adapter to revalidate, which adds meaning beyond the schema. It's not overly verbose but clarifies that the parameter refers to a registered adapter's identity, which is essential.

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

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

The description clearly states the tool's purpose: to re-check the frozen source identity of a registered adapter without spending or generating money. It specifies the resource (registered adapter) and the verb (revalidate). It also distinguishes itself from siblings like hydracept_register_model_adapter (which registers) and hydracept_pinned_get (which retrieves pinned info), by emphasizing the action is a non-generating re-check.

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

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

The description gives explicit guidance on when to use this tool: when sourceHealth is stale, unavailable, or invalid. It also explains what it does not do (never advances a branch or tag, never generates or spends money). While it doesn't explicitly name alternative tools to use instead, the context makes the intended use clear, so no exclusions are necessary.

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?

It discloses that the tool operates over hosted HTTP and that artifact persistence will not work unless invoked through stdio MCP in a checkout, and notes the input/body alias. With zero annotations, this is useful but remains thin; it doesn't state side effects, async behavior, or auth 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?

The text is extremely short and free of filler, but it substitutes cryptic protocol names for an understandable operation. It is concise rather than appropriately structured, with the most useful line (the alias) buried last.

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 seven parameters, no annotations, and many sibling operations, the description omits core semantics like how the run is triggered, cost/timeout implications, and expected return behavior. Even with an output schema, an agent lacks the context needed to invoke this tool safely.

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?

It explicitly clarifies that 'input' aliases 'body', but the remaining six parameters (capability_key, wait, timeout, max_cost, idempotency_key) are unexplained in a schema with 0% description coverage. This minimal hint does not compensate for the 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 references 'hydracept.run-result.v1' and 'hosted HTTP' but never states the operation's verb or what it accomplishes. It reveals an alias but not the tool's core purpose, leaving an agent to infer it from the name and schema.

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

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

No when-to-use guidance or alternatives are named; the only context is that artifact persistence requires stdio MCP, which is a constraint rather than a selection guide. An agent cannot determine when to prefer hydracept_run over the many sibling tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose that the default is not silently injected and that omitted project/environment inherit workspace binding. However, it omits details on side effects, reversibility, or permissions. The non-injection clarification is valuable, but the description is not comprehensive given the absence of annotations.

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

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

The description is two sentences with no redundancy. The first sentence states the purpose concisely, and the second adds a critical behavioral note. It is front-loaded and efficient.

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

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

Given 4 parameters, 0% schema coverage, and no annotations, the description is incomplete. It lacks essential parameter semantics for alias and capability_key, provides no usage context versus clear_adapter_default, and does not mention the output schema. While it covers the non-injection behavior, significant gaps remain for an agent to correctly use the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions that project/environment inherit workspace binding, but it does not explain the 'alias' parameter or the 'capability_key' default. The alias is the core parameter, yet it's not defined, leaving agents with insufficient guidance to correctly fill parameters.

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

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

The description clearly states the tool sets a route-compatible semantic alias preselected for future image.generate.v1 work. It uses a specific verb ('set') and resource, and distinguishes from the sibling hydracept_clear_adapter_default. The phrase 'preselected' clarifies it's about defaults, making the purpose unambiguous.

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

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

The description does not mention when to use this tool versus alternatives. There is no guidance on when to set a default versus clear it, or when to use other adapter-related tools. The note about omitted project/environment inheriting workspace binding is a parameter behavior, not a usage directive, so no explicit when-to-use guidance is provided.

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

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

Annotations are absent, so the description must carry the behavioral disclosure burden. It mentions output facets (generation, pricing, SHA-256, PNG alpha) but does not disclose side effects, permissions, rate limits, or what 'smoke' implies (e.g., non-destructive test). The behavior remains opaque.

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 short but not succinctly informative; it uses cryptic jargon ('managed-trial smoke', 'stdio') that obscures meaning. Front-loading is not achieved because the key clarifying context is missing. Brevity without clarity is not effective.

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 4 parameters, an output schema, and no annotations, this tool requires a richer description. The current text leaves critical operational details unexplained, such as what a trial involves, the expected output structure, and how poll_seconds is used. The description is inadequate for reliable tool invocation.

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

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

Schema description coverage is 0%, so the description must compensate for parameter explanations, but it does not mention prompt, capability, output_path, or poll_seconds. The listed output aspects do not clarify input semantics. The agent is left to infer parameter meaning from names alone.

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 'Explicit managed-trial smoke' is vague and does not clearly state what the tool does. 'Same contract as stdio' is an oblique reference that an agent may not understand without further context. It hints at generation and output attributes but lacks a direct verb-resource statement.

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

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

There is no guidance on when to use this tool versus the many hydracept_* siblings. No alternatives are named, and the 'same contract as stdio' reference does not explain selection criteria. An agent cannot determine when this smoke test is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The phrase 'Session diagnostics' weakly implies a read-only operation, but the description does not state whether invoking it has side effects, whether the optional refresh mutates state, or whether additional permissions or network calls are involved.

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 tight noun phrase with no filler or redundancy, and the core purpose is front-loaded. A more action-oriented structure with a verb would improve it slightly, but as written it is appropriately concise.

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

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

The tool is simple and has an output schema, so return-value documentation is not required. However, with no annotation coverage, no parameter semantics, and no usage guidance, the agent is left uncertain about the refresh option and the operation's side-effect profile, making the definition incomplete.

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 never mentions the refresh parameter. The meaning of refresh (what is refreshed, when it should be true, and what effect it has) is entirely left to inference.

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 identifies the resource as the session associated with the authenticated API key and indicates this is a diagnostics/status operation. It lacks an explicit verb like 'retrieve' or 'report', and it does not explicitly distinguish itself from siblings such as hydracept_smoke or hydracept_job_status, though the 'session' focus provides reasonable clarity.

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

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

There is no guidance on when to use this tool versus any of the many sibling tools. 'Session diagnostics' only implicitly suggests checking API key session health, but no concrete use cases, exclusions, or alternative routing are provided.

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

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

With no annotations, the description carries the disclosure burden and does provide meaningful behavior: pricing is sealed at admission, eligible durable text jobs get discounted deferred processing, and the response contains nextAction. It does not cover side effects or idempotency semantics, but it covers the most surprising behaviors.

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 three short sentences with no filler, front-loads the core action, and each sentence carries a distinct piece of information: what the tool does, pricing/deferred behavior, and return/alias details.

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

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

It covers pricing, deferred processing, and the return field, which is substantial, and an output schema reduces the need to describe response shape in prose. However, for a submission tool with many siblings, it lacks guidance on when to use this instead of quote/run/invoke tools and does not explain idempotency 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 description must compensate, but it only clarifies the input/body alias and tells the caller to omit quoteId. The required capability_key and idempotency_key are left unexplained, and the free-form body is given no content guidance.

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

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

The description uses a specific verb-resource pair ('Submit a capability job') and adds a useful return hint, so an agent can tell it is the submission endpoint rather than the inspection/status siblings. It does not explicitly differentiate it from similar operations like hydracept_run or hydracept_invoke, so it stops short of full sibling distinction.

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

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

It gives a clear operational directive ('Omit quoteId') and a scoping condition for deferred processing, but it never says when to choose this tool over run/invoke/quote siblings or what preconditions apply. Guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not indicate whether the operation is read-only or has side effects, what security or authentication constraints apply, or what the outcome of verification is. The HTTP method and path do not reveal behavioral traits beyond the fact that it is a POST request.

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 one short sentence with no filler, which is structurally clean. However, brevity here comes at the expense of substance; it is under-specified rather than appropriately concise, providing only the endpoint and not enough detail to be useful.

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

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

Despite having an output schema, the tool has no annotations, a single opaque unparameterized body, and a description that only restates the endpoint. An agent lacks essential information about what the lockfile verification does, when to call it, and what the response represents. This is markedly inadequate for reliable tool selection and invocation.

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

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

The schema has one parameter, 'body', with no description and 0% description coverage. The description does not mention the parameter or clarify what should be sent in the request body. With no supporting explanation, the agent cannot determine what a valid body should contain, despite the schema allowing arbitrary objects.

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: it is a POST to verify a lockfile. This distinguishes the high-level action, but it does not explain what 'verify' means in this domain (e.g., integrity, signature, syntax), leaving the purpose somewhat vague. It also does not explicitly differentiate it from siblings like hydracept_manifest_verify beyond the resource name.

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

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

There is no guidance on when to use this tool versus alternatives such as hydracept_lockfile_emit or hydracept_manifest_verify. The description provides no context about the workflow or conditions that would recommend this endpoint, so an 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal one important trait: commission quotes are human-paid and not intended for execution. However, it doesn't describe side effects, permissions, reversibility, or what happens when a request is created, leaving significant behavioral gaps for a mutating operation.

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

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

The description is only two sentences and front-loads the action before the caveat. Every sentence contributes a distinct piece of information with no wasted words. It is compact and easy to parse, though it could afford a bit more useful detail.

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

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

Although an output schema exists, the description leaves the most critical input, the body parameter, completely unexplained. It also provides no context about how this request relates to quote handling or when it should be used. For a tool with no annotations and an opaque parameter, this is insufficient for an agent to invoke it correctly.

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

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

The input schema has a single 'body' parameter with a schema description coverage of 0%, and the description never mentions it. An agent has no idea what the body should contain, its format, or how it relates to the capability request. The description completely fails to compensate for the missing schema documentation.

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

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

The description opens with a clear verb and resource: 'Create a capability REQUEST.' It states the tool's core action without merely repeating the tool name. The warning about commission quotes adds a distinguishing trait relative to execution quote tools, though it doesn't explicitly name a sibling.

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

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

There is no direct guidance on when to use this tool versus alternatives like hydracept_quote_capability or get_capability_request_quote. The warning that the quote 'must not be used as execution.quoteId' is a constraint on the result, not a condition for choosing this tool. No exclusion or alternative is mentioned.

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

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

With no annotations, the description carries the full burden, and it does disclose one important behavioral trait: it does not spend money. This implies a read-only, non-costly operation, which is valuable context. Still, it omits details like side effects, authorization requirements, match semantics, and what happens when no capability is found, though the output schema may cover 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?

The description is two tight sentences with no filler. The core purpose is front-loaded, and the important 'Does not spend money' behavior is isolated clearly. Every sentence earns its place.

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

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

For a simple read-only resolution tool, the description covers the main behavioral caveat (no cost) and relies on the output schema for return details. However, it does not explain parameter usage or when to choose this over adjacent quote/estimate siblings, leaving an agent with only partial context for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, but it says nothing about the 'intent' or 'requirements' parameters. The parameter names are somewhat self-explanatory, but the description does not clarify how requirements constrain the capability match or what form intent should take. This falls short because the schema itself provides no descriptions.

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

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

The description uses a specific verb and resource: 'Determine whether Hydracept already provides a suitable capability.' This clearly states the tool checks for existing capability fit rather than creating or estimating something. It distinguishes from quote/estimate siblings via 'already provides' and 'Does not spend money,' though it does not name a sibling 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?

'Does not spend money' gives a useful decision signal, implying it should be preferred before cost-incurring alternatives like quotes or estimates. However, there is no explicit when-to-use guidance, no named alternatives, and no exclusions or conditions for when another tool would be more appropriate.

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