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

With no annotations, the description carries the full burden. It adds useful behavioral details: batch semantics, comma-separated channels, the 5-channel maximum, one-to-one option mapping, and pushId requirements. But it does not disclose failure behavior, partial-send outcomes, return value shape, or any authorization/rate-limit considerations.

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

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

The description is three short sentences with no filler. The primary action is front-loaded, and the key constraints are stated directly and compactly.

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

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

This is a 12-parameter tool with no annotations and no output schema, yet the description only elaborates channel, option, and pushId. It omits guidance around result/error responses, how content interacts with templates, timestamp/callback behavior, and prerequisites for successful batch sending—leaving a significant completeness gap for an agent invoking 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 coverage is 100%, so the baseline is 3. The description adds value beyond the schema by clarifying the 5-channel maximum, the strict one-to-one matching between channel and option, and the pushId requirement for specific templates—details not fully captured in the input 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 clearly states the action: using the pushplus /batchSend interface to send messages to multiple channels at once. This distinguishes it from the single-message sibling tools (send_text_message, send_push_message, etc.) by emphasizing multi-channel batch behavior, though it does not explicitly name the 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?

Usage context is implied: it is for multi-channel batch sends, with concrete constraints such as a 5-channel limit, comma-separated channels, option-to-channel pairing, and mandatory pushId for certain templates. However, it never explicitly says when to prefer this tool over the single-send siblings or when not to use 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 behavioral burden. It clarifies that the operation is a GET with no request parameters and describes the unified response shape, which implies a read-only info lookup. However, it does not explicitly state side-effect safety, preconditions, or error behavior beyond the generic code field.

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

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

The description is compact and front-loaded with the resource and action. Every sentence adds meaningful information: endpoint, purpose, parameter absence, and response structure, with no filler or repetition.

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

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

With no output schema, the description appropriately documents the unified response and the two data fields. It is sufficient for a zero-parameter, simple info query, though it could be slightly stronger by stating the expected data types for createTime and haveContextToken.

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 is an empty object, so there are no parameters to document. The description reinforces this with '请求参数: 无' (no request parameters), which removes any ambiguity for the agent.

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

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

The description states the HTTP method and exact endpoint, then gives a clear verb-resource pair: '获取已绑定机器人详情' (get bound bot details). This is specific enough to distinguish it from sibling ClawBot tools like qrcode, message, or unbind operations.

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

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

There is no guidance about when to choose this tool over alternatives. It does not mention related sibling tools such as open_clawbot_get_msg or open_qqbot_bot_info, nor any conditions that would make this the right call.

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

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

With no annotations, the description carries the burden of behavior disclosure. It discloses the HTTP method, the fact that no parameters are needed, the unified response envelope, and the semantic difference between url and qrcode. However, it does not mention authentication requirements, failure modes, or whether any side effects occur, which leaves some behavioral uncertainty.

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

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

The description is compact, well-structured, and front-loaded with the endpoint and purpose. Every sentence adds useful information: endpoint, purpose, parameter count, unified response format, and data field meanings. There is 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?

For a zero-parameter GET tool with no output schema and no annotations, the description adequately covers the endpoint, request expectations, and response structure including the meaning of the data fields. It stops short of documenting error cases beyond the generic code/msg envelope, but this is a minor gap for such a simple 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 are zero parameters, and the description explicitly confirms this with '请求参数: 无.' Since there are no parameters to document, the explicit no-parameter statement adds clarity beyond the empty schema and earns above the baseline for a schema-covered case.

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: '获取微信 ClawBot 绑定二维码' via GET /open/clawBot/getBotQrcode. This clearly distinguishes the tool's role from sibling tools like open_clawbot_get_qrcode_status, and the mention that qrcode is for querying scan status reinforces the distinction without ambiguity.

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

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

The description provides no explicit guidance about when to use this tool versus alternatives such as open_clawbot_get_qrcode_status or open_friend_get_qr_code. It states that there are no request parameters and describes the response, but it never says 'use this when you need the binding QR code' or 'use the status tool to check after scanning.'

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 itself carries the burden. It explicitly warns that the call '可能耗时较长' (may take a long time), and it describes the unified response envelope and data item shape. This covers the main non-obvious behavior for a no-parameter GET operation.

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

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

The description is compact and logically ordered: endpoint, behavior warning, parameters, and response format. Every clause conveys useful information and nothing is 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?

For a simple parameter-free retrieval tool with no output schema, the description is complete: it states the resource, latency risk, and the exact response structure including success code and item type/text fields. No additional context is necessary to invoke it correctly.

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

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

The tool has zero parameters and the schema already reflects that. The description confirms '请求参数: 无' and adds no misleading parameter expectations, which satisfies the baseline for a parameter-free 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 uses a specific verb ('获取' / get) and resource ('ClawBot 侧消息'), and names the exact HTTP endpoint. This is distinct from sibling tools such as open_clawbot_get_bot_qrcode or open_clawbot_unbind, so an agent can tell what it operates on.

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 and does not mention alternatives or exclusions. With many sibling message/message-list tools (e.g. open_message_list), an agent gets no explicit help choosing this tool over them.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses an HTTP GET operation, a non-mutating query intent, and gives the unified response envelope with code, msg, and data. This is useful transparency, though it stops short of explaining specific status values or error behaviors.

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

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

The description is compact and well structured: operation first, then parameter explanation, then response format. Every sentence adds information, with no filler or repetition of schema details beyond the necessary connection to getBotQrcode.

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

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

For a one-parameter GET query, the description covers the required input, its source, and a generic response envelope. However, without an output schema, the core value—what the binding status data actually contains or what possible values appear—is left to the vague 'data(业务数据)', so an agent cannot fully interpret 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?

Schema description coverage is 100%, so the schema already documents qrcode as '二维码编号（getBotQrcode 返回的 qrcode）'. The description mostly restates this and adds that it is required, which is already encoded in the schema. The value-add is minimal but consistent.

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 operation: '查询扫码绑定状态' (query scan-binding status) on a specific ClawBot resource, and includes the exact HTTP path. It also references getBotQrcode as the source of the qrcode parameter, which indirectly distinguishes it from the QR-code generation sibling, though it does not explicitly name 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 implies when to use the tool by noting that qrcode comes from getBotQrcode's data.qrcode, suggesting this status-check call follows QR-code generation. However, it does not explicitly state when to choose this over sibling tools such as open_clawbot_unbind or open_clawbot_get_msg, nor does it provide when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden. It does flag the operation as high-risk and states the response envelope (code, msg, data), but it does not disclose the actual consequences of unbinding, such as whether it is irreversible, whether the bot disconnects immediately, or what side effects occur.

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

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

The description is compact and front-loaded, covering endpoint, risk level, absence of parameters, and response format in a few clauses. No filler or redundant explanation is present.

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 0-parameter tool, the description is mostly adequate: it gives the endpoint, risk flag, and unified response shape. However, given that this is a high-risk unbind operation with no annotations, it should explain what 'unbind' actually does and what the agent should expect afterward.

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 zero parameters, and the schema confirms this. The description explicitly states '请求参数: 无', so there is no parameter semantics burden beyond confirming the absence of 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 states a specific verb ('解绑' / unbind), an explicit HTTP endpoint, and the target resource ('微信 ClawBot'). This clearly distinguishes it from sibling tools like open_qqbot_unbind or other ClawBot utilities.

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 when-to-use guidance or exclusions. It warns '高风险' but does not explain under what circumstances unbinding is appropriate, nor does it mention alternatives such as open_qqbot_unbind for the QQBot equivalent.

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 behavioral burden. It discloses the authentication requirement, user restriction, binding consequence, and unified response format. It does not cover repeated-binding behavior or side effects, but key behavioral information is 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?

The description is compact and well-structured: endpoint, parameter, prerequisites, support scope, postcondition, and response format. Every sentence adds useful information with no filler.

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

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

For a simple one-parameter binding operation with no output schema, the description covers the request shape, prerequisites, restrictions, success consequence, and response envelope. Nothing critical is missing for an agent to invoke it correctly.

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

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

The input schema already documents apiKey with 100% coverage including the required prefix constraint. The description adds the source of the API Key and emphasizes that it is required, providing marginal value beyond the schema. Baseline 3 is appropriate.

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 starts with 'POST /open/cmcc/bind - 绑定新消息ClawBot', stating a specific action (bind) and a specific resource (China Mobile new-message ClawBot). It is clearly distinguishable from sibling tools like open_cmcc_unbind, open_cmcc_test, and open_cmcc_info.

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 clear prerequisites (obtain API Key from the 5G message app), a support restriction (China Mobile users only), and postconditions (can use /send with channel=cmcc). It does not explicitly name alternative tools or when not to use this tool, but the usage context is well defined.

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 burden of behavioral disclosure. It discloses the HTTP method, response envelope (code/msg/data), and data field semantics including bound=0/1 and masked API key. However, it does not mention authentication requirements, error behavior beyond 200 success, or explicitly state that this is a read-only operation.

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

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

The description is compact and well-structured: endpoint, no-parameter note, unified response envelope, and data fields. It is front-loaded with the purpose and contains no filler or redundant 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 zero-parameter GET status query, the description is complete. There is no output schema, so the description appropriately explains the response envelope and the data fields an agent needs to interpret the result. No critical information appears missing 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?

The input schema is empty and schema coverage is 100%, so there are no parameter semantics for the description to clarify. The description explicitly confirms '请求参数: 无' (no request parameters), which removes any ambiguity. With zero params, this meets the baseline-4 expectation.

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 states a specific operation (GET) and resource (ClawBot binding status), with the title reinforcing '查询新消息ClawBot绑定状态'. It is clearly distinguishable from sibling tools like open_cmcc_bind, open_cmcc_unbind, and open_cmcc_test, which are mutation/action tools rather than a status query.

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 intended use—querying binding status—is implied by the title and description, but no explicit when-to-use, when-not-to-use, or alternative tool guidance is provided. An agent can infer the purpose, but the description does not actively route away from bind/unbind/test siblings.

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 it does well: it discloses that the tool sends a test message, explains the unbound error response, and describes the unified response format. It does not cover authentication or rate limits, but for a zero-parameter test endpoint the key behaviors are transparent.

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

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

The description is compact and well structured: endpoint and purpose, parameter clarification, error condition, verification step, and response format. Every sentence adds useful information without unnecessary padding.

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

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

For a zero-parameter, no-output-schema tool, the description is remarkably self-contained. It includes the operation, error case, success verification path, and response structure, so an agent has enough context to call and interpret 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?

The input schema is empty and the description confirms '请求参数: 无', so there is no parameter ambiguity. This matches the baseline of 4 for tools with zero parameters and complete schema coverage.

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 (sends a ClawBot test message), the resource (GET /open/cmcc/test), and the overall purpose. It does not explicitly differentiate itself from sibling test or CMCC tools, but the endpoint and action make its role understandable.

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 this is a binding test: it mentions the unbound error and tells the user to check the phone's 5G message app after success. However, it never explicitly says when to use this tool versus alternatives such as open_cmcc_bind, open_cmcc_unbind, or open_cmcc_info.

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 only states 'high-risk unbind' plus the generic response format. It does not disclose side effects, irreversibility, prerequisites, or post-condition of the unbind operation.

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

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

The description is a single compact line that front-loads the endpoint and risk level, then covers parameters and response format with no filler.

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

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

The operation is simple (no parameters) and the response format is described, which is adequate for invoking the endpoint. However, as a high-risk unbind operation with no annotations, it should explain what the unbind does and what happens after calling it.

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

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

The tool has zero parameters and the schema is fully covered at 100%. The description explicitly states '请求参数: 无', which satisfies the baseline for a no-parameter 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 states the action (解绑/unbind) and resource (新消息ClawBot) with the endpoint and a high-risk flag. However, it does not explicitly differentiate this from the sibling open_clawbot_unbind, which also appears to unbind a ClawBot.

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 call this tool versus alternatives such as open_cmcc_bind or open_clawbot_unbind. The 'high-risk' label is a warning, not usage 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?

No annotations are provided, so the description carries the full burden. It discloses the HTTP method, pagination defaults and limits, the unified response envelope, and the paginated data shape with list item fields. It does not explicitly state that the operation is read-only or describe auth requirements, but the list semantics imply a non-mutating call.

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

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

The description is compact and well organized into endpoint, request pagination, unified response, pagination response, and item fields. Every sentence adds operational detail such as defaults, maximum page size, or response structure, with no filler or redundancy.

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

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

For a simple two-parameter list tool with no output schema and no annotations, the description covers pagination request fields, the standard response envelope, the paginated data structure, and the fields inside each list item. It lacks only broader context like authentication or placement of parameters in the request body, but nothing essential to invoking the call correctly is missing.

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

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

The input schema already documents both current and pageSize with descriptions, and schema coverage is 100%. The description restates these parameters and adds default/max values, but those are already in the schema, so the description adds little beyond what the structured data provides.

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

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

States a specific verb and resource: '获取企业微信应用列表' and the exact endpoint 'POST /open/cp/list'. The phrase '企业微信应用列表' clearly distinguishes this from sibling list tools like open_mp_list or open_mail_list.

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 makes it clear this is the tool for paginated enterprise WeChat application list retrieval. It does not explicitly name alternatives or exclusions, but the resource scope is specific enough for an agent to infer when to select it among many sibling list tools.

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

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

With no annotations, the description carries the behavioral burden. It discloses the HTTP method, the fact that MCP assembles the multipart body, the unified response envelope (code/msg/data), and the typical success payload (image URL string). It does not mention side effects beyond creating an uploaded image, but it is substantially transparent.

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

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

The description is compact and front-loaded: endpoint and invocation first, then parameters, then the alternative flow, then the response format. Every sentence contributes information relevant to calling the tool correctly, with no padding.

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

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

Given two simple parameters and no output schema, the description is complete: it documents auth method, multipart assembly, the alternative sibling, and the full response envelope including success code and data meaning. An agent has enough to invoke and interpret 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?

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful context: 'filename + contentBase64，由 MCP 组装 multipart' tells the agent it does not need to build multipart encoding itself. It also reinforces that contentBase64 should exclude the data: prefix, though the schema already states this.

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: '通过开放接口上传图片' and 'POST /open/file/uploadImage - 使用 access-key 直接上传图片（multipart file）'. It also names the sibling flow it is not (七牛直传流程/open_user_image_upload_token), making selection 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?

It gives a clear context: this tool directly uploads with access-key and MCP assembles the multipart request. It explicitly routes to open_user_image_upload_token when the official Qiniu flow is needed, but does not cover other exclusions such as file size limits or unsupported image formats.

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 exist, so the description carries the full disclosure burden, and it does reasonably well: the 'GET' verb signals a read-only, non-mutating call, the unified response envelope (code 200 = success) is described, and the matchResult enum values (0-条件不满足,1-已转发,2-频率限制,3-不在触发时间段,4-执行异常) explain how to interpret results. It omits auth requirements and any non-200 error behavior, keeping it short of a 5.

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 endpoint and required parameter are front-loaded, and the remaining bulk is a compact enumeration of response fields that replaces a missing output schema. It is dense and slightly run-on, but every listed field earns its place given 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 and no annotations, the description compensates by enumerating the full data payload and interpreting the matchResult values, which is exactly what an agent needs. It stops short of covering error conditions or how to obtain a logId, so it is not fully complete.

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

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

Schema coverage is 100% for the single logId parameter, so the schema already documents its type and meaning; the description only restates 'logId(记录编号,必填)'. No additional format, range, or sourcing guidance is added, so the baseline of 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?

The description states a specific verb+resource (GET /open/forwardLog/detail - 查看触发记录详情), making it clear this fetches a single forward-rule trigger record. The 'detail' vs the sibling 'open_forward_log_list' distinction is implied by the resource name but never made explicit in the text.

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: the mandatory logId parameter signals that a specific record's identifier must already be known (presumably obtained from open_forward_log_list), but the description never names that sibling or states when to prefer this tool. No exclusions 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 burden and does well: it discloses pagination defaults (current=1, pageSize=20, max 50), the meaning of each matchResult code, and the full response envelope. It omits auth requirements and error/rate-limit behavior, but the operational behavior is largely 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?

Content is front-loaded with endpoint and purpose, then pagination, filters, and return format. The description is dense and enumerates the full list item fields, but since no output schema exists these details earn their place rather than being padding.

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

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

There is no output schema, so the description responsibly documents the response envelope (code/msg/data), pagination fields, and the per-item list fields, plus filter semantics. Combined with the schema, an agent has everything needed to call and interpret the tool.

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

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

Schema description coverage is already 100%, so the schema fully documents all four parameters, including the matchResult enum. The description only restates the same parameter meanings, adding no syntax or format detail beyond the structured field. 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+resource combos (POST /open/forwardLog/list - 获取触发记录列表) so the agent knows this returns trigger records. It does not explicitly distinguish itself from the sibling open_forward_log_detail (singular detail view), which the description leaves to the agent to infer.

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 mentions that results can be filtered by ruleId and matchResult, implying a listing/filter workflow, but gives no explicit when-to-use, when-not-to-use, or named alternative such as open_forward_log_detail. Usage is inferred 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the membership requirement, that variables/targets/condition must be passed as JSON strings, and the unified response envelope (code/msg/data). However, it does not cover broader mutation behavior such as permission requirements beyond membership, duplicate handling, or side effects.

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

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

Front-loaded with the endpoint and purpose, then key requirements. It is compact and mostly earns its place, though repeating the sourceType enum values already documented in the schema is slightly 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?

For a 20-parameter mutation tool with no annotations and no output schema, the description is adequate but incomplete. It covers the required field, JSON string encoding for complex parameters, membership prerequisite, and response envelope, but omits guidance on alternatives and deeper behavioral 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 100%, so the schema already documents all 20 parameters well. The description adds only the required field (ruleName) and the fact that variables/targets/condition are JSON strings, plus repeats sourceType enum values already in the schema. Baseline 3 is appropriate.

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 ('消息规则'), plus the endpoint POST /open/forwardRule/add. The verb clearly distinguishes this create tool from sibling edit/delete/list/detail 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?

Gives a prerequisite ('需会员才能开启'), which is useful usage context, but does not explicitly say when to use this versus open_forward_rule_edit, open_forward_rule_test, or other sibling tools. Usage is only implied by the create verb.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that this is a GET call and describes the unified response envelope (code/msg/data, 200 = success), which is real behavioral context since there is no output schema. However, it says nothing about idempotency, side effects on forwarding behavior, or required authorization for a state mutation.

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?

Compact and front-loaded, leading with the endpoint and the enable/disable purpose, then parameters, then response shape. The HTTP method/URL prefix is mildly redundant but functions as useful endpoint context; no sentence is wasted.

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

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

For a two-parameter toggle the description covers purpose, both params, and the response envelope, which is adequate. It stops short of routing the agent away from the sibling edit/delete tools and omits any authorization or side-effect context, leaving real gaps for a mutation.

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% and both parameters are already documented as 规则编号 and 状态；1-启用，0-停用. The description's restatement of ruleId and status(1启用/0停用) adds no meaning beyond the schema, so the baseline of 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?

The description names a specific action pair (启用或停用) and a specific resource (消息规则), so an agent knows exactly what the tool mutates. It is implicitly distinct from open_forward_rule_edit/delete, though it never explicitly names those siblings to draw the boundary.

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 status toggle versus open_forward_rule_edit (which presumably changes other fields), and no mention of prerequisites or permissions. The agent must infer that this is the dedicated enable/disable path 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 burden. It does signal the high-risk/mutating nature of the operation and shows the unified response shape (code/msg/data), which is useful. But it omits critical behavioral details such as whether deletion is reversible, permission requirements, or cascading effects on associated forwarding logs.

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?

Compact single paragraph that front-loads the HTTP method/path and the risk flag. Efficient, though it mixes endpoint notation, risk, request params, and response format into one dense string.

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 1-param mutation with no output schema, the essentials (endpoint, required param, response envelope) are present. However, given zero annotations and the high-risk nature, more guidance on consequence/permission/auth would make it 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 single parameter ruleId is fully documented in the schema (100% coverage) as '规则编号', and the description merely restates it as '规则编号,必填'. The schema already carries this, so the description adds no new semantic meaning. Baseline 3 for high coverage.

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 ('删除消息规则', delete message rule) plus the concrete endpoint. It's clear what the tool does and it is distinguishable from the other forward_rule siblings (add, edit, list, detail), though it doesn't explicitly name 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?

The '高风险' (high-risk) warning hints at caution, but there is no explicit when-to-use guidance, no statement of irreversible effects, and no reference to alternatives. An agent must infer that this permanently removes a rule.

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

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

With no annotations, the description carries the full burden and does substantial work: it declares the membership gating, the unified response envelope (code 200 = success, msg, data), and enumerates the meaning of trigger-source, variable-source, and extraction-method codes. It omits pagination/error behavior, but for a simple read detail call this is solid disclosure.

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

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

Front-loaded with the endpoint and purpose, followed by request and response contract. The dense enum listing is justified because no output schema exists, though the generic '统一响应' boilerplate is somewhat repetitive.

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 no output schema, the description usefully explains the return envelope and the semantics of returned field codes, which is the missing piece for an agent to interpret results. It falls short only on sibling routing and error handling.

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 100% and the single ruleId parameter is fully documented in the schema; the description repeats 'ruleId(规则编号,必填)' without adding syntax or format beyond it. Baseline 3 is correct 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?

States a specific endpoint and resource (GET /open/forwardRule/detail – 消息规则详情), so an agent knows it retrieves a single rule's detail. However, it never distinguishes itself from the many sibling rule tools (open_forward_rule_list, open_forward_rule_get_setting, etc.), relying on the name alone to convey 'detail vs list'.

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 and no alternative named. It notes a membership prerequisite ('需会员才能开启') but never says when to pick this over open_forward_rule_list or open_forward_rule_get_setting, leaving 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?

With no annotations, the description carries the full burden and delivers the single most important behavioral fact: "会整体覆盖变量和发送目标" — an update fully overwrites variables and targets, which an agent must know before calling. It also notes the membership requirement, though it says nothing about auth scope, reversibility, or what happens to fields omitted from the payload.

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 block that front-loads the route, the action, and the overwrite warning before the field/response details. The generic "统一响应" boilerplate is low-value but short and does not bury the important content.

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 21-parameter mutation tool with no annotations and no output schema, the description covers the critical gaps: overwrite semantics, membership prerequisite, required fields, and a response envelope description. Remaining gaps (auth scope, effect of omitted fields) are real but modest given that the schema documents every parameter.

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% across 21 parameters, so the schema already documents each field in detail; the baseline is 3. The description only restates the two required fields (already in the schema's required list) and defers the rest to the add tool, adding minimal semantic value.

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

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

The description states a specific verb+resource ("修改消息规则") and the concrete HTTP route, which makes the intent unmistakable. It implicitly distinguishes itself from siblings like open_forward_rule_add by pointing to that tool for unspecified fields ("其余同新增"), but it never explicitly contrasts with rule_change_status or rule_save_setting, so sibling differentiation is only partial.

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

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

It gives a usable precondition ("需会员才能开启") and names the required fields, plus routes unknown field semantics to open_forward_rule_add. However, it never says when to choose this edit tool over open_forward_rule_change_status or open_forward_rule_save_setting, so the usage guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden, and it does disclose the response envelope (code/msg/data) and the meaning of each data.mode value (0/1/2), which is genuinely useful behavior beyond the schema. It does not mention permissions or error conditions, but for a read-only master-switch lookup this is solid.

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

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

Three compact sentences: endpoint, response envelope, then field semantics. The critical enumeration of mode values is front-loaded after the endpoint and nothing is padded.

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

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

No input params exists, no output schema exists, so the description must (and does) explain the return shape and the mode enum. It is adequate for a simple read tool, though it stops short of stating prerequisites or how this setting interacts with the save_setting sibling.

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 are zero input parameters, so the 4-baseline applies. The description does, however, document the return-field semantics of data.mode, which is extra value even though it concerns output rather than input.

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 (获取/get) and resource (消息规则总开关/message-rule master switch), and the HTTP endpoint 'GET /open/forwardRule/setting' pins the operation down. This clearly distinguishes it from siblings like open_forward_rule_list or open_forward_rule_save_setting.

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 endpoint and the fact that this is a read of the master switch imply usage, but there is no explicit guidance on when to call this versus open_forward_rule_list, open_forward_rule_detail, or open_forward_rule_save_setting. A one-line routing cue would have earned a higher score.

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 a good job: it discloses the membership precondition, the pagination ceiling (max 50), and the complete success/response envelope including business-data fields. It does not discuss auth header requirements or failure modes, but the behavioral picture is substantially richer than the schema alone.

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 purpose and pagination parameters are front-loaded before the response-field enumeration, so the most important information is immediately visible. The long list-item breakdown (id, tokenId, sourceType, status, etc.) is dense and reads as a data dictionary, but it earns its place given the absence of an output schema.

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 2-parameter read-only list tool with no output schema and no annotations, the description supplies the endpoint, pagination contract, response envelope, and every list-item field — enough for an agent to call it and interpret the result. Only the auth mechanics and the relative role of the sibling rule tools are left unspecified.

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% and both parameters (current, pageSize) are already documented in the schema with their defaults. The description repeats the same defaults and the 20/max-50 constraint, adding essentially no meaning beyond the structured field definitions, which is the baseline-3 case.

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

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

The description states a specific verb+resource (获取消息规则列表) and the underlying endpoint POST /open/forwardRule/list, making the operation unambiguous. It does not, however, explicitly distinguish this list operation from siblings such as open_forward_rule_detail or open_forward_rule_test, so sibling differentiation relies on 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?

It notes the membership requirement (需会员才能开启), which is a useful prerequisite. But it never says when to use this list tool versus open_forward_rule_detail (single rule) or open_forward_rule_add/edit, leaving usage context implied by the name 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 does disclose the membership gate, the exact failure message, and the unified response envelope (code/msg/data), which is genuine value. It says nothing about side effects, whether this overrides existing rule settings, or reversibility, so it is only partially complete for a mutation 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 text is a single dense paragraph mixing HTTP verb, effect, membership rule, a verbatim restatement of the mode parameter, and the response envelope. It is front-loaded on the core purpose, but the duplicated mode text and response boilerplate dilute it.

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

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

With one required integer parameter, no annotations, and no output schema, the definition supplies the missing pieces an agent needs: the membership prerequisite and the return envelope (code/msg/data). Nothing critical for correct invocation is absent, though the relationship to the per-rule forward-rule tools remains 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?

Schema description coverage is 100% and the only parameter (mode) is documented in the schema with the same enumeration text. The description merely repeats that text verbatim, adding no syntax, default, or interaction detail beyond the schema, so the baseline of 3 is appropriate.

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 — 设置消息规则总开关 (set the forward-rule master switch) — and describes the three modes, so the agent knows exactly what state this tool changes. It does not, however, distinguish it from close siblings such as open_forward_rule_change_status or open_forward_rule_get_setting, leaving that to inference.

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

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

There is a real precondition disclosed: modes 1 and 2 require membership, otherwise the API returns 「消息规则需开通会员后才能开启」. That is useful usage context, but there is no explicit when-to-use-this-vs-alternatives guidance (e.g. versus change_status or the per-rule edit tools), so usage 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 carries the full burden and does disclose key behavioral traits: the operation is non-destructive ('不会真正发送') and gated on membership ('需会员才能开启'). It also spells out the response envelope (code/msg/data) and the fields inside data, which is real added value beyond structured fields.

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

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

Front-loaded with the purpose and endpoint, then the important no-send/membership caveat, then the response shape. It is dense but every element earns its place, especially the response description given there is no output schema.

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 16-parameter tool with no annotations and no output schema, the description compensates well by documenting the return envelope and data fields and by flagging the membership prerequisite and non-sending behavior. Parameter-level usage is left to the schema, which is fully covered.

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 all 16 parameters are already documented in the schema. The description adds no per-parameter meaning beyond what the schema provides, so the baseline of 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?

The description gives a specific verb and resource ('用模拟请求测试规则' – test a rule with a simulated request) and adds the crucial qualifier that nothing is actually sent. This clearly distinguishes it from the surrounding open_forward_rule_add/edit/delete/list siblings, though it does not name a specific 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?

It provides context (simulated request, no real send, membership required to enable) which implies when to use it, but there is no explicit when-to-use vs. alternatives or when-not-to-use guidance relative to the other forward_rule tools.

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

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

No annotations are provided, so the description carries the full transparency burden. It explicitly discloses high risk, the fact that both sides of the friendship are dissolved, the other person can no longer add you, and that self-blacklisting is impossible. This fully informs the agent about the destructive side effects.

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

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

The description is compact and well-structured: risk is front-loaded first, followed by behavioral consequences, eligibility constraints, request parameter, and response format. Every sentence contributes useful information without fluff.

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

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

For a single-parameter mutation tool with no output schema, the description covers the endpoint, risk level, side effects, eligibility rules, request parameter, and unified response fields. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so the schema already documents friendId and its source from the friend list. The description repeats this information without adding materially new semantics, so a baseline score of 3 is appropriate.

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: adding an existing friend to the blacklist via the POST endpoint. It also differentiates itself from siblings like open_friend_remove_blacklist and open_friend_blacklist_list by specifying the exact scope and effect.

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 strong usage context: use it to blacklist an existing friend, not yourself, and only for people already in your friend list. It does not explicitly name alternatives such as open_friend_remove_blacklist for undoing the action, but the conditions are clear enough for correct selection.

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

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

With no annotations, the description carries the full burden and covers behavior well: it documents pagination defaults, max page size, the uniform response envelope (code/msg/data), and the exact fields in each blacklist entry. It doesn't mention auth or rate limits, but the read-only nature is clear from '获取' and there are no mutation hints.

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 dense and well organized: purpose first, then request parameters, response envelope, pagination structure, and list item fields. Every sentence carries useful information and there is no filler.

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

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

For a simple list tool with two optional parameters and no output schema, the description provides enough to invoke it and interpret results, including list item semantics and the note that id is used for解除黑名单. It omits error handling and authentication details, but those are not critical for a paginated read-only list call.

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

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

Schema description coverage is 100%, and the schema already documents current's default and pageSize's default/maximum. The description repeats these constraints without adding new semantic meaning, so it meets the baseline but contributes no extra parameter insight.

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 operation and resource: '获取好友黑名单列表' via POST /open/friend/blacklistList. This distinguishes it from sibling tools such as open_friend_list (regular friend list) and open_friend_add_blacklist/remove_blacklist (mutating blacklist operations).

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

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

The description implies the tool is for retrieving a paginated list of blacklisted friends, which is enough for basic selection. However, it gives no explicit when-to-use guidance and does not contrast it with similar siblings like open_topic_user_blacklist_list, so the agent must infer the right choice largely 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?

With no annotations, the description carries the behavioral disclosure burden. It does label the operation '高风险' (high risk), exposing its destructive nature, and it documents the unified response format (code/msg/data). It does not go further to state irreversibility, authorization requirements, or consequences beyond deleting the friendship, so it is adequate but not rich.

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

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

The description is compact and front-loaded: endpoint, risk label, required parameter, and response contract each in logical order. It avoids fluff, though the response-format sentence is generic and could be considered unnecessary; overall this is efficient 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?

This is a low-complexity, two-parameter destructive tool with no output schema. The description compensates for the missing output schema by defining the unified response contract and flags high risk. It could mention irreversibility or require additional confirmation, but for a simple delete-friend call the provided context is sufficient to invoke 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 100%, so the schema already documents both friendId and appId. The description adds the '必填' (required) marker and says friendId comes from the friend list, which repeats the schema's meaning rather than adding new semantics. The baseline of 3 is appropriate because the schema carries the parameter load.

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

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

The description uses a specific verb and resource combination: '删除好友' (delete friend), preceded by the exact endpoint. Even without opening the schema, an agent can distinguish it from sibling friend-management tools like open_friend_list, open_friend_edit_remark, and open_friend_add_blacklist. The endpoint and risk label add no ambiguity.

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 by requiring friendId '来自好友列表 friendId', which points the agent to fetch a valid friendId from a friend-list source first. However, it does not explicitly say when to choose this tool over related friend operations or when not to use it, so the guidance remains implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden. It discloses the HTTP method (POST), required parameters, and the unified response format (code, msg, data), which provides some behavioral context. However, it does not detail side effects, idempotency, error conditions, or prerequisites beyond the id originating from a list. The description adequately conveys it is a write operation but lacks deeper behavioral transparency.

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

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

The description is a compact, front-loaded statement: endpoint and purpose first, then parameters, then response format. Every sentence earns its place with no filler. It is appropriately sized for a simple two-parameter edit operation.

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 a simple operation with two fully documented parameters and no output schema, the description covers the essentials: endpoint, purpose, required fields, and response envelope. It lacks a detailed data shape for the response, but for an edit-remark action the success/failure code is likely sufficient. The context is complete enough 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 100%, so the schema already documents both parameters. The description essentially repeats the schema: id is the friend number from the list, remark is the note. It adds no new semantic meaning beyond what's already in the input schema, meriting the baseline score.

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 operation '修改好友备注' (modify friend remark) with the specific resource '好友备注'. It names the endpoint and explicitly identifies the target as '好友', distinguishing it from sibling tools like open_topic_user_edit_remark. An agent can immediately understand what this tool does without opening the schema.

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

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

Usage is implied by the description: it is for editing a friend's remark, and the mention '列表 id 字段' hints that the id comes from a friend list operation. However, there is no explicit when/when-not guidance or reference to alternative tools such as open_friend_list or open_topic_user_edit_remark. The description leaves the agent to infer the context.

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

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

With no annotations, the description carries the full burden and does a solid job: it reveals the operation is a GET request, documents the unified response shape (code/msg/data), and names the returned data field qrCodeImgUrl. It could add more detail about auth requirements or error cases, but the core behavior is transparent.

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

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

The description is compact and organized: endpoint, purpose, parameter list, unified response, and data field. It front-loads the key purpose and does not include filler, though it reads as a dense paragraph rather than structured bullets.

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, so the description correctly compensates by explaining the unified response and the qrCodeImgUrl field. All four optional parameters are covered with defaults and ranges, and the endpoint and purpose are clear. Nothing essential is missing for an agent to invoke this 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 100%, so the schema already documents all four parameters. The description adds defaults and ranges (604800, 30 days, -1, 1-999) which mostly mirror the schema descriptions; it does not materially expand semantics beyond the structured definitions. Baseline 3 is appropriate.

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

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

The description names a specific HTTP method and resource (GET /open/friend/getQrCode) and states the exact purpose: 获取个人二维码（用于添加好友）. The explicit '个人' scope distinguishes it from sibling QR-code tools like open_topic_qr_code and open_clawbot_get_bot_qrcode, so an agent can tell them apart.

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

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

The description implies when to use the tool by saying it is for adding friends, but it does not explicitly state when to use it over alternatives, nor does it mention any exclusions or prerequisites. The usage context is inferable, not 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, the description carries the burden of explaining behavior, and it does so by documenting pagination behavior, the unified response envelope, paginated data shape, and each list item's fields including the token's purpose. It does not explicitly mention authentication or confirm there are no side effects, but '获取' strongly implies a read operation and the response contract is well detailed.

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 front-loaded with endpoint and purpose, then moves into pagination, response envelope, paginated data, and list item fields in a logical order. It is dense but not bloated; the field enumeration is justified because 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?

Given the tool's simplicity (two optional parameters, no output schema, no annotations), the description is complete: it specifies request parameters, defaults, limits, the uniform response envelope, pagination fields, and the full set of list item fields. An agent has enough information to invoke the tool and interpret its response 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 100%: both current and pageSize already have meaningful descriptions with defaults and the 50 maximum. The tool description mostly repeats this information rather than adding new semantic context beyond the schema, so the baseline of 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?

The description opens with the exact HTTP method and path plus the Chinese action '获取好友列表' (get friend list), making the verb and resource explicit. It distinguishes itself from sibling friend-related tools like open_friend_delete and open_friend_edit_remark by clearly naming the list operation.

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

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

The description explains pagination usage (current, pageSize, defaults, max) but never states when to prefer this tool over alternatives or when not to use it. However, the name and purpose make the intended use obvious, and no sibling tool appears to be a competing friend-list endpoint.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly warns that the operation is high-risk and that removing the blacklist entry will not automatically restore the friend relationship, requiring a new QR-code scan. This is valuable behavior beyond the schema and adequately prepares the agent for the side effect.

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

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

The description is compact and front-loaded with the endpoint and risk warning. Each sentence earns its place: risk, side effect, parameter explanation, and response format. It conveys the necessary information without fluff.

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

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

For a single-parameter tool with no output schema, the description covers the critical aspects: the operation, its risk, the parameter source, and the unified response format. It does not describe the exact content of 'data', but this is not essential for invoking a simple removal operation.

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

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

Schema description coverage is 100%: the schema already documents 'id' as the blacklist record ID from the blacklist list's id field. The description largely restates this and adds the 'required' flag, which is already in the schema. No significant new parameter meaning 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?

The description states a specific action ('解除好友黑名单' / remove friend blacklist) and the exact REST endpoint, making the resource and verb unambiguous. It is clearly distinct from sibling tools like open_friend_add_blacklist or open_friend_blacklist_list.

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

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

The description clearly indicates when the tool is appropriate: to remove a friend from the blacklist. It also provides important cautionary context by warning that removal is high-risk and does not restore the friend relationship automatically. It does not explicitly name alternatives or exclusions, but the use case is clear.

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

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

With no annotations, the description takes the full burden and does so thoroughly: it discloses the ~7200-second validity, notes that repeated acquisition invalidates the previous key, warns of 403 when prerequisites aren't met, and documents the unified response fields including accessKey and expiresIn. This is rich behavioral disclosure beyond a bare 'get credential' statement.

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

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

The description is compact yet dense, starting with the endpoint and purpose, then covering prerequisites, behavior, and response format. Each sentence contributes essential operational information and there is no filler or repetition.

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

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

For a zero-parameter, no-output-schema tool with no annotations, this description is fully self-sufficient. It covers prerequisites, authentication variables, token lifecycle, response structure, and how to use the result, so an agent has everything needed to call and consume it correctly.

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

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

The input schema has zero parameters, so the baseline is 4; the description exceeds it by explaining how authentication is supplied via environment variables PUSHPLUS_TOKEN and PUSHPLUS_SECRET_KEY, and how the returned accessKey should be placed in the 'access-key' header. This adds meaning that the empty schema cannot convey.

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: '获取开放接口调用凭证' (obtain open interface access credential), and names the exact endpoint POST /common/openApi/getAccessKey. It clearly distinguishes this from the many sibling open_* tools by framing it as the credential-issuing tool.

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 clear context: which environment variables are required, that the open interface must be enabled, that a security IP must be configured, and that other open_* tools automatically exchange and cache the key. It stops short of an explicit when-to-use/when-not-to-use rule, but the guidance is strong enough for an agent to decide correctly.

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 discloses the HTTP method (GET), the unified response shape (code/msg/data), and the returned data fields, including smtpSsl semantics. However, it does not mention authentication requirements, error behavior, or whether the password field is sensitive/redacted.

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

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

The description is compact and front-loaded with the endpoint and purpose, then lists the request parameter and response fields in a structured way. Every sentence adds necessary information with no filler.

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

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

For a simple single-parameter GET detail tool with no output schema, the description covers the request, required parameter, and response data fields. It is sufficiently complete to call correctly, though it lacks explicit usage guidance and auth context.

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

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

The input schema already fully documents mailId with a description and required flag. The description restates mailId as '必填' and mentions it in the URL, but adds no additional meaning beyond the schema.

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

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

The description clearly states this is a GET endpoint for mail channel details ('邮箱渠道详情') and specifies the resource via mailId. It is easily distinguishable from the sibling open_mail_list, since this is the detail variant.

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 '详情' (detail) wording and the requirement of a mailId, but the description does not explicitly say when to use this tool versus open_mail_list or other detail tools. No exclusions or alternatives are named.

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 and does well by documenting the unified response envelope, pagination fields, and list item fields. The only minor omission is auth requirements and error-code behavior beyond the generic 200 success case.

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 well-structured and front-loaded with the endpoint and resource, followed by compact request and response sections. It is detailed rather than verbose, and every sentence carries functional information. A short example would be a minor improvement.

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 2-parameter list endpoint with no output schema and no annotations, the description is unusually complete: it covers request parameters, pagination behavior, the response envelope, and list item fields. It lacks only optional extras like authentication prerequisites and non-success error variants.

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 100%, so the schema already defines current and pageSize. The description adds useful context around defaults and maximums, but mostly repeats schema information and contributes no new parameter-level 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?

The description clearly states the endpoint, HTTP method, and resource: 'POST /open/mail/list - 获取邮箱渠道列表'. It is immediately distinguishable from sibling tools like open_mail_detail and open_message_list because it explicitly names the resource (mail channel list) and the list operation.

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

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

The purpose of retrieving a paginated mail channel list is clearly conveyed, so an agent can infer when to use this tool. It does not explicitly name alternatives or when-not-to-use conditions, but no exclusions are needed given the straightforward list semantics.

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 responsibility for disclosing behavior. It explicitly states the high-risk nature, that all recipients lose access after deletion, and that the action cannot be undone. It also discloses the unified response structure. This goes beyond what the raw schea or endpoint alone would convey.

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?

Every sentence carries meaningful information: the endpoint, the high-risk/irreversibility warning, the required parameter, and the response format. It is compact, well-organized, and front-loads the most critical safety information before procedural 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 single-parameter delete operation with no output schema, the description covers the essential behavioral details: what gets deleted, the consequences, irreversibility, how to supply the parameter, and the shape of the response. No critical knowledge needed to invoke or understand the tool is missing.

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

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

The input schema has 100% parameter description coverage for shortCode, and the description simply repeats the parameter name and required flag. While it confirms the field is mandatory, it adds no format, length, origin, or relationship to other messages beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states a specific verb+resource via the HTTP method and endpoint ('DELETE /open/message/deleteMessage') and clearly communicates the destructive intent: deleting a message so all recipients can no longer see it. This distinguishes it from non-delete sibling tools such as open_message_list and open_message_send_result, and from delete tools targeting other resourcesses like topics or friends.

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 makes the usage context unmistakable: use this when you need to permanently remove a message from all recipients. It does not nae alternative tools or exclusions, but given that no sibling tool offers message deletion, the context is clear enough. The high-risk warning also advises againt casual use.

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 the standard response envelope (code/msg/data), the pagination response shape (pageNum/pageSize/total/pages/list), and the list item fields, as well as defaults and limits for page and pageSize. It does not mention authentication, side effects, or error behavior, but the read/query nature and response detail provide solid transparency.

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

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

The description is front-loaded with its purpose, then compacts request parameters, response envelope, pagination fields, and list item fields into a dense but clearly structured block. Every sentence earns its place, especially because there is no output schema to fall back on for return-value documentation. No redundant or filler content is present.

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 5-parameter optional-input list endpoint with no output schema, the description is quite complete: it covers all request parameters, defaults, max values, response wrapper, pagination structure, and list item fields. The only gaps are explicit sorting behavior, error-code semantics beyond 200, and a clearer pointer to sibling tools for send-result or delete operations.

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 the baseline is 3. The description largely repeats parameter meanings already in the schema, such as current default 1, pageSize default 20/max 50, and channel examples. It adds no significant new parameter-level meaning beyond what the input schema already provides.

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

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

The description states a clear verb and resource: '分页查询消息列表' (paginated query of message list), and gives the endpoint path POST /open/message/list. It is clearly a list/query operation, but it does not explicitly differentiate itself from siblings like open_message_send_result or open_message_delete, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as open_message_send_result or open_message_delete. The description only mentions that shortCode can be used to check send results, but it never names an alternate tool or states when this list endpoint is preferred. Usage context is merely implied by the verb 'query'.

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 discloses the HTTP method, unified response shape, data fields, and the status enum with meanings, which is substantial. It does not discuss authentication or rate limits, but for a simple GET-style query the provided behavioral detail is strong.

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?

Concise and front-loaded: endpoint and purpose first, then a compact response spec. Every sentence carries useful information and there is no filler.

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

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

For a one-parameter, low-complexity query tool with no output schema, the description covers the necessary operational details: endpoint, status meanings, error field, and update time. It could slightly improve by explicitly routing the agent to use this after send-message calls, but the parameter schema already supplies that 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 100%; the schema already defines shortCode as the short link code returned by the send-message interface. The description adds no new param semantics beyond confirming the lookup key, so 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, resource, and scope: 'GET /open/message/sendMessageResult - 按 shortCode 查询投递结果'. This clearly distinguishes it from message-sending, message-listing, and message-deleting 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?

Usage is implied rather than explicit: querying by shortCode after a send operation. The schema parameter adds that the shortCode is returned synchronously by the send-message interface, but the description does not state when to use this tool instead of alternatives or provide exclusions.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses the HTTP method, the unified response envelope, and the relationship between detail fields and list fields, which is useful. It does not mention authentication, error behavior, rate limits, or explicitly guarantee non-destructiveness.

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

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

The description is compact, front-loaded with the endpoint and purpose, and then covers request, response, and data semantics in three concise clauses. No filler or redundant prose.

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

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

For a simple one-parameter read endpoint with no output schema, the description gives the response envelope and hints at field completeness relative to the list. It lacks exact detail fields and error handling, which leaves some ambiguity but is adequate for basic 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 100%, and the schema already explains id as 微信公众号编号. The description repeats the parameter name and required status but adds little 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?

The description clearly identifies the resource as 公众号详情 and the operation as GET /open/mp/detail, implying retrieval of official account details by id. It is semantically distinguishable from sibling open_mp_list, though it does not explicitly call out the distinction.

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

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

The usage context is implied: this is a detail endpoint keyed by an id, so it should be used when a specific 公众号's details are needed. However, it does not explicitly state when to prefer it over open_mp_list or provide exclusion 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 burden of behavioral disclosure. It discloses the response envelope (code/msg/data), pagination semantics, and detailed list item fields with enum meanings. It does not mention authentication, error cases beyond code 200, or whether the operation has side effects, but for a list operation the provided detail is strong.

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 dense and every clause adds useful information: endpoint, purpose, request parameters, response envelope, pagination fields, and list item fields. It is somewhat long and could benefit from line breaks, but it avoids filler and is appropriately front-loaded with purpose and usage.

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 there is no output schema, the description compensates well by explaining the full response shape, pagination fields, and list item attributes including enum values. It is complete enough for an agent to call the tool and interpret results, though it omits non-200 error handling and authentication prerequisites.

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 already describes both parameters with defaults and max values, giving 100% schema coverage. The description repeats this information and adds response-level pagination details, but does not add meaning to the parameters themselves beyond what the schema already states.

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 ('获取') and resource ('微信公众号渠道列表'), and specifies the HTTP method and endpoint. It is distinct from siblings like open_mp_detail because it explicitly describes a paginated listing operation, though it does not explicitly name or contrast sibling tools.

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

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

The intended use is implied by the description: retrieve the WeChat official account channel list with pagination. It provides concrete pagination usage (current, pageSize defaults and max), but gives no explicit guidance about when to choose this tool over alternatives such as open_mp_detail or open_cp_list.

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

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

With no annotations, the description carries the full burden. It discloses that this is a mutating, high-risk operation and describes the unified response format. However, it does not mention side effects such as irreversible point deduction, authorization/permission needs, or failure behavior beyond a 200 success code.

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

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

The description is compact and efficient: it front-loads the endpoint and risk level, then covers request parameters and response structure in two sentences. No unnecessary words; every part 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 two-parameter tool, the description includes both request and response contracts, which is reasonable. However, 'data: 提现业务结果对象' is vague, and there is no elaboration on error cases or the consequences of the withdrawal. A high-risk operation would benefit from more detail about what could go wrong and what the agent should communicate to the user.

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 already provides descriptions for both parameters ('收款账户ID' and '提现积分'), and the description simply restates them without adding new constraints or context. There is no mention of value ranges, positivity requirements, or interactions between accountId and points, so the description adds little beyond the schema.

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

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

The description clearly identifies the action and resource: '发起积分提现' (initiate points withdrawal) with the endpoint POST /open/pay/transferOrder. The high-risk warning immediately signals the nature of the operation, and no sibling tool appears to perform a similar function, so distinction is inherent.

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

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

The description does not explicitly state when to use this tool versus alternatives or provide exclusions. The '高风险' (high-risk) label implies caution, but there is no guidance on prerequisites, confirmation requirements, or scenarios where this tool should be avoided. Given the long sibling list, an explicit usage note would be valuable.

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 discloses important behavioral details: the HTTP method is POST, membership is required, the unified response format is described, and the data returned is the newly created preprocessing ID. It could add more about possible failures or side effects, but it covers the essential 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 compact and front-loaded: it opens with the endpoint and purpose, then lists required parameters, then closes with the unified response shape. Every sentence earns its place without redundant fluff.

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

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

For a simple create endpoint with four required scalar parameters and no output schema, the description is complete: it states the action, the membership prerequisite, all required inputs, and the response structure including the data field. An agent has enough information to invoke 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 100%, so the baseline is 3. The description repeats the parameter meanings already present in the schema and adds only the '必填' markers and the contentType enum value, which are also inferable from the schema. It does not meaningfully expand parameter 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?

The description clearly states the action '新增预处理' with the specific resource and endpoint 'POST /open/pre/add'. It is immediately distinguishable from sibling tools like open_pre_list, open_pre_detail, open_pre_edit, and open_pre_delete because it uniquely identifies the create operation.

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

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

The description provides clear usage context: this tool is for adding new preprocessing information and requires membership ('需会员'). It does not explicitly mention alternatives or when not to use it, but the '新增' verb and the sibling tool names make the intended use obvious.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It explicitly flags the operation as high risk, states that membership is required, and documents the unified response format. It does not detail irreversibility or side effects, but the high-risk warning partially covers that.

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

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

The description is compact and structured: endpoint, risk level, membership requirement, request parameter, and response format are all included with no filler. Each sentence carries useful 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 single-parameter delete operation with no output schema, the description covers the essential invocation details: endpoint, required parameter, risk, membership, and response shape. It could add error cases or authentication specifics, but nothing critical is missing for basic use.

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 100% and the schema already describes preId as the preprocessing information ID. The description adds that it is required and labels it as 预处理编号, but this largely repeats the schema rather than providing deeper semantic meaning.

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 ('删除' / DELETE), a clear resource ('预处理'), and the endpoint path. It also adds high-risk and membership context, making it easy to distinguish from sibling operations like open_pre_add, open_pre_edit, open_pre_list, and open_pre_detail.

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 makes clear this tool is for deleting preprocessing information and that membership is required. It does not explicitly name alternatives or when-not-to-use scenarios, but the usage context is unambiguous given the DELETE verb and resource.

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 burden of behavioral disclosure. It reveals that this is a GET request, requires membership, and documents the unified response shape including code, msg, data, and the data fields. It does not describe non-200 errors or authorization details, but for a simple detail-read tool this is reasonably transparent.

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

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

The description is compact and front-loaded, starting with the endpoint and membership requirement, then giving the request parameter and response structure. Every sentence contributes useful information 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?

For a tool with a single parameter and no output schema, the description is complete: it covers the endpoint, required auth, the input, and the full response data shape including contentType mapping. An agent has enough context to call the tool and interpret its 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?

The schema already covers 100% of the parameter with type, required status, and a Chinese description. The tool description essentially repeats the same preId meaning without adding new format, constraints, or usage detail, so it provides no additional 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?

The description clearly identifies a GET endpoint that retrieves the detail of a preprocessing (预处理) record by preId, and lists the fields contained in the response. This differentiates it from sibling tools such as open_pre_list, open_pre_add, and open_pre_delete because it is specifically about retrieving one record's detail.

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 states that membership is required and that preId is mandatory, providing some usage context. However, it does not explicitly explain when to use this tool instead of open_pre_list or other preprocessing tools, so the usage is implied rather than clearly directed.

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 discloses the HTTP method, membership requirement, required parameters, unified response format, and sample response data. However, it does not cover side effects like overwrite behavior or failure details.

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

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

The description is compact and front-loaded with the endpoint and purpose. It packs necessary request and response details into one dense paragraph, though bullet-style structure could improve scannability.

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?

Since there is no output schema, the description compensates by explaining the unified response format and example data. It covers request requirements and the membership prerequisite, but lacks error-case details and field value examples.

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 the schema already documents all parameters. The description repeats requiredness and content type mapping without adding new parameter-specific 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?

Description states a specific verb and resource: '修改预处理' via POST /open/pre/edit. This clearly distinguishes it from sibling CRUD tools like open_pre_add, open_pre_list, open_pre_detail, and open_pre_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 is given on when to use this tool versus alternatives. It mentions the membership requirement but does not explain when to prefer this over open_pre_add or other pre-processing tools.

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

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

With no annotations, the description carries the full behavioral burden and largely meets it: it specifies POST, membership requirement, unified response envelope, pagination fields, and item fields. It does not address rate limits or explicitly state side-effect-free/read-only behavior, though '获取列表' strongly implies a read-only retrieval.

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

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

The description is compact, front-loaded with endpoint and purpose, then efficiently packs request and response details. Every clause contributes; minor density from semicolon-separated enumerations keeps it from 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?

For a two-optional-param list tool with no output schema, the description explains the pagination request, unified response, paginated data envelope, and list item fields. It stops short of indicating whether the parameters are sent in the query string or body, and no auth-header details are given beyond '需会员'.

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% and the description merely restates the defaults and max for current/pageSize. It adds no information 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?

The description names a specific HTTP endpoint and a clear action (获取预处理列表, get pre-processing list), with pagination semantics. It is distinguishable from the sibling detail/add/edit tools via the 'list' resource, but it does not explicitly call out the contrast with open_pre_detail.

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 that membership is required and shows how to paginate, so the agent knows the basic precondition and request shape. However, it provides no when-not-to-use guidance or explicit pointer to alternatives such as open_pre_detail for a single item.

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，因此描述承担了行为透明度的主要责任。描述披露了“需会员”的权限要求、请求参数、统一响应结构和返回的 data 为“预处理后的消息内容字符串”，让智能体知道调用后会得到处理结果。虽然没有明确说明该操作是否只读、是否执行用户代码，但“测试”和返回结果已经提供了足够的操作语义。

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

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

描述由三句话组成：第一句点明端点与用途，第二句罗列参数，第三句说明响应结构，信息组织清晰且没有冗余展开。请求参数部分与 schema 有少量重复，但整体仍属于紧凑高效的描述。

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?

工具参数简单且无嵌套对象，没有输出 schema，但描述明确解释了 data 为“预处理后的消息内容字符串”，弥补了返回值的说明缺失。同时包含了“需会员”这一关键调用前提；虽然未给出错误码细节，但统一响应中的 code/msg 已提供了基本错误信息框架。

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 为 100%，因此按校准基线应打 3 分。描述只是重复了 content、contentType、message 的中文含义，几乎没有补充超出 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?

明确说明了该工具用于“测试预处理代码”，并给出了具体的 HTTP 端点“POST /open/pre/test”，属于“特定动词+资源”的清晰表述。虽然没有像“与 open_pre_add 等工具对比”那样显式区分兄弟工具，但“测试”这一动作与预处理的增删改查兄弟工具在语义上已经明显不同。

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?

描述点明了使用前提“需会员”，并说明该工具用于测试预处理代码，暗含了与预处理增删改查工具的区别。但没有明确说明何时应使用本工具而非 open_pre_add、open_pre_edit 等其他兄弟工具，也没有明确的排除条件。

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 does well: it discloses the uniqueness constraint against duplicate creation, that qqCode is immutable after creation, that the group must permit proactive bot messages, and that botAppId must already be bound. It omits any auth/permission requirement or rate-limit context, keeping it short of a 5.

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

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

Front-loaded with the HTTP route and one-line purpose, then structured into 请求 / 限制 / 统一响应 blocks, so an agent can scan to the relevant clause. It is dense and repeats some facts already present in the schema (e.g. qqCode character rules), which costs it a point.

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

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

No output schema exists, and the description compensates by documenting the response envelope (code/msg/data). Combined with per-parameter conditions and the duplicate-creation restriction, the definition is nearly complete; only authentication and error-case behavior are unaddressed.

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 already 100%, so the baseline is 3; the description adds real value on top by spelling out cross-field conditions (qqGroupId required only when sendType=2, botAppId required only when sendType=1 and ignored otherwise, group's bot takes precedence for sendType=2) and format/immutability rules for qqCode.

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 (新增 QQ 机器人配置) and immediately explains the two operating modes (sendType=1 to self, sendType=2 to a QQ group) plus the no-config-needed case. However, it never distinguishes this tool from nearby siblings like open_qqbot_edit or open_qqbot_custom_bot_add, which an agent could easily confuse with 'add a QQ bot'.

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?

Provides clear conditional usage for each sendType and a genuine when-not-to-use hint ('只用默认机器人发给自己时无需配置'). It stops short of routing to alternatives (e.g. open_qqbot_edit for modification, open_qqbot_list for enumeration), which would make it a 5.

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

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

With no annotations, the description carries the full burden and does so well by documenting the uniform response envelope and every data field with their enums (isBind 0/1, receiveStatus 0/1, botType 1/2, shareUrl purpose). It does not state that this is a read-only query or mention auth/permission needs, which is the remaining 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?

Front-loaded with endpoint and purpose, then parameters, then response shape. The response enumeration is dense but each field earns its place because no output schema exists to carry it; only the redundant restatement of code/msg/data envelope is borderline filler.

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

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

For a single-optional-parameter read tool with no output schema, the description covers input sourcing, defaults, and the full return contract. Missing only ancillary context such as authentication requirements or rate limits, which are minor here.

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 already 100% for the single botAppId parameter, so the baseline is 3; the description earns an extra point by explaining the default behavior and, more valuably, citing the sibling tool and JSON path (bots[].botAppId) that supplies the value.

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 ('查询 QQ 机器人绑定状态') plus the underlying endpoint GET /open/qqBot/botInfo, so the agent knows exactly what this returns. It does not explicitly differentiate itself from close siblings like open_qqbot_my_bots or open_qqbot_list, which keeps it out of the top band.

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 notes botAppId is optional and defaults to the default bot, and tells the agent where to source the value ('取自 open_qqbot_my_bots 返回的 bots[].botAppId'). That is useful context, but there is no explicit when-to-use versus alternatives (e.g. my_bots vs list vs bind_link) or any stated prerequisite.

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

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

With no annotations, the description carries the full burden and does well: it discloses credential-verification gating, quota limits, which bots are ineligible, the required post-add binding step, and that appSecret is a sensitive credential that must not be echoed. It stops short of auth/permission semantics or rollback behavior, but the behavioral surface is well 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?

Content is front-loaded with the operation, then constraints, follow-up step, parameters, and response shape. It is dense and slightly over-packed into one block, but every clause conveys 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?

With no output schema, the description compensates by describing the uniform response envelope (code/msg/data with 200 success). Combined with the quota rules and the mandatory binding follow-up, an agent has enough to invoke and sequence the call 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 coverage is 100%, so baseline is 3, but the description adds real value beyond the schema by flagging appSecret as a sensitive credential that must not be echoed in replies, guiding safe handling of the 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 states a specific verb and resource ('添加自有 QQ 机器人' / add your own QQ bot) and scopes it with '自有' (custom/self-owned), which distinguishes it from the generic sibling open_qqbot_add without requiring the agent to open either schema.

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

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

It gives concrete usage conditions: validation must pass before saving, normal users are capped at 1 bot and members at 5, and official bots or bots already claimed by another account cannot be added. It also names the required follow-up tool open_qqbot_get_bind_link. No explicit 'use X instead of Y' routing, but the when-to-use conditions are clear.

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

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

With no annotations provided, the description carries the full burden and does so well: it discloses that deleting the bot also unbinds it, deletes its QQ groups, deletes configs that use it, and invalidates related options. It stops short of stating irreversibility, permission requirements, 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?

Front-loaded with the HTTP route and the high-risk warning, followed by the parameter and response shape; each sentence serves a purpose. The raw 'DELETE /open/qqBot/customBot/delete' route string is somewhat redundant but cheap.

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

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

For a one-parameter destructive tool with no output schema, the description covers the cascading side effects and describes the unified response envelope (code/msg/data), including the success code 200. Missing only permission/irreversibility 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 coverage is 100% and the single botAppId parameter is already documented in the schema. The description only restates it as '(自有机器人AppID,必填)', adding the required flag but no new format or constraint detail, so 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?

The description states a specific verb and resource (删除自有 QQ 机器人) and scopes it to '自有' custom bots, which separates it from the many open_qqbot_* siblings. It stops short of naming a specific sibling (e.g. open_qqbot_delete vs open_qqbot_custom_bot_delete ambiguity), so it does not reach full sibling 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 '高风险' label signals caution, but the description never states when to choose this tool over alternatives such as open_qqbot_unbind or open_qqbot_delete, nor any prerequisite or confirmation condition. Only implied usage is 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?

With no annotations, the description carries the full burden and delivers meaningful behavior: the new credential is saved only after validation passes ('新凭证校验通过才保存'), and the agent is told not to echo appSecret in its reply. It omits auth/permission requirements and what happens to the previous secret, so it is strong but not exhaustive.

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

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

A single dense block that front-loads the endpoint and the operation, then the parameters, then the response envelope. Every clause carries information and nothing is repeated from the schema verbatim.

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 no-annotation mutation tool with no output schema, the description covers purpose, required inputs, validation semantics, the security caveat, and the code/msg/data response shape. Auth prerequisites and downstream effects on the bot's existing bindings are the only notable 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 coverage is 100% and both parameters are typed and length-bounded in the schema, so the baseline is 3. The description adds genuine value on top: it marks both as required and adds the security instruction not to echo appSecret back to the user.

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: modifies the AppSecret of a self-owned QQ bot, with the trigger condition (re-sync after resetting on the QQ open platform). This implicitly separates it from open_qqbot_edit and open_qqbot_custom_bot_add/delete, but no sibling is named explicitly, so it stops short of a 5.

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

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

The parenthetical '在QQ开放平台重置后同步' gives a concrete when-to-use condition, which is more than most definitions offer. It gives no when-not-to-use guidance or pointer to alternatives such as open_qqbot_custom_bot_refresh, so it stays at 4.

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 and does so well: it discloses the non-persistent nature of the call, the IP-whitelist prerequisite, and that appSecret is sensitive and must not be echoed back in replies. It omits failure modes or rate limits, but covers the behaviors an agent most needs.

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

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

Front-loaded with the endpoint and its purpose, then prerequisites, request fields, and response shape in compact sentences. It is information-dense with little waste, though the response-envelope boilerplate (code/msg/data) adds some bulk.

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

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

No output schema exists, yet the description enumerates the returned data fields (botId, username, avatar, botAppId, shareUrl, botType) and explains the shareUrl use case. Combined with the prerequisite and sensitive-parameter note, an agent has everything needed to call and interpret this 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 coverage is already 100%, so baseline is 3, but the description adds meaning beyond the schema: it marks appSecret as a sensitive credential that must not be echoed, and labels both fields as required. That is genuine added semantics, not repetition.

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 precise verb+resource: validates a custom QQ bot using AppID/AppSecret and returns avatar/nickname. The qualifier '仅校验不保存' cleanly distinguishes it from the sibling write tools open_qqbot_custom_bot_add/edit/delete, so an agent can route without opening schemas.

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?

Provides an explicit precondition (add serverIps returned by open_qqbot_my_bots to the QQ open-platform IP whitelist) and the key distinction that this validates without persisting. It does not explicitly say to call this before open_qqbot_custom_bot_add, but the 'only validate, do not save' constraint makes the use case clear.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the HTTP verb (GET) and the unified response envelope fields (code=200 success, msg, data), but says nothing about whether it mutates locally stored bot info, what permissions are required, or any rate limits on refresh.

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

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

Front-loaded with the endpoint, then the purpose, then the request parameter and response shape — a compact, information-dense layout. The raw path prefix is mildly redundant but takes almost no space.

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?