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

Annotations already declare this as a read-only, idempotent, non-destructive operation, so the safety profile is covered. The description adds useful context that the response includes HTML content and settings, but it does not mention permissions, rate limits, or any other behavioral traits beyond what annotations provide.

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 short sentence with no wasted words, and the resource scope is front-loaded. However, the fragmentary phrasing leaves out information that would make the sentence more actionable.

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 tool with one parameter, the description is adequate in stating that one banner is retrieved along with its HTML and settings. It is still missing how to obtain the banner ID and any additional return context, which matters because there is no output schema.

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

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

Schema description coverage is 0%, and there is only one required id parameter. The description implies that the ID selects a single banner, but it does not explain the ID format, where the ID comes from, or how to obtain it, so it only minimally compensates for the undocumented 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?

The description identifies the resource and scope as one banner, and states that it returns HTML content and settings. The singular 'one banner' implicitly distinguishes it from the sibling list_banners tool, though it does not name 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?

There is no explicit guidance on when to use this tool versus shoptet_list_banners, shoptet_get_html_codes, or other retrieval siblings. The singular scope implies retrieval by ID, but no conditions, prerequisites, or exclusions are stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so the safety profile is covered. The description adds that these are Appearance-editor configuration values and that omission returns all fields, but says nothing about output shape, size of returned HTML blobs, or any permission requirements — reasonable but modest added value.

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 compact clauses: scope first, then the omission default. No filler, no repetition of the title, and the most actionable detail (field names) is front-loaded.

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-optional-parameter read tool with full annotations this is close to adequate, but with no output schema the description could have indicated the return shape (e.g. a map of field name to HTML string) and noted that values may be large. That gap is the main remaining shortfall.

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% and the schema gives only a pattern '^[A-Za-z]+$' with no enum, so the description carries the load — and it does, by listing the accepted field identifiers and defining the omission default. It stops short of saying whether values are case-sensitive or what the pattern enforces, so it doesn't fully close 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 names a specific resource and locates it precisely ('Custom HTML code fields from Appearance → Editor → HTML code'), and enumerates the concrete fields (header, footer, orderFinale, robotsFile, llmsFile). The verb is only implied by the tool name, but the resource scope is unambiguous and clearly distinct from the product/order/banner 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?

'Omit field to get all' is a genuine usage hint about how to call it in bulk vs. single mode. There is no guidance on when to reach for this tool versus other shop-configuration tools, and no stated prerequisites (e.g. admin scope, that these codes are shop-wide settings).

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the returned field set, which is genuinely useful, but says nothing about pagination, empty-price-list behavior, or size limits for large variant sets.

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

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

One sentence, front-loaded with the resource and immediately followed by the field list; nothing is wasted. Slightly telegraphic, reading as a noun phrase rather than a full statement of action.

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

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

With no output schema, the description does well to list return fields. However, for a one-parameter lookup the only true input (product_id) is left unexplained, and nothing indicates whether results are limited or truncated.

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 product_id parameter has no prose explanation in either the schema or the description. 'All variants of a product' only indirectly implies that product_id identifies that product; no format or constraints are added.

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 resource (a product's variant price list) and enumerates the returned fields (variant id, name, code, price, stock), so the agent knows exactly what data comes back. It doesn't explicitly name the sibling shoptet_get_product as the alternative, 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?

The phrase 'from its price list tab' implies the context in which this applies, but there is no explicit guidance on when to use this versus shoptet_get_product or shoptet_list_products, and no stated prerequisites. Usage is inferable rather than instructed.

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

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

Annotations already carry the safety profile (readOnly, idempotent, non-destructive, open-world), so the bar is lower. The description does add one genuinely useful non-schema behavior — long texts are truncated to max_chars — but says nothing about the default limit, what truncation looks like in the response, or what happens if the id does not exist.

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

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

Two compact sentences with no filler, and the truncation caveat follows immediately after the field list it qualifies. Opening with a bare noun list rather than a verb makes it read slightly like a field caption, which keeps it from a 5.

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

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

For a two-parameter read-only fetch with annotations covering safety and no output schema, the essentials are present: which product, which fields, and the truncation caveat that would otherwise surprise an agent. Remaining gaps (not-found behavior, default max_chars) are minor.

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

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

Schema description coverage is 0%, so the description must compensate, and it only partly does: it explains that max_chars bounds long text fields, which is the one non-obvious parameter. The id parameter is never mentioned, and the 200–50000 bounds and default for max_chars are left entirely to the schema.

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

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

The description names the exact resource ('one product') and enumerates the fields returned (name, visibility, short description, description), which lets an agent distinguish it from shoptet_list_products. The verb is only implicit — it never says 'retrieve' or 'get' — but 'of one product' makes the singular-fetch semantics 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?

Usage is only implied: 'one product' signals single-record lookup versus the sibling list_products, but no alternative is named and no condition for choosing between them is given. There is also no guidance on when max_chars should be raised or lowered.

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

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

Annotations already declare readOnly, idempotent, non-destructive, openWorld, so the safety profile is covered. The description adds a small amount of context by naming the returned fields and hinting at the id format ("banner2"), but says nothing about whether all banners are returned, ordering, or pagination.

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?

Extremely short with no wasted words, and the resource is front-loaded. However, the terseness comes at the cost of missing the verb and any sentence structure that would make it self-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?

For a zero-parameter list tool with no output schema, the description should at least confirm that it returns a collection of banners with the listed fields and whether it covers the whole shop. It gestures at the returned shape but leaves the return semantics (completeness, ordering, empty results) unstated.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The field hints are useful mainly for constructing a subsequent get_banner call rather than for this tool's inputs.

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

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

The description is a bare noun phrase, "Banners (id like \"banner2\", name, position)", which mostly restates the title "List banners" plus a field list. It does not itself state the action (list) or the scope (all banners in the shop), so an agent must rely on the name to infer 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?

No when-to-use guidance, no exclusions, and no pointer to the obvious sibling shoptet_get_banner for fetching a single banner by id. The listing intent is only implied by the tool name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered and the bar is lower. The description contributes the set of fields a coupon exposes (code, discount, template, validity, usage), which helps an agent anticipate payload shape, but says nothing about pagination, result limits, or whether code filtering is exact or partial.

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 fragments with no filler; the field inventory leads and the filtering note follows. The telegraphic phrasing wastes no words, though the missing verb makes it slightly less scannable than a well-formed first sentence would be.

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?

Read-only listing tools are simple and annotations carry the safety burden, but with no output schema the description should say more about the return envelope and result size. The field list partially substitutes for that, yet an agent still cannot tell whether an unfiltered call returns everything or a paged subset.

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 `code` parameter, which is declared only as a string with maxLength 40. The description compensates partially by labeling it an optional filter on coupon code, but it does not clarify matching semantics (exact vs. prefix) or case sensitivity, which matters for a maxLength-40 identifier.

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

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

The description identifies the resource ("Discount coupons") and the fields each record carries (code, discount, template, validity, usage), and the name supplies the listing verb. However, it is a noun phrase rather than a verb+resource statement, and nothing distinguishes it from the sibling shoptet_list_coupon_templates, which an agent could easily confuse it with.

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

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

"Optionally filter by code" is the only usage signal, and that fact is already encoded in the schema (required: [], code is the sole property). There is no statement of when to call this versus shoptet_list_coupon_templates, no note on whether an unfiltered call returns all coupons, and no mention of result volume or paging.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so safety is covered. The description adds nothing beyond that: no hint of how many templates come back, whether the list is paginated or in what shape the entries are returned. For a zero-parameter list tool there is little to disclose, but what could be added is absent.

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

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

A single short clause with no filler, and the resource is front-loaded. It is slightly under-specified as a bare fragment lacking a verb, which keeps it off the top score.

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

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

With no input parameters, rich annotations and no output schema, the description covers the essentials of what the tool is and why to call it. It does not say what the returned entries contain (e.g. the identifier field an agent would feed into template_id), which is the one piece of information a caller would still need.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The mention of template_id refers to another tool's argument, not to a parameter here, so it neither helps nor hurts.

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 specific resource (coupon templates) and its role as the source of template_id values, which implicitly distinguishes it from the sibling shoptet_list_coupons (actual coupons) and shoptet_get_price_list. It is a noun phrase rather than a verb phrase, relying on the name 'list' to supply the action, but an agent can still tell what it returns.

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

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

It states the concrete downstream use: use these values as template_id when proposing a coupon. That is a real when-to-use signal rather than a vague one. It stops short of naming an explicit alternative to avoid or any exclusion, so it does not reach the top band.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower, but the description adds a genuinely useful behavioral guarantee: customer names, e-mails and addresses are never returned, which tells the agent not to plan on PII enrichment. It does not disclose how many records come back by default or how 'recent' is computed.

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 returned field set comes first, then the privacy constraint. Every clause carries information an agent needs, especially since no output schema exists.

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

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

With no output schema, listing the returned fields is essential and is done well; the PII exclusion is a valuable extra. What's missing is default result size/ordering and any hint about the limit parameter's effect, which matters for a list tool.

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

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

Schema description coverage is 0% — the single 'limit' parameter has bounds only, no description. The tool description never mentions limit, defaults, or the relationship between limit and the 'recent' window, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('List orders') and enumerates the returned fields, which clearly separates it from the product/coupon/banner siblings. It stops short of a 5 because 'recent' is never defined — no time window, default ordering, or default count 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?

There is no order-specific sibling to disambiguate against, and 'Recent orders' implicitly scopes usage to the latest records rather than a historical lookup. However, nothing states when to prefer this over a filtered/date-range query, nor any prerequisite or pagination strategy.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and openWorld, so the safety profile is fully covered. The description adds useful return-field context (id, name, price text) and the case-insensitive filter behavior, but says nothing about pagination, default limit, or total result size for a read tool whose main risk is incomplete result sets.

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 tightly packed sentence with zero filler: source, return fields, and the optional filter are all front-loaded. Nothing could be removed without losing information.

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

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

There is no output schema, and the description partially compensates by naming three returned fields, but it omits whether more fields exist and how `limit` affects the result set. For a 2-parameter listing tool with no annotated pagination behavior, this leaves real gaps 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 carries the burden. It explains `query` as a case-insensitive name filter, which is genuinely valuable, but `limit` is entirely undocumented in both places — no default, no note of the 200 maximum, no paging semantics.

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 products from the admin product list") and it names the returned fields, so it is clearly distinguishable from the singular shoptet_get_product sibling. It stops short of explicitly contrasting with that sibling, but the list/get distinction is evident from the wording.

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?

"from the admin product list" implies this is the browse/enumerate path versus fetching a single product, but no when-to-use or when-not-to-use guidance is stated. The alternative sibling (shoptet_get_product) is never named, so the agent must infer the routing itself.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds only the '(from, to)' field hint and nothing about return shape, ordering, volume of results, or pagination – which matters for an openWorld listing tool with no output schema.

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

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

Two short fragments with zero padding; the resource is front-loaded before the filtering hint. It is terse enough to be efficient, though the telegraphic style borders on under-specified.

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

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

For a list tool with no output schema and an undocumented parameter, the description should say what comes back and how results are paged or ordered. It leaves the agent guessing about return contents beyond the two field names.

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% and the single 'from' parameter has no schema description, so the description carries the burden. 'Optionally filter by source path' does clarify that 'from' is the source path and is optional, which is genuinely useful, but it gives no example format (path vs. full URL, leading slash) despite the 300-char limit.

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 ('URL redirect rules') and its fields ('from, to'), but supplies no verb – 'list' is only inferred from the tool name and title. It is distinguishable from siblings because they cover entirely different resources, but the purpose statement itself is fragmentary rather than a clear verb+resource claim.

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

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

'Optionally filter by source path' hints at the main usage pattern and correctly signals that no filter is required (0 required params), but there is no guidance on alternatives, when not to use it, or pagination behavior for a listing tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: this tool handles authentication/login and reports whether write tools are enabled, which an agent needs to know before attempting mutations.

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

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

It is a single, front-loaded sentence with no wasted words. The two key checks, shop connection and write-tool enablement, are stated directly.

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 zero-parameter tool with rich annotations, the description gives enough context to call it correctly: it identifies the authentication step and the two facts it confirms. It does not describe the return shape, but no output schema exists and the core purpose is still clear.

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

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

The tool takes zero parameters, so there are no parameter semantics for the description to clarify. The baseline for a zero-parameter tool is 4, and no additional parameter detail is needed.

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

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

The description uses specific verbs and resources: it says the tool logs in and confirms which shop the server is connected to and whether write tools are enabled. This clearly separates it from sibling data-retrieval tools like shoptet_get_product and shoptet_list_orders, though it does not explicitly name those siblings.

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

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

The description implies a setup or verification use case by saying to log in and confirm shop connection and write-tool status. It does not explicitly say when to use this tool instead of alternatives, nor does it state prerequisites or exclusions.

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