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 states that the search is saved 'locally' and for 'repeat execution,' which gives some behavioral context. However, it does not disclose what happens if a name already exists, whether the definition is validated, what permissions are needed, or what the return looks like. For a mutation tool with no annotations, this is a significant gap.

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, well-structured sentence that is front-loaded with the core action. It is concise and contains no unnecessary words.

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

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

Given the complexity (nested object, 2 required params, no output schema, no annotations), the description is incomplete. It should explain the expected structure of the 'search' parameter, any constraints, and the tool's behavior upon saving (e.g., overwrite, validation, locality). The description fails to provide this critical 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%, and the description provides no information about the 'name' or 'search' parameters. The nested 'search' object has multiple fields (query, sort, limit, etc.) that are not explained in the description. The description does not compensate for the lack of schema descriptions, leaving the agent to infer parameter meanings from property names and types 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 states a specific verb and resource: 'Save a structured Prom.ua search definition locally.' This clearly identifies the action and the entity being saved, distinguishing it from siblings like prom_saved_search_run or prom_search_products. However, it does not explicitly differentiate from prom_saved_search_list/delete at a glance, though the verb 'save' inherently contrasts with list/delete.

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

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

No guidance on when to use this tool versus alternatives like prom_search_products or prom_saved_search_run. It implies saving for repeat execution, which hints at use case, but there is no explicit when/when-not or alternative selection criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says what is deleted but not that the deletion is permanent, whether it requires auth, or whether it affects an active/running saved search. For a destructive operation with zero annotation coverage this is a real gap.

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

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

A single efficient sentence with the verb front-loaded and no filler. It is terse to the point of under-specification, but nothing in it is wasted.

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

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

A destructive tool with no annotations, no output schema, and an undocumented parameter needs more than one sentence. The description leaves the agent without the id's origin, irreversibility, or error 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?

One parameter (id) with 0% schema description coverage and no prose explanation in the description — the agent gets no hint about the id's format or origin (e.g. from prom_saved_search_list). The description adds no meaning beyond the schema's type and minLength.

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

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

States a specific verb (Delete) plus resource (saved Prom.ua search), which cleanly separates it from the sibling create/list/run saved-search tools. It does not explicitly name or route against those siblings, but the action is unambiguous.

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

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

No when-to-use, when-not-to-use, or prerequisite guidance. Nothing tells the agent whether the id must come from prom_saved_search_list, or that this is irreversible.

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 behavioral burden, yet it says nothing about read-only safety, pagination, ordering, or what a saved-search record contains. It only repeats the operation implied by the name. 'Locally saved' is the sole extra detail, hinting that these live in local storage rather than on the remote account.

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

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

One short, front-loaded sentence with zero filler. Nothing could be cut without losing the 'locally saved' scope qualifier.

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

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

For a zero-parameter list tool with no output schema and no annotations, the description is minimally sufficient but stops short of stating whether the result is paginated or what the list entries contain. Adequate, not complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. Schema coverage is 100% and there is nothing further for the description to clarify.

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

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

Specific verb+resource: 'List locally saved Prom.ua searches.' The qualifier 'locally saved' usefully distinguishes it from date-driven siblings like prom_search_products and prom_search_url, but it never names those alternatives.

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

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

No when-to-use guidance, no prerequisites, and no routing to the obvious siblings prom_saved_search_run, prom_saved_search_create, or prom_saved_search_delete. The agent must infer usage purely from the tool name.

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

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

With no annotations, the description carries the full burden. It usefully discloses execution behavior (direct Prom SSR with DuckDuckGo fallback), which tells the agent results may come from a secondary source, but it omits whether the operation is read-only, any rate limits, auth requirements, or failure modes.

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

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

A single compact sentence, front-loaded with the action and resource. No filler, though it is short enough that more clarifying detail could have been added without bloat.

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

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

For a simple single-parameter tool with no output schema, the description covers the core action but leaves gaps on the id's origin, expected return shape, and safety profile, which matter for an unannotated 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 (id) with 0% schema description coverage. The phrase 'locally saved Prom.ua search' implies id is the saved-search identifier (matching prom_saved_search_list output), but the description gives no format or sourcing detail beyond that 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?

States a specific verb and resource ('Run a locally saved Prom.ua search') and adds an implementation detail (Prom SSR with DuckDuckGo fallback). It is clearly distinct from siblings like prom_saved_search_list/create/delete and prom_search_products, though it doesn't explicitly name what it is not.

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

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

Usage is implied by the name and description: this runs an existing saved search identified by id, versus prom_search_products which presumably runs an ad-hoc query. No explicit when/when-not guidance or prerequisites are given.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the meaningful trait of dual-source retrieval with an automatic DuckDuckGo fallback. It omits other operational facts an agent needs, such as auth requirements (no-auth DDG vs. direct Prom), rate limits, or failure modes when the fallback also fails.

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 tight sentences, front-loaded with the primary action and followed by the fallback condition. Nothing is wasted, though the fallback detail could be seen as secondary to the core purpose.

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 an 8-parameter, dual-source tool with no annotations and no output schema, the description covers the mechanism but not the return shape (no output schema to compensate) or the interaction between client-side filters and pagination. It is adequate but leaves real gaps.

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

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

Schema description coverage is 63%; the description adds no parameter-level meaning at all. The undocumented params (sort, limit, offset) are standard self-explanatory enums/integers with defaults, so the schema gap is tolerable, but the description contributes zero semantic value beyond the schema.

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

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

States a specific verb and resource ("Search Prom.ua ... Product JSON-LD") and even discloses the retrieval mechanism. However, it never explicitly distinguishes itself from the sibling prom_search_url or prom_saved_search_run, leaving an agent to infer the difference from the name alone.

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

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

The description explains how the search executes (SSR then DuckDuckGo fallback) but gives no guidance on when to choose this tool over prom_search_url or prom_saved_search_run, and no prerequisites are stated. Usage is only weakly implied by the name and the source param.

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 and does useful disclosure work: it tells the agent there is no auth requirement and no network/page fetching, so no side effects occur. It omits whether the returned URL is fully qualified or how it should be presented, but the key safety profile is covered.

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

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

Two short sentences with zero filler; the core action is front-loaded and the credential/access disclaimer follows immediately. 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 single-parameter, no-output-schema URL builder, the definition explains purpose and the no-auth/no-fetch behavior adequately. The remaining gap is the shape of the produced URL, which is minor but would help an agent present the result.

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

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

One parameter at 0% schema description coverage, so the description must compensate. It only says the URL is built 'for a query', which adds no encoding rules, language expectations, or filter semantics beyond the schema's plain 'query' string.

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

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

States a specific verb and resource ('Build a Prom.ua marketplace search URL') plus the input ('for a query'). It implicitly separates itself from siblings like prom_search_products by clarifying that it constructs a link rather than retrieving data, though it never names the alternative explicitly.

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

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

The clauses 'requires no API credentials' and 'performs no automated page access' imply the intended context (produce a human-clickable link instead of querying the marketplace), but there is no explicit when-to-use or when-not-to-use statement and no sibling is named. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It correctly signals a mutating/write operation and discloses the environment gating requirement, which is real added context. It does not say whether payload is a full replace or partial patch, how arrays are treated as batch vs single, or what errors/authorization failures look like.

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

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

Two short sentences, zero filler, with the operation front-loaded and the gating constraint immediately after. 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?

A write tool with no annotations, no output schema, and an opaque anyOf payload needs far more disclosure than this. The agent cannot tell what product fields are editable, whether the call is upsert or replace, or what a successful response returns.

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 exactly one required parameter (payload) with a free-form anyOf schema and 0% description coverage, and the description says nothing about its shape or required fields. Because schema coverage is far below 50%, the description must compensate and it does not, leaving the agent unable to construct a valid payload.

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

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

States a specific verb+resource ("Edit seller products") and adds a scoping qualifier ("by Prom.ua ids") that implicitly distinguishes it from the sibling prom_seller_edit_products_by_external_id. However, it never names that sibling or explains the id distinction explicitly, 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?

The description discloses a hard precondition ("Disabled unless PROM_ALLOW_WRITES=true"), which is genuine usage guidance. It does not, however, state when to prefer this tool over prom_seller_edit_products_by_external_id or any other edit path, so the when-to-use routing is only implied.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses the write-enablement guard (PROM_ALLOW_WRITES), but says nothing about what gets changed, reversibility, permissions, or side effects of this edit 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?

Two short sentences, front-loaded with the core action and followed by the critical environment guard. Nothing extraneous.

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 write tool with no annotations, no output schema, and an undocumented payload, the description is too thin. It should at least explain the payload format or the nature of edits to be callable without guesswork.

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

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

Schema description coverage is 0% for the single required parameter 'payload'. The description only says 'by external ids' and provides no additional meaning about the payload structure, expected object/array shape, or required fields.

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

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

The description states a specific verb and resource: 'Edit seller products by external ids.' The 'by external ids' qualifier distinguishes it from the sibling prom_seller_edit_products, which presumably operates on internal IDs.

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 includes a clear pre-condition: 'Disabled unless PROM_ALLOW_WRITES=true.' However, it does not explain when to choose this tool over the related prom_seller_edit_products, leaving alternative routing to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a safe read, but nothing is said about auth/scope requirements or what happens when the id does not resolve. For an unannotated tool this is thin.

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

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

A single tight sentence with the resource and lookup key front-loaded and no filler. Nothing wasted, though it is arguably too terse to carry much 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 simple one-param getter with no output schema this is minimally adequate, but it omits not-found behavior and how the id type is interpreted, leaving the agent to guess at edge cases.

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 sole param allows string|integer via anyOf, so the schema alone says nothing about what 'id' means. The description's 'by id' tells the agent it is an identifier, but adds no format or type guidance beyond that.

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

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

States a specific verb+resource (get a seller client) and the scope (by id), which pairs clearly against the sibling prom_seller_list_clients. It does not explicitly name the list alternative, but the singular 'one' makes the distinction reasonably inferable.

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 indication of when to use this versus prom_seller_list_clients, when to look up by id versus by external id, or any prerequisites. The agent must infer usage purely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the bare retrieval action. It does not say whether the call fails when the id is unknown, whether it requires seller authentication, or what shape of message data comes back.

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

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

A single short sentence with no filler, and the action is front-loaded. It is efficient but so terse that it borders on under-specification for a tool with zero supporting documentation.

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

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

With no annotations, no output schema, and 0% parameter coverage, the description is the only documentation an agent has, and it omits return value expectations, not-found behavior, and permission requirements. For a lookup tool in a 22-sibling seller suite, this is insufficient.

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

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

Schema description coverage is 0%, and the single id parameter has no description in the schema beyond an anyOf string/integer type. The phrase "by id" weakly implies the id identifies a message, but the description adds no format, source, or validation detail to compensate for the coverage gap.

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

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

States a specific verb (get), resource (seller message), and distinguishing scope ("one... by id"), which implicitly separates it from the list_messages sibling. However it never names an alternative explicitly and gives no clue how a message is conceptually tied to clients/orders in the surrounding seller toolset.

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

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

There is no when-to-use guidance: no indication of when to prefer this over prom_seller_list_messages or prom_seller_reply_message, no prerequisites such as knowing the message id source, and no exclusion conditions. The agent must infer that it fetches details for an already-known id.

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, yet it discloses nothing beyond the basic operation: no auth requirements, no behavior when the id is unknown, and no indication of what the returned order contains. A read-only nature is only implied by the verb 'Get'.

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

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

A single short, front-loaded sentence with no wasted words. It is appropriately sized for a simple lookup, though the extreme brevity is part of the reason detail is missing.

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 (one required param, no nesting, no output schema), so a terse description is defensible. Still, for a fetch-by-id tool with no annotations and no schema descriptions, an agent gets no guidance on failure modes or return shape, leaving a genuine 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's 'by id' merely restates the single required parameter without adding format or source guidance. It does not clarify that the id may be a string or integer, nor what kind of order identifier is expected.

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

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

States a specific verb (Get) and resource (seller order), and the singleton scope ('one') implicitly distinguishes it from the sibling prom_seller_list_orders. It does not name the alternative explicitly, but the purpose is unambiguous.

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

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

No statement of when to use this versus prom_seller_list_orders, prom_seller_get_product, or the other get_* siblings. The only usable signal is the word 'one', leaving the agent to infer the retrieval-by-id scenario.

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 says nothing about authentication requirements, rate limits, error behavior, or what happens when the id does not exist. 'Get' implies a read operation, but that is the only behavioral signal, and it is minimal.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the action, resource, and identifier in one efficient line.

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 retrieval tool, the description covers the essential invocation details: what it returns (one seller product) and the required identifier. However, with no output schema and no annotations, it leaves return fields and error behavior unexplained, which is a noticeable gap for an agent relying on the description 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 the single parameter. It does clarify that the `id` is a 'Prom.ua product id', which is more meaningful than the schema's generic `id` field, but it does not describe accepted value format (e.g., string vs integer) or valid identifier patterns.

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

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

The description states a specific verb ('Get'), a specific resource ('seller product'), and scope ('one') plus the identifier type ('Prom.ua product id'). It implicitly distinguishes itself from `prom_seller_list_products` (one vs list) and `prom_seller_get_product_by_external_id` (Prom.ua id vs external id), though it never explicitly names the alternative.

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 explicit when-to-use, when-not-to-use, or alternative tool guidance. It only implies that the tool is for retrieving a single product when the Prom.ua product id is known; no exclusions or sibling 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?

No annotations are provided, so the description carries the full burden. 'Get' implies a read, but nothing is said about behavior when the external id is unknown, whether errors are raised or null returned, permissions, or rate limits.

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

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

A single short sentence with no filler, and the distinguishing qualifier is front-loaded. Efficient, though it could carry one more clause of value without bloat.

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

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

For a lookup tool with no annotations, no output schema, and no parameter documentation, the description leaves the agent guessing about return shape, not-found behavior, and how to obtain an external id. More is needed given the structured fields provide nothing.

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

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

Schema coverage is 0% for the single parameter, so the description must compensate. It does add the key insight that 'id' is an external identifier rather than an internal one, which the schema alone does not convey, but gives no format, source, or example of that identifier.

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

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

States a specific verb (get), resource (seller product), and lookup key (external id). 'By external id' meaningfully separates it from the sibling prom_seller_get_product, which presumably keys on an internal id, though that contrast is not made explicit.

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

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

The phrase 'by external id' implies the condition under which this tool is the right choice, but no when-to-use, when-not, or named alternative (e.g. prom_seller_get_product) is given. Usage is left to inference.

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

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

No annotations are provided, so the description carries full behavioral burden. It notes the 'authenticated' seller context, but says nothing about pagination behavior (the schema has a cursor param), rate limits, or what the returned client records contain—significant gaps for a tool with zero annotation coverage.

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

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

A single tight sentence with no filler; the scope qualifier ('authenticated seller company') is front-loaded. There is simply little content to structure around.

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 two-optional-param read tool with no output schema this is minimally adequate, but it omits how pagination via last_id should be exercised and how it relates to the singular client-getter sibling. Nothing an agent needs is fatally missing, yet little is added.

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

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

Schema description coverage is 100%, so both params (limit, last_id) are already documented in the schema. The description adds no syntax or usage detail beyond it, so the baseline 3 applies.

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

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

States a specific verb (list) and resource (clients) scoped to 'the authenticated Prom.ua seller company'. An agent can distinguish it from prom_seller_get_client by the plural 'list', but the description never names or contrasts with that 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?

There is no when-to-use guidance, no prerequisites, and no mention of the obvious alternative prom_seller_get_client for fetching a single client or how this differs from other list tools. Usage is only inferable from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the read-only implication of 'List'. It does not mention pagination, result limits, ordering, or authentication/permission requirements for a seller-scoped endpoint.

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

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

A single short sentence with the resource front-loaded and no wasted words. It is appropriately sized for a zero-parameter list tool, though it is arguably too terse to be maximally 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?

For a parameterless list tool with no output schema, the description is minimally adequate — it says what is listed but not what each option looks like or how the seller scope is determined. It leaves the agent able to call the tool but not to anticipate the response.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter semantics to add beyond the schema. Nothing in the description contradicts the empty schema.

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

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

The description states a clear verb+resource ("List seller delivery options") that an agent can distinguish from siblings like prom_seller_list_payment_options and prom_seller_list_order_status_options. It is specific about what is returned at a category level, though it does not explain what a 'delivery option' actually contains.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives or the conditions under which this list should be preferred. Usage is only inferable from the name.

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

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

No annotations are provided, so the description carries the full burden. 'List' implies a read-only operation, but the description says nothing about return shape, pagination semantics, rate limits, or ordering. It adds essentially no behavioral context beyond the verb.

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

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

A single short sentence with zero waste and the key resource front-loaded. It is efficient, though its brevity borders on under-specification rather than deliberate conciseness.

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 two-parameter list tool with a fully documented schema and no output schema, the description is minimally sufficient. It omits any context about what a 'product group' is or how results are ordered, but the agent can still call it correctly.

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

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

Both parameters (limit, last_id) are fully documented in the schema at 100% coverage, including their Prom.ua-specific meaning for pagination. The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a clear verb (List) and a specific resource (seller product groups) within the Prom.ua domain. It does not, however, differentiate itself from the many sibling list tools (list_products, list_clients, list_orders), so an agent gets no help distinguishing it when several listing tools could seem applicable.

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 other list_* siblings, and no mention of prerequisites, authentication, or the pagination workflow. The agent must infer everything 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, the description carries full behavioral burden. It mentions authentication but discloses nothing about pagination behavior, sorting, default filters, rate limits, or response shape, despite the tool having a cursor parameter and multiple filter parameters.

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 with the core scope front-loaded. It avoids redundancy, though its brevity contributes to gaps elsewhere rather than being a structural flaw.

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

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

For a list tool with five parameters, no annotations, and no output schema, the description is too thin. It omits filter semantics, pagination context, and any usage distinctions an agent would need 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?

Schema description coverage is only 40%, and the description adds no parameter details at all. Three of five parameters (status, date_to, date_from) are undocumented in both the schema and the description, leaving filter and date-range semantics entirely unexplained.

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

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

The description states a clear verb ('List') and resource ('messages') scoped to the authenticated Prom.ua seller company. It does not explicitly differentiate from siblings like get_message or reply_message, but the list action is unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as get_message, reply_message, or list_clients. The intended usage is only implied by the name and description.

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 but delivers only a one-line purpose. It never discloses pagination semantics (despite limit and last_id params), result ordering/default sort behavior, rate limits, or what 'authenticated seller company' implies for permissions.

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

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

A single front-loaded sentence with no filler, which is appropriately terse. However, the brevity crosses into under-specification for a tool with eight parameters and no supporting annotations.

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 an eight-parameter list tool with no annotations, no output schema, and no description of pagination or filter behavior, the one-sentence description leaves key calling details (how to page, what filters combine, what is returned) undocumented.

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

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

Schema coverage is 75%, but the description adds zero parameter meaning. Two parameters (status and sort_dir) lack schema descriptions entirely, and the description does not compensate for those gaps or clarify filter/sort/pagination interactions among the eight 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?

States a specific verb and resource ('List orders') with a clear scope ('from the authenticated Prom.ua seller company'), which cleanly separates it from the singular prom_seller_get_order. It does not explicitly name sibling alternatives, but the read/list intent is unambiguous.

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

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

The description offers no guidance on when to use this list tool versus prom_seller_get_order for a single order, nor any conditions or exclusions. An agent must infer usage entirely from the tool name and schema.

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 and no output schema, so the description carries the full behavioral burden and it does not deliver. It never states that this is a read-only enumeration, what the returned options look like (codes vs. labels), or whether the result set is static or seller-configurable.

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

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

A single short sentence with no filler, and the purpose is front-loaded. It is efficient, though its brevity comes at the cost of the missing details noted elsewhere rather than from deliberate tight writing.

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

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

For a zero-parameter, read-only lookup this is minimally viable, but with no output schema the description should have explained what the listed options are and how an agent should use them. It leaves the consumer guessing about the return shape.

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

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

The tool takes zero parameters, so the baseline of 4 applies. There is nothing for the description to disambiguate on the input side.

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

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

The description names a specific verb and resource (list seller order status options), so an agent knows it is a lookup of status enumerations rather than a mutation. However, it adds nothing beyond what the tool name already conveys, making it close to a restatement rather than a clarifying statement of purpose.

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

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

There is no guidance on when to call this versus siblings such as prom_seller_set_order_status or prom_seller_list_orders, nor any stated prerequisites. The agent must infer that this is a reference lookup used before setting a status.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses essentially nothing beyond the operation name. It does not state that this is a safe read-only call, whether results are scoped to the authenticated seller, whether the list is paginated, or what a payment option contains — all of which an agent must know to use it confidently.

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

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

A single six-word sentence that front-loads the verb and resource with no filler. It is appropriately sized for a trivial enumeration tool, though it is so short that it is arguably under-specified rather than optimally 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?

For a zero-parameter list tool with no output schema, the description should at least indicate what the returned options represent and how they are meant to be consumed. Instead it leaves the agent guessing about the return shape and the seller-account scoping, which is a modest but real gap.

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

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

The tool takes no parameters and the schema is empty with 100% coverage, so there is nothing parameter-related for the description to add. Baseline for zero-parameter tools applies.

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

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

The description gives a specific verb ("List") and resource ("seller payment options"), which is unambiguous and parallel to siblings like prom_seller_list_delivery_options and prom_seller_list_order_status_options. It does not explicitly distinguish itself from those siblings, but the resource noun alone is enough for an agent to pick correctly.

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

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

There is no explicit when-to-use statement or named alternative, but the usage is strongly implied: it is a zero-parameter enumeration of available payment choices, presumably to feed a checkout or order flow. For a no-arg listing tool this is adequate, though a sentence like "call before creating an order to see accepted methods" would lift it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies an auth requirement via 'authenticated seller', but discloses nothing about pagination semantics, result caps, rate limits, or whether group_id narrows the result set. For a cursor-paginated listing tool this is thin.

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

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

A single efficient sentence with the resource and auth scope front-loaded and no filler. It is appropriately sized, though it is so short that it forgoes useful 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?

All five parameters are optional and the tool has no output schema, so the description needn't explain returns. However, it omits any hint about pagination behavior or how group_id scopes the listing, leaving an agent to infer these from the schema 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 coverage is 80%, so four of five parameters are already documented in the schema, and the description adds no syntax or format detail beyond them. group_id is undocumented in both places, which the description does not remedy. Baseline 3 is appropriate when the schema does the heavy lifting.

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?

Names a specific verb (list) and resource (products) scoped to 'the authenticated seller's Prom.ua company', which distinguishes it from the public prom_search_products sibling. It stops short of explicitly contrasting with prom_seller_get_product or the saved-search siblings, so the differentiation is implicit rather than stated.

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

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

The description gives no when-to-use guidance, no mention of alternatives (e.g. prom_search_products for public search or prom_seller_get_product for a single item), and no conditions under which this listing should be preferred. For a tool sitting among 22 siblings, that gap matters.

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 does disclose one critical behavioral trait: the tool is disabled unless PROM_ALLOW_WRITES=true, which is genuinely useful operational context. However, it omits other important behavior – whether the message is sent immediately, rate limits, auth/permission requirements, and what the reply looks like on the platform.

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

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

Two short sentences, front-loaded with the core action, followed by the operational gating constraint. No filler, no 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 mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. It doesn't compensate for the missing parameter documentation or describe return behavior, leaving notable gaps in the agent's ability to call it correctly.

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

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

Schema description coverage is 0% and the description says nothing about the two required parameters. It never clarifies that 'id' identifies the message being replied to or that 'message' is the reply body. The agent must infer meaning from parameter names alone, which is a real gap for a 2-param required schema.

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

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

The description states a clear verb+resource: 'Reply to a seller message through Prom.ua.' It distinguishes itself from read-oriented siblings like prom_seller_get_message and prom_seller_list_messages via the 'Reply' verb. However, it doesn't clarify how it differs from the closely named prom_seller_set_message_status, which could also involve outbound messaging.

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

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

No when-to-use guidance is given beyond the basic action. There is no mention of alternatives (e.g., set_message_status for status changes versus reply for sending content) or preconditions beyond the write-gate flag. The agent must infer context.

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

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

With no annotations present, the description carries the full burden. It does disclose a genuinely useful behavioral trait beyond the schema: the operation is a write that is disabled unless the PROM_ALLOW_WRITES environment flag is set. However, it says nothing about allowed status values, idempotency, or the effect of the change, leaving significant mutation-related behavior undisclosed.

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

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

Two short sentences, front-loaded with the primary action and followed by the operational gate; nothing is padded. It is lean, though the extreme brevity means little is actually conveyed.

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 write tool with zero annotations, zero schema descriptions, and no output schema, the description is too thin: no valid status values, no permission/effect details, and no failure behavior are covered. Only the write gate is addressed, leaving the agent under-equipped to call it correctly.

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

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

Schema description coverage is 0%, so the schema names both parameters (ids, status) with no meaning attached. The description only adds the batch hint 'one or more' for ids, which the array/minItems:1 schema already implies, and offers nothing on valid status values despite there being no enum to constrain them.

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

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

States a specific verb ('Change status') plus resource ('seller messages'), which cleanly separates it from the sibling prom_seller_set_order_status and from read/list siblings like prom_seller_list_messages. It stops short of naming an alternative explicitly, so it is clear but not fully differentiated in prose.

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

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

The only conditional given is the write gate ('Disabled unless PROM_ALLOW_WRITES=true'), which is a prerequisite rather than usage guidance. There is no statement of when to change a message status versus replying (prom_seller_reply_message) or reading it, and no exclusions.

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

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

No annotations are supplied, so the description carries the full burden. It usefully discloses the write-gate flag, but omits the mutating semantics an agent needs: valid status values, irreversibility of the change, and whether cancellation_text/cancellation_reason become mandatory for certain statuses. That is a meaningful gap for a write 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?

Two short sentences with zero filler; the action is front-loaded and the constraint follows immediately. Nothing needs to be cut.

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 mutation tool with no annotations, no output schema and 0% parameter documentation, the description covers only the write gate. It leaves the agent guessing about permissible status values and the cancellation fields, so it is not sufficient on its own to call the tool correctly.

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

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

Schema description coverage is 0% across four parameters. The description implies 'ids' accepts multiple orders and that 'status' is the target value, but says nothing about valid status values (the schema allows string or integer) or the purpose/conditions of cancellation_text and cancellation_reason.

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

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

States a specific verb ('Change status') and resource ('seller orders'), with the one-or-many scope made explicit. It is clearly separable from read siblings like prom_seller_list_orders and prom_seller_get_order, though it does not explicitly name the nearest alternative prom_seller_set_message_status.

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

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

Gives a hard availability condition ('Disabled unless PROM_ALLOW_WRITES=true'), which is useful gating context. However it never says when to prefer this tool over alternatives, nor what preconditions the target orders must satisfy for a status change to be valid.

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