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

With no annotations, the description carries the full behavioral burden. It discloses the default source (local browser auto-detect) and browser support, but says nothing about the credential-import being a sensitive/state-changing operation, whether it overwrites an existing session, what authentication or permissions are needed, or that a QR-code flow exists (implied only by the 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?

A single front-loaded sentence with a parenthetical qualifier — no filler or redundancy. Its brevity is efficient, though for a five-parameter credential tool it borders on under-specification.

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

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

An output schema exists, so return values need not be described. But with zero annotations, 0% parameter coverage, and a security-sensitive login-import operation, the description is far too thin to let an agent invoke this correctly or safely.

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

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

Schema description coverage is 0% across five parameters, so the description must compensate. It only clarifies browser (default auto-detect plus supported values) and leaves qr, raw, source, and qr_timeout entirely unexplained in both schema and description.

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

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

States a specific verb and resource: importing a login state (登录态), with the default acquisition path (auto-detect from the local browser). It is clear what the tool does, but it never distinguishes itself from auth_status or auth_reset_guard, which are the obvious adjacent siblings an agent must choose between.

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

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

The description implies when it runs by default (auto-detect from the local browser) and enumerates supported browsers, which is useful context. However, it gives no explicit when-to-use vs auth_status/auth_reset_guard guidance, no prerequisites, and no indication of what happens if an existing session is already present.

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 almost nothing. For a security-sensitive mutation that disables a protective mechanism, an agent needs to know about authorization requirements, whether the reset is permanent or temporary, and what side effects follow — none of which appear.

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 phrase with zero filler, front-loading the action and target. It is appropriately sized for a zero-parameter tool, though it borders on under-specification rather than true 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?

An output schema exists, so return values need not be explained. But for a zero-param, annotation-free mutation that resets a risk-control guard, the description omits the critical context an agent needs: authorization prerequisites, when this should be invoked, and consequences of the reset.

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 no parameter semantics to document; the baseline for a parameterless tool applies. The description does not need to add anything here.

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+resource: manually clearing/releasing the risk-control circuit-breaker (guard) state. It is clearly distinct from sibling auth tools like auth_login and auth_status. However, it does not explicitly differentiate itself from those siblings or state the scope of what the reset affects.

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

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

The word '手动' (manually) faintly implies use when automatic recovery has not occurred, but no explicit when-to-use condition, prerequisite, or alternative (e.g., checking state via auth_status first) is given. An agent cannot confidently decide when this action is warranted versus waiting.

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 discloses that the tool returns login-relevant fields, but it does not explicitly state whether the operation is read-only or what happens when the login state is invalid, leaving some behavioral ambiguity.

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

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

The description is a single, front-loaded sentence with no filler. It directly states the action and the return values, making it highly concise and well-structured.

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

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

Given the tool's simplicity (0 params) and the presence of an output schema describing return values, the description is largely complete. It could be slightly enhanced by noting when to use it (e.g., before auth-dependent operations), but the core information is sufficient.

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

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

The tool has 0 parameters, so the baseline is 4. The description does not need to add parameter details, and the schema already has no properties. The description appropriately focuses on the return information.

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

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

The description uses a specific verb ('检查' / check) and resource ('登录态' / login state), and specifies the return fields (unb / tracknick / 昵称), which clearly distinguishes it from sibling auth tools like auth_login and auth_reset_guard.

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

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

The description implies that the tool is used to check login validity, but it does not provide explicit when-to-use context or mention alternatives such as auth_login or auth_reset_guard. No exclusions or prerequisites 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?

With no annotations provided, the description must disclose behavioral traits, but it only states the basic recognition capability and return values. It does not mention whether the operation is read-only, how accuracy or error cases are handled, or any limitations or prerequisites (e.g., image format), leaving a significant transparency 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, compact sentence that front-loads the core purpose and immediately states inputs and outputs. Every word contributes value, with no redundancy or filler.

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

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

Given the simple two-parameter tool and the existence of an output schema (which handles return value structure), the description sufficiently covers the main input-output contract. It could add a note about the optionality of images or prerequisites, but for a basic classification tool it is nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning by indicating that 'title' and 'image' are the semantic inputs, which the schema titles ('Title', 'Images Json') do not convey. However, it does not clarify that title is required while images_json is optional, nor does it explain the format of images_json beyond what the schema defaults suggest.

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

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

The description clearly identifies the tool's function: AI-based product category recognition, with explicit inputs (title and image) and outputs (catId/catName). This distinguishes it from sibling tools, which cover auth, item management, media upload, and 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?

The description implies usage when a product title and image are available and a category is needed, but it does not explicitly say when to prefer this over alternatives or mention any exclusions. No sibling tool offers similar category functionality, so the context is adequate but not fully spelled out.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states '写操作' (write operation) and mentions rate limiting and risk control protections, which adds useful context about side effects and constraints. However, it does not disclose whether the deletion is permanent or reversible, or what consequences occur beyond the operation itself.

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

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

The description is a single, compact phrase that front-loads the core action and resource, followed by a brief note on operation type and protections. Every word earns its place, with no redundancy or filler. It is highly efficient and appropriately sized for a tool with one parameter.

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

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

Given the tool's delete/delist operation and the existence of an output schema, the description covers the basic purpose but lacks crucial contextual information. It does not mention whether the delete is soft (delist) or hard (permanent), what happens to associated data, or any side effects. It also provides no usage alternatives, making it incomplete for an agent to fully understand the tool's impact.

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

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

The schema has one required parameter, item_id, with 0% description coverage. The description does not explain the parameter's meaning or any special requirements. Although item_id is self-explanatory, the description provides no additional value beyond the schema, and the low coverage means the description should compensate but fails to do so.

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

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

The description clearly states the action '下架/删除' (delist/delete) and the resource '商品' (item/product), making the tool's purpose unmistakable. It also distinguishes from sibling tools like item_get, item_list, and item_publish by indicating it's a delete/delist operation, which is unique among the given 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 provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or scenarios where other tools like item_get or item_publish would be more appropriate. The only hint is that it's a write operation, but that's not explicit usage guidance.

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

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

The description includes the annotation '（只读）' (read-only), which is a useful behavioral hint, but with no annotations provided, it carries the full burden of disclosure. It does not mention authentication requirements, error behavior (e.g., item not found), rate limits, or any other side effects. The single read-only note is insufficient context for an agent to anticipate tool behavior fully.

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

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

The description is a single, concise sentence that directly communicates purpose and the read-only nature. It is front-loaded and contains no filler words, making it efficient for an agent to parse quickly.

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 simple nature of the tool (one parameter, output schema exists) the description covers basic purpose, but lacks usage guidance and parameter context. The output schema presumably handles return values, but the description still leaves gaps around when to use the tool and what the item_id parameter means, making it minimally adequate but 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 input schema has only one parameter, item_id, but the description does not elaborate on what this ID represents, how to obtain it, or any validation rules. Since schema description coverage is 0%, the description should compensate, but it adds no additional semantic meaning beyond the parameter's name.

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

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

The description clearly states the tool's function: querying Xianyu item details (read-only). The verb '查询' (query) plus resource '商品详情' (item details) makes the purpose explicit. It also distinguishes from siblings like item_delete, item_publish, and item_list by specifying a read-only detail retrieval.

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 provided on when to use this tool versus alternatives such as item_view or item_list. The description does not mention exclusions, prerequisites, or scenarios where this tool is preferred. Users are left to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. '查看' implies a read, but nothing is said about pagination behavior, auth/permission requirements (the 'API 直签' hint is unexplained), or result limits, despite a limit parameter defaulting to 50.

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 padding. The parenthetical '(API 直签)' consumes space without conveying actionable 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?

An output schema exists, so return values need not be explained, and this is a simple read-only list tool. However, with zero annotations and no mention of pagination or scope limits, the description is only minimally sufficient.

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 optional parameter (limit) with 0% schema description coverage; the description never mentions it. The parameter is self-explanatory from its name and default of 50, so the gap is minor, but the description adds no meaning beyond the schema.

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

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

States a specific verb (查看/list) and resource (在售商品, on-sale items) scoped to the current account, which distinguishes it from search_items and item_get. The trailing '(API 直签)' is opaque jargon that adds no usable clarity, and there is no explicit differentiation from item_view.

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 choose this tool over search_items, item_get, or item_view. The only implicit signal is the 'current account' scope. An agent must guess at the 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?

With no annotations, the description carries the full burden. It usefully discloses two behaviors an agent could not infer: category auto-detection and default-address use, plus the yuan price unit. However, it says nothing about permissions/auth, irreversibility of publishing, failure modes (e.g., duplicate titles), or what happens to category_json/location_json params when auto-detection is claimed.

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

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

The single line is front-loaded and free of waste, with the two automatic behaviors and the price unit packed in compactly. For an 11-parameter mutation tool, however, this brevity crosses into under-specification rather than disciplined 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?

An output schema exists, so return values needn't be described. But for a mutation tool with 11 parameters, 0% schema coverage, and no annotations, the description leaves most of the calling contract (non-required params, delivery enum semantics, json field formats) undocumented.

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

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

Schema description coverage is 0% across 11 parameters, so the description must compensate and largely fails. It clarifies the price unit (yuan) and implies category/location are optional due to auto-detection, but leaves images, delivery enum, post_price, original_price, can_self_pickup, and the *_json fields 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 gives a clear verb+resource (publish an item) and adds meaningful scope: category is auto-detected and the default address is used. This is readily distinguishable from siblings like item_delete, item_get, and item_list by verb alone, though it never names them explicitly.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The agent can infer that this creates a new listing, but nothing tells it how this relates to category_recommend or location_default, which the description implies are handled internally, nor any prerequisite or precondition.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does disclose something useful beyond the name: the tool reads the live page response and returns image and seller fields. It says nothing about auth requirements, blocking/rate limits, failure modes when the page lacks the item, or whether the call is purely read-only.

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 with the retrieval mechanism and return content front-loaded in a parenthetical. No filler, though the parenthetical could be split into a clearer when-to-use statement.

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

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

An output schema exists, so return-value explanation is not strictly required, and the description still names the notable payload fields. The critical missing piece is routing versus item_get in a sibling set that contains both, plus any note on browser-fetch fragility.

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?

Only one parameter (item_id) with 0% schema description coverage; the description says nothing about its expected format (numeric ID, slug, or URL). The parameter name is largely self-explanatory, which prevents a lower score, but no format or validation guidance is 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 verb and resource ('查看商品详情') and adds a meaningful qualifier ('浏览器视角', reading the page response) that implies a distinct retrieval mechanism. However, it never names or distinguishes itself from the sibling item_get, which likely returns the same resource via another path, so the agent must guess between them.

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

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

'浏览器视角' hints that this is browser-page-based rather than API-based, but the description gives no explicit when-to-use, when-not-to-use, or alternative (item_get, search_items, item_list). The user must infer the choice from a two-character qualifier.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. '获取' implies a read-only 'get' operation, but it does not mention whether authentication is needed, potential side effects, or behavior when no default exists. Minimal transparency 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?

The description is a single concise sentence, front-loaded with the action verb and resource. Every word earns its place with no redundant details.

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

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

For a simple getter with an output schema, the core purpose is clear, and the output schema can cover return values. However, missing parameter semantics and usage context leave notable gaps, making this adequate but incomplete.

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

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

Schema description coverage is 0%, and the description does not mention latitude or longitude at all. The input schema shows defaults but not their meaning or effect on the result, so the agent has little guidance on how to use these 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?

Description '获取账号默认发布地址' (get account's default publishing address) uses a specific verb and resource, clearly indicating the tool's purpose. It distinguishes itself from sibling tools like item_publish by focusing specifically on retrieving the default location.

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 provided on when to use this tool versus alternatives, nor are there prerequisites, exclusions, or contextual hints. The description only states what it does, not when it should be used.

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 useful behavioral fact — the returned receipt is reusable — but says nothing about auth requirements, accepted formats, size limits, or whether uploads consume a shared quota (the '独立媒体预算' phrase hints at quota behavior without explaining it).

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

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

Very short, with the core action front-loaded. However, '独立媒体预算' is an unexplained clause that occupies space without conveying actionable meaning, so not every element 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?

An output schema exists, so return values needn't be described. But for a mutation/upload tool with no annotations, no documented path semantics, and no usage conditions, the description leaves too much for the agent to guess.

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 'path', so the description must compensate and does not. An agent cannot tell whether 'path' is a local filesystem path, a URL, or a media identifier — a critical ambiguity for an upload tool.

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 (上传图片 = upload image) and adds the outcome (returns a reusable image receipt). It does not differentiate from siblings, though none of the listed siblings are competing upload tools, so the risk of misselection is low. The phrase '独立媒体预算' (independent media budget) is cryptic and adds fog rather than clarity.

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

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

No guidance on when to call this versus alternatives, no prerequisites, no indication of what kind of image or workflow this fits. The agent is left to infer everything about the trigger condition.

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

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

With no annotations, the description carries the full burden. It does disclose one real behavioral trait beyond the schema: the call auto-paginates through all pages rather than returning a single page. It says nothing about read-only safety, rate limits, or what happens on very large histories despite a timeout parameter being present.

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 key resource (cid conversation) is front-loaded. It is arguably too terse for a four-parameter tool, but there is no wasted text.

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

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

An output schema exists, so return-value explanation is not required. However, for a tool with four undocumented parameters and zero annotations, the description omits pagination-control semantics, default behavior (limit=0, timeout=30s), and any guidance on choosing between this and the sibling message tools.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate and it largely does not. It clarifies only that cid identifies the conversation; the distinction between limit and limit_per_page, and the role of timeout, are left 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?

States a specific verb and resource: pulling historical messages for a given cid conversation. This clearly separates it from message_list_chats (list conversations) and message_watch (live streaming). It does not, however, explicitly name those siblings or contrast itself with them.

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

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

There is no statement of when to use this tool versus message_list_chats or message_watch, nor any prerequisites (e.g. must the cid be known/authenticated first). The parenthetical '(翻页到底)' implies a full-history fetch, but the agent must infer that.

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 non-obvious behavior beyond the schema — that the call touches HTTP and briefly opens a WebSocket by default, and that recent messages are backfilled (implying extra network work and latency). However it says nothing about permissions, rate limits, blocking duration, or whether the WS phase can be suppressed.

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 tight line with the resource front-loaded, so there is no wasted text. The density borders on cryptic, but every clause carries information about mechanics and ordering.

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

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

An output schema exists, so return values need not be explained, but the rest is thin: three undocumented parameters, no annotations, no guidance on choosing this over message_history or message_watch, and no statement of what the WS discovery phase costs or requires.

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

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

Schema description coverage is 0% across three parameters (timeout, fetch_num, watch_secs) whose names alone are ambiguous. The phrase 短时 WS 发现 hints at the short watch window but never maps to watch_secs, and timeout and fetch_num are entirely unaddressed, so the description does not 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?

The description names a specific resource and action (会话列表 = chat list) and adds scope detail: discovery over HTTP plus a default short-lived WebSocket, recent-message backfill, and activity-time descending order. That is clear enough for an agent to know what it returns, though it never distinguishes itself explicitly from siblings like message_history or message_watch.

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

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

There is no when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. An agent choosing between message_list_chats, message_history, and message_watch gets nothing beyond an implicit hint from the mention of a short WS discovery phase.

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

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

No annotations are present, so the description carries the full burden. It discloses the requirement for text (though this conflicts with the schema where text is optional) and that images use URL+dimensions, but omits auth needs, side effects, or failure behavior.

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

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

The description is a single, very concise sentence that front-loads the main action. However, it lacks structure and packs multiple details awkwardly, but it is not verbose or redundant.

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

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

Given the tool has 8 parameters, no annotations, and an output schema, the description is under-specified. It fails to explain core parameters like cid and toid, making it incomplete for reliable tool invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It only clarifies text and image parameters (text required, image uses url+wh), but leaves cid, toid, item_id, and dimension fields unexplained, which is insufficient for 8 parameters.

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

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

The description clearly states the tool sends a message (text/image) to a conversation, using the verb 'send' and specifying the resource. It distinguishes itself from sibling tools like message_history and message_list_chats, which are for reading or listing messages.

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 provided on when to use this tool versus alternatives. The description mentions text/image but does not explain when to choose one kind or when other messaging tools might be more appropriate.

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

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

With no annotations provided, the description shoulders the transparency burden. It discloses key behavioral traits: the long-lived nature ('常驻'), output format (JSONL to stdout), and termination method (Ctrl-C). This goes beyond a bare restatement of the name, though it omits potential details like reconnection behavior or error handling, which are less critical for a simple watch tool.

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

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

The description is a single sentence that is front-loaded with the key concept ('常驻 IM 长连接'), followed by output specifics and exit instruction. Every word contributes meaning without redundancy or fluff.

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

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

Given the tool has zero parameters and an output schema exists, the description adequately covers the tool's purpose, mode of operation, and termination. It tells the agent what to expect (JSONL stream) and how to stop it, making it sufficient for safe invocation. No additional context is necessary.

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

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

The input schema has zero parameters, so the baseline is 4. No parameter documentation is needed, and the description focuses on the tool's behavior, which is appropriate for a parameterless tool.

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

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

The description clearly identifies the tool as a persistent IM long connection that outputs downstream events as JSONL to stdout, and mentions exit via Ctrl-C. This distinguishes it from siblings like message_history (past messages) and message_send (sending), establishing a specific watch/stream scope.

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

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

The description implies usage for live event monitoring ('常驻' meaning resident/continuous) and provides exit instructions, but it does not explicitly state when to prefer this over alternatives like message_history for historical data. No exclusions or alternative tool names are given, leaving usage guidance implicit rather than explicit.

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

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

With no annotations, the description carries the full disclosure burden. It adds one genuinely useful behavioral trait — that it goes through a browser path resistant to anti-bot/risk control — and hints at multi-page crawling, but says nothing about authentication requirements, rate limits, or request cost for what is presumably a scraping 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?

A single front-loaded sentence with a tight parenthetical; nothing is redundant. It is arguably under-specified rather than bloated, but it wastes no 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?

An output schema exists, so return values need not be explained, and that covers part of the gap. Still, for a scraping-based search tool with zero annotation coverage and 0% parameter documentation, the absence of auth/cost/pagination context leaves it only minimally adequate.

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

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

Schema description coverage is 0%, so the description must explain the three parameters, but it only clarifies one: --pages is described as cross-page crawling. The required query and the limit parameter (default 20) are left entirely undefined, so an agent cannot tell whether limit caps results per page or overall.

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 (搜索闲鱼商品 / search Xianyu items), so the agent knows exactly what it retrieves. It does not, however, distinguish itself from the sibling item_list or the item_get/item_view tools, leaving ambiguity about which search/list variant to pick.

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

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

No when-to-use or when-not-to-use guidance is given, and the closest sibling (item_list) is never mentioned or contrasted. The only contextual hint is the parenthetical about a browser path and anti-risk-control, which is a mechanism note rather than selection guidance.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the write target (~/.claude/skills/), which is useful behavioral context for a filesystem mutation, but it says nothing about overwrite semantics implied by the `force` parameter, nor about what `list` does, nor about permissions/idempotency.

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 padding; the action and destination are front-loaded. Only minor issue is referring to the parameter as --dest rather than the schema field name `dest`.

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

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

For a three-parameter mutation tool with zero annotation coverage and no schema descriptions, the description is too thin: it omits the behavior of two of three parameters and any overwrite/force semantics. The existence of an output schema excuses it from explaining return values, but not from the rest.

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 document the three parameters, but it only explains `dest` (and even then as a CLI-style --dest flag rather than the schema's `dest` name). `list` and `force` are entirely unexplained, leaving the agent to guess.

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 concrete verb+resource+destination: copies built-in Claude Skills into ~/.claude/skills/ or a --dest directory. An agent can tell exactly what the tool does. It does not need to differentiate from siblings, which are all unrelated item/message/auth tools.

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

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

No when-to-use guidance, no prerequisites, and no mention of when to prefer this over any alternative (e.g. list mode vs install). The description only restates the action; nothing routes the agent's decision.

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