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

No annotations are provided, so the description is the only source of behavioral context. It communicates that this is a read-only capability check (does not mutate state), which is useful, but it does not disclose what the response looks like or whether network/auth checks are involved. For a zero-parameter check, the description is adequate but minimal.

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

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

The description is a single, concise sentence that conveys the core purpose. It is appropriately brief for a tool with no parameters. It could arguably be more informative, but there is no wasted 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?

Given the tool's simplicity (no parameters, no output schema) and the presence of a similar sibling, the description is mostly sufficient. However, it lacks the output format or any conditions under which the answer might be false, which could be inferred from the name but would benefit from explicit disclosure.

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, so the schema is effectively trivially covered. The description adds meaning by explaining the operation's intent, which is useful for an agent deciding whether to call it. A baseline of 4 is appropriate when no parameters require additional 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 states a clear action ('Check if can send image') and resource, so the purpose is somewhat specific. However, it does not differentiate from the sibling tool 'can_send_record', which likely performs a similar check for a different resource type. An agent might confuse the two without additional context.

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 capability check before sending an image, but it does not specify when to use it versus alternatives, nor does it mention any prerequisites or typical usage context. With many sibling tools, more explicit guidance would help.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. 'Check if can send' implies a read-only capability probe, but it does not clarify side effects, required connection state, or how the result is expressed. With no annotations, this is minimal disclosure.

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

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

The description is a single short sentence with no redundant filler and is reasonably front-loaded. It is slightly awkward in phrasing but earns its place; the problem is under-specification, not verbosity.

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

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

Although the tool is low-complexity with no parameters, there is no output schema and no annotation safety profile. The description does not explain what the caller receives (e.g., a boolean, a result code) or what conditions affect the answer, leaving the agent to infer essential call semantics.

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 completely empty, so there is no parameter meaning for the description to add. Per the baseline for zero-param tools, this is appropriately scored.

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

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

The description uses a specific verb ('check') and target ('voice record'), so the basic operation is clear. It does not state the scope (friend/group) or explicitly differentiate itself from the sibling can_send_image, but the resource type is distinct enough to avoid confusion.

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

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

No guidance is given about when to use this tool versus alternatives such as can_send_image or send_* tools. There are no prerequisites, exclusions, or a stated pattern like 'call before sending a voice message.'

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 supplied, the one-word action 'Delete' carries the full behavioral burden. It implies mutation/destruction but doesn't state whether deletion is permanent, requires special permissions, or has side effects on group messages.

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

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

The description is a single front-loaded sentence with no filler or redundant phrases. It is appropriately sized for such a simple tool.

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

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

Despite the simple schema, the tool is destructive, has no annotations, and lacks any behavioral or situational detail. An agent has no way to know the consequences of calling it or what a successful call returns.

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

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

Schema coverage is 100%, so message_id is already documented as 'Message ID'. The description adds no additional meaning or constraints about what the ID refers to or how to obtain it.

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 concrete action and object: deleting an essence message. It is clear enough to recognize the tool's purpose, though it doesn't differentiate this from sibling delete_msg or explain what an essence message is.

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 context is given for when to use delete_essence_msg versus alternatives like delete_msg, set_essence_msg, or get_essence_msg_list. There are no usage conditions, prerequisites, or exclusions.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. 'Delete group file' only states the action; it does not disclose whether the deletion is permanent, requires special permissions, has side effects, or returns anything. This is insufficient for a destructive 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, front-loaded sentence with no redundant words. It is appropriately concise, though it could benefit from a bit more elaboration without sacrificing brevity. The structure is clean and easily parsed.

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 delete tool with no annotations, no output schema, and only 3 parameters, the description omits important operational context: prerequisites (e.g., need to have the file ID), whether the delete is permanent, and any permission requirements. The provided information is not enough for an agent to invoke the tool correctly in a real workflow.

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% – each parameter has a description ('File ID', 'Group ID', 'File type'). The tool description adds no extra meaning beyond the schema, so it does not enhance parameter understanding. Baseline 3 is appropriate since the schema is complete.

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') and resource ('group file'), which clearly identifies the action. It is not a tautology and distinguishes from sibling tools like upload_group_file or get_group_file_url, though it lacks any detail about scope or special conditions.

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

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

No guidance on when to use this tool versus alternatives. It does not mention that the file_id must be obtained from list/get operations first, nor any prerequisites like admin permissions. The absence of any usage context leaves the agent to guess the appropriate invocation flow.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Recall' implies a destructive or mutating action, but the description does not state whether the action is irreversible, what exactly happens to the message for recipients, what permissions are required, or what errors may occur.

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

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

'Recall message' is under-specified rather than usefully concise. It essentially restates the tool's purpose with no additional structure, context, or qualifiers, so it does not earn its place as a complete description.

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

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

For a mutating tool with no annotations and no output schema, this description leaves important operational details unstated, such as side effects, reversibility, restrictions, and failure behavior. Although the tool has only one parameter, the context provided is too thin for an agent to invoke it with full confidence.

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 the only parameter, message_id, with 100% coverage, so the baseline is 3. The description adds no extra meaning about how to obtain or use message_id beyond what the schema 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 uses a specific verb, 'Recall,' with the resource 'message,' which clearly conveys the core operation of deleting or withdrawing a message. It doesn't explicitly contrast with siblings like get_msg or delete_essence_msg, but the meaning is reasonably unambiguous.

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

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

No guidance is given about when to use this tool versus alternatives, nor any prerequisites or restrictions such as whether only own messages can be recalled or whether time limits apply. The agent gets no context for choosing or invoking this tool safely.

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 only states the verb 'Get' without revealing any side effects, permissions, or nature of the returned data. It is not misleading but is essentially empty of behavioral information.

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

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

The description is extremely brief, but this is under-specification rather than appropriate conciseness. It provides no useful structure or front-loaded context, making it unhelpful despite its brevity.

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 must explain what the tool returns and any relevant context. 'Get cookies' does not describe the return format, scope, or any dependencies, leaving the agent without enough information to use 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 already documents the 'domain' parameter as 'Domain' with 100% coverage. The description 'Get cookies' adds no further meaning to the parameter, so it does not enrich the schema. Baseline 3 applies because schema coverage is high.

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 'Get cookies' is a tautology of the tool name, providing no additional specificity about what cookies, from which context, or how it differs from siblings like get_credentials or get_csrf_token. It merely restates the name without distinguishing purpose.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites, scenarios, or exclusions. The description gives zero context about selection conditions, leaving the agent to guess.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure, and it provides none. It does not state whether the call is read-only, what data is returned, whether it triggers any side effects, or any security 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?

Two words is under-specification rather than conciseness. The sentence does not earn its place because it repeats the name and communicates no decision-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?

The tool is simple, but the meaning of 'credentials' is left fully ambiguous in a sibling space dense with credential-related tools. Without an output schema or annotations, the description alone cannot tell the agent what comes back, so it is not complete enough for correct selection and invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description is not required to duplicate the schema but adds no clarification about how 'domain' filters credentials or what format is expected.

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

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

The description 'Get credentials' is a tautology that merely restates the tool name. It does not say what kind of credentials are returned, from which service, or how this differs from credential-adjacent siblings like get_cookies, get_csrf_token, and get_login_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?

There is no guidance on when to call this tool versus alternative auth/credential tools in the sibling list. With several siblings that plausibly return credential-like data, the agent has nothing to select on.

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 only says 'Get CSRF token,' which implies a safe read but doesn't state whether a session is required, whether the token is generated fresh, or whether there are side effects. For an auth-related tool this is a meaningful gap.

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

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

The text is extremely short and front-loaded, but the single sentence merely restates the tool name and adds no information. It is not verbose, but it is under-specified rather than productively concise.

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

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

With no annotations and no output schema, the description is the only signal an agent has, and it doesn't explain the token's role, return format, or relationship to the many auth-related sibling tools. The zero-parameter schema covers input ambiguity, but the missing context prevents a complete mental model.

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 declares zero parameters, and with 100% schema description coverage there is nothing for the description to add. The no-parameter baseline of 4 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 'Get CSRF token' names a specific resource with a clear retrieval verb, so an agent can infer what the tool returns. It doesn't add context to distinguish it from auth-related siblings like get_cookies or get_credentials, but the core purpose is unambiguous.

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

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

The description gives no guidance on when to call this tool instead of alternatives like get_cookies or get_credentials, and no context about whether it is a prerequisite for other calls. An agent has to infer its purpose entirely from the tool name.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but the description does not state whether it is non-destructive, whether it returns a list or paginated results, or any ordering, filtering, or permission requirements. For a read operation this is less critical than for mutations, but still a noticeable gap.

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

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

The description is a single concise sentence with no redundant words sense. It is front-loaded and easy to parse. However, it is so terse that it sacrifices useful contextual information, though the conciseness itself is good.

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

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

The tool is simple with one required parameter, but the description does not mention what the tool returns, whether pagination or limits apply, or how this relates to setting/deleting essence messages. With no output schema and no annotations, more context is needed for an agent to confidently call this tool in the right situation.

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 fully describes the only parameter, group_id, as 'Group ID', so schema coverage is 100%. The description adds no additional meaning about the parameter, so the 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 specifies a clear verb ('Get') and a specific resource ('group essence message list'), which distinguishes it from set/delete essence tools. However, it doesn't explicitly contrast it with get_group_msg_history or read_group_messages, so the differentiation is not as sharp as it could be.

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

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

No guidance is provided about when to use this tool versus alternatives like get_group_msg_history or read_group_messages. The description implies a simple retrieval use case, but it doesn't state exclusions, prerequisites, or which sibling tools are preferable in other scenarios.

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

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

No annotations are provided, so the description should disclose behavioral aspects such as whether this is a read-only operation)Skip, any rate limits, or potential errors. The description simply states 'Get forward message' and does not elaborate on what happens if the message_id is invalid, whether it returns the full message content, or any authentication requirements. For a read operation, this is a moderate gap.

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

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

The description is a single, concise sentence that states the purpose without any wasted words. It is appropriately short for a simple retrieval tool, and the structure is clear.

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

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

The tool has one parameter, no output schema, and no annotations(migrations). The description is minimal but sufficient for a simple getter, yet it lacks details such as what the return value looks like, how errors are handled, or when to use it over similar tools. Given the complexity is low, the description is barely adequate but 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 description coverage is 100%, with each parameter described. The description 'Get forward message' does not add meaning beyond the schema, but the schema already explains message_id as 'Forward message ID (pass as a string to preserve precision)'. Since coverage is high, the baseline is 3, and the description adds no additional value to the parameters.

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

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

The description 'Get forward message' clearly identifies the action (get) and the resource (forward message). It distinguishes from siblings like 'get_msg' (which likely gets a general message) by specifying 'forward', making the purpose reasonably clear. However, it does not explicitly contrast with 'get_msg' to disambiguate, but the verb+resource is specific enough for a 4.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for retrieving forward messages specifically, nor does it reference siblings like 'get_msg' or 'get_group_msg_history'. With a large sibling list including several message retrieval tools, an agent could benefit from explicit routing, but none is 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 provided, the description carries the full burden of behavioral disclosure, and 'Get friend list' reveals nothing: no return format, no authentication requirements, no pagination or limits, not even a confirmation that it returns the calling user's own friends.

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 words is brief, but this is under-specification rather than efficient conciseness. No information is conveyed beyond the tool's own name, so the description cannot be said to earn 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?

While the zero-parameter input makes the call signature trivial, there is no output schema and no annotations, so the description should at least indicate what the tool returns (friend IDs, nicknames, pagination). It does not, leaving the agent to guess the response shape.

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

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

The tool has zero parameters and schema coverage is trivially 100%, so there is nothing for the description to add about parameters. The 0-parameter baseline of 4 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 'Get friend list' restates the tool name almost verbatim, making it essentially a tautology. It names a verb and resource but adds no detail that distinguishes it from siblings like get_group_list or get_stranger_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?

No usage guidance is provided whatsoever. There is no statement of when to use this tool, no exclusions, and no mention of alternatives such as get_stranger_info or get_friend_msg_history, despite several closely related sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Get', implying a read operation, but does not disclose ordering, pagination, whether it returns only messages from the specified user, or any rate limits. It also doesn't state what the response contains. For a read tool without annotations, this is a significant gap.

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

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

The description is a single short sentence with no fluff, which is appropriately concise for the tool's simplicity. However, it could have incorporated useful context (like pagination hints) without becoming verbose. It is front-loaded with the core action, but the brevity leaves some expected context out.

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 lack of output schema, annotations, and the existence of closely related sibling tools, the description is incomplete. It does not explain the return format, how to paginate (e.g., using message_seq), or how this relates to get_group_msg_history. An agent would have to guess at expected behavior, which is inadequate 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 coverage is 100% for all three parameters (count, user_id, message_seq), so the schema already provides definitions. The description adds no additional meaning beyond the schema. Baseline 3 is appropriate because the schema handles the parameter documentation, and the description does not contradict or enrich it.

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 'Get friend message history' uses a clear verb+resource and distinguishes from group-focused siblings like get_group_msg_history and read_group_messages by explicitly stating 'friend'. It is not a tautology and the purpose is evident, though it could be more specific about scope (e.g., private one-on-one messages) but it's sufficient.

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 like get_group_msg_history or read_group_messages. It does not mention any preconditions, differences in message scope, or when to prefer one over the other. An agent has no clues to select this tool over similar ones beyond the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool gets a list, with no mention of pagination, ordering, return format, or whether it requires special permissions. For a read operation, this is a notable gap, though the verb 'get' does imply a non-mutating action.

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

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

The description is a single short sentence with no waste, but it is under-specified. It is concise but does not earn its place by adding value beyond the tool name; it essentially restates the name.

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 tool, the description is minimal but lacks any context about the returned data, pagination, or relationship to sibling announcement-related tools. With no output schema and no annotations, an agent has little to go on beyond the parameter name.

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

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

Schema description coverage is 100%, so the schema already documents the single group_id parameter. The description adds no additional meaning beyond what the schema provides, 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 'Get group announcement list' states a specific verb and resource, so an agent can tell it fetches announcements for a group. However, it does not distinguish it from sibling tools like get_group_info or get_group_member_list, and the name is nearly identical to the description, adding little beyond the tool name.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, so an agent must infer usage solely from the name and the group_id parameter.

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, but it only states the basic read operation. It does not explain what 'remaining' means, whether this quota is per-group, time-based, or affected by other operations.

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, succinct sentence with no wasted words, and the core action is front-loaded. However, it is so minimal that it sacrifices useful context for brevity.

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 lack of annotations and output schema, the description should clarify what the return value represents and what 'remaining @all count' means in practice. The current description is likely understandable to a domain expert but leaves an agent uncertain about semantics beyond the group_id 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 coverage is 100% and the group_id parameter is described as 'Group ID', so the schema sufficiently documents the single parameter. The description adds no additional semantic detail, but the baseline of 3 applies because the schema is complete.

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 a precise resource ('remaining @all count for group'), which clearly conveys the tool's purpose. It is visually and semantically distinct from sibling tools like get_group_info or get_group_honor_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?

No guidance is provided about when to use this tool, what preconditions exist, or how it differs from alternatives. The agent must infer usage entirely from the tool name and description.

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

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

No annotations are provided, so the description carries the full burden. It states the operation (get file list) but doesn't disclose whether it's read-only, whether folder_id is required or optional, what happens if folder_id is omitted, or any pagination/recursion behavior. For a listing tool, this is a notable gap.

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

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

The description is a single concise sentence that front-loads the action and resource. It earns its place with no wasted words, though it could add a bit more context without becoming verbose.

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

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

With no annotations, no output schema, and a terse description, the tool lacks critical context. An agent doesn't know whether folder_id is optional, what the return format is, or how this differs from get_group_root_files. For a file-listing tool, this is incomplete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds the context that the tool lists files in a folder, but it doesn't clarify the relationship between group_id and folder_id (e.g., whether folder_id is optional and defaults to root). Baseline 3 is appropriate since 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?

The description 'Get file list in specified group folder' clearly states the action (get file list) and the resource (specified group folder). It distinguishes itself from siblings like get_group_root_files (root files) and get_group_file_url (file URL), 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 description implies usage for listing files in a group folder, but it doesn't explicitly state when to use this tool versus alternatives like get_group_root_files or get_group_file_system_info. No exclusions or alternative routing are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states the operation but does not disclose any side effects, output format, or access requirements. For a retrieval tool, it does not clarify whether this returns metadata, hierarchy, or storage stats. Significant gap given zero annotation support.

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

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

One short sentence, no fluff. It is concise and to the point. The structure is acceptable for a simple tool.

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

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

Only one required parameter and a clear operation, but no output schema and no behavioral details. The description is sufficient for basic invocation, but given the tool's purpose, it lacks explanation of what 'file system information' includes, which could lead to ambiguity. More detail on return structure or usage context would improve completeness.

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% for the single parameter, group_id, so the description does not need to explain it. The description adds no extra meaning beyond what the schema provides, so 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 ('Get group file system information'), and the sibling list includes similar tools like get_group_root_files and get_group_files_by_folder. The description is clear about what it does but does not explicitly differentiate from these siblings, so it's slightly above average.

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?

Implied usage: an agent would use this when they need group file system information. However, there is no explicit guidance on when to use this tool versus alternatives like get_group_root_files or get_group_files_by_folder, nor any exclusion criteria. Minimal guidance is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the operation and does not mention whether the URL is temporary, whether it is a direct download link, or whether any authentication or side effects are involved. This is a minimal disclosure with no added behavioral context.

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

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

The description is extremely concise, front-loaded with the verb and resource, and contains no filler. However, the brevity comes at the cost of omitting useful context such as URL expiry or usage caveats.

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

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

For a simple getter with a fully documented schema, this is minimally adequate: the purpose is clear and the return (a download URL) is implied. But there is no mention of the URL's nature or expiration, no output schema, and no annotations to fill the gaps, 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 description coverage is 100%, so every parameter is already documented in the input schema, including required flags. The description adds no parameter-level meaning beyond the schema, so the baseline score 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 clear verb ('Get') and resource ('group file download URL'), and the word 'download' clarifies that this returns a link rather than file content. It does not explicitly distinguish this from sibling file tools like get_group_files_by_folder or upload_group_file, but the resource is specific enough to be identifiable.

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

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

The description gives no guidance on when to use this tool versus alternatives, and does not mention prerequisites such as group membership or file access. It is left entirely to the agent to infer usage from the tool name and 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 of behavioral disclosure. It uses the verb 'Get', which implies a read, but it does not state whether the operation is read-only, requires special permissions, has no side effects, or how results are shaped. The description is too thin to satisfy the transparency burden.

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

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

The description is short, but it is under-specified rather than properly concise: it simply restates the tool name in natural language. The single sentence does not earn its place because it contributes no useful information beyond the name.

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 parameter schema is complete enough to invoke the tool correctly with group_id, and optional type values are listed. However, there is no output schema, no behavioral context, and no explanation of what 'honor information' actually returns, so the description is only minimally sufficient.

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

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

The schema description coverage is 100%, with both group_id and type already documented in the input schema. The description adds no parameter-level meaning, but this is acceptable because the schema already defines the type values and the required group_id.

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 'Get group honor information' is essentially a word-for-word expansion of the tool name get_group_honor_info, so it adds no new information beyond restating the identifier. It identifies a resource but does not specify what 'honor information' includes or how it differs from other group-related 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?

There is no guidance about when to use this tool versus alternative tools such as get_group_info, get_group_info_ex, or get_group_member_list. The chosen behavior must be inferred entirely from the tool name and parameter schema, which is insufficient for robust agent 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Get' implies a read-only action, but there is no mention of permission requirements, return behavior, side effects, or data scope beyond the resource name.

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

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

The description is a single short phrase with no filler, redundant wording, or unnecessary examples. It front-loads the operation and resource immediately, and every word contributes to the stated purpose.

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

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

With no annotations and no output schema, the description does not tell the agent what response to expect or whether special access is needed. Given the simple one-parameter schema, this is minimally usable, but it lacks enough behavioral context to be considered 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 only parameter is fully documented in the schema ('group_id' described as 'Group ID'), so schema description coverage is 100%. The description adds no additional parameter meaning beyond the schema, which puts it at the baseline of 3.

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 clear verb and resource phrase, 'Get group ignored join requests', which distinguishes it at the wording level from many sibling tools. It does not explicitly contrast it with related tools like get_group_system_msg or set_group_add_request, so it is clear but not fully differentiated.

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

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

The description provides no guidance on when to invoke this tool versus the sibling request-related tools. It does not mention prerequisites, alternatives, or excluded scenarios, leaving the agent to infer when 'ignored join requests' is the right concept.

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

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

With no annotations, the description carries the disclosure burden, but it only says 'Get', implying a read without confirming non-mutation, error behavior, permissions, or what 'detailed information' contains. This is thin for a description that must stand 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 description is a single front-loaded sentence with no filler, making it quick to parse. Its brevity is a strength, although it sacrifices useful 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?

The tool is simple, but the description does not explain the return contents or distinguish it from get_group_info_ex. With no output schema and no usage context, the description is not complete enough for reliable selection.

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, group_id, is documented as 'Group ID'. The description adds no additional parameter meaning, so the high schema coverage keeps this at baseline 3.

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 verb and a resource ('Get group detailed information'), but 'detailed information' is vague and mostly restates the tool name. It does not specify what fields are returned, and the sibling get_group_info_ex makes the boundary ambiguous.

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 call this tool instead of get_group_info_ex, get_group_list, or other group-info siblings. No context, prerequisites, or exclusions are provided, so an agent must infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Get group detailed information (extended)' and does not mention any side effects, permissions, rate limits, or what 'extended' entails. For a read operation this is less critical, but the lack of any detail about the response or special behavior leaves the agent guessing.

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

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

The description is a single short sentence with no wasted words. It is front-loaded with the verb and resource. However, it is so terse that it misses the opportunity to clarify 'extended' or differentiate from get_group_info, so it earns a 4 rather than a 5.

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

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

Given the tool has no output schema, no annotations, and a sibling named get_group_info that likely serves the basic version, the description is incomplete. An agent cannot know what 'extended' means, what fields are returned, or when to prefer this over get_group_info. The single parameter is documented, but the overall context is under-specified.

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 only parameter group_id is described as 'Group ID'. The description adds no extra meaning beyond the schema, so the baseline of 3 applies. It does not clarify the format, range, or how to obtain the group_id, but the schema is sufficient for basic invocation.

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 'Get group detailed information (extended)' states a clear verb and resource, but it is vague about what 'extended' means and how it differs from the sibling get_group_info. It does not specify what fields or details are included, so an agent cannot tell exactly what it will get beyond a general sense of 'more 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?

No guidance is given on when to use this tool versus get_group_info or other group-related tools. The sibling list includes get_group_info, which is likely the basic version, but the description does not explicitly state the relationship or selection criteria. An agent must infer usage from the name and the word 'extended'.

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 clearly indicates a read-only operation ('Get list') but does not mention pagination, ordering, field details, authentication requirements, or rate limits. For a simple list tool, this is minimal but not completely absent; however, the lack of any extra behavioral context makes it a 2.

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

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

The description is a single, concise sentence: 'Get list of all joined groups.' Every word is necessary and directly communicates the tool's function. It is front-loaded with the core action and resource, with no filler or redundant phrasing.

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 low complexity (no parameters, no output schema), the description provides the essential purpose. However, without an output schema, it doesn't describe what the returned list contains (e.g., group IDs, names, objects), which an agent might need to know to use the result. Since there are no annotations either, the description is adequate but not fully complete for a tool that returns a list.

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 coverage is 100% (trivially). Per the rubric, a tool with no parameters receives a baseline of 4. The description adds no parameter information because there are none to describe, so it fully meets the requirement without needing to compensate for missing 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 states a clear verb-resource combination: 'Get list of all joined groups.' It implies a read operation returning a collection of groups. It is distinct from siblings like get_group_info (which targets a single group) or get_group_member_list (which lists members of a specific group), so the purpose is unambiguous even though it doesn't explicitly differentiate.

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 doesn't state that it should be used for enumerating all groups, nor does it mention that get_group_info or get_group_info_ex are for individual group details. The usage context is implied by the name and description, but there is no explicit direction, so the score is low.

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 only says 'get detailed info' and does not disclose what fields are returned, whether the target must be in the group, whether it can fail for certain user IDs, or any rate limits. For a read operation, this is a notable gap.

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

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

The description is a single concise sentence that is front-loaded with the action and resource. It earns its place, though it could add a bit more context without becoming verbose.

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 is thin for a tool that returns 'detailed info'. An agent would not know what fields to expect, whether the member must be in the group, or how errors are signaled. Given the sibling set includes similar getters, more context is needed.

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 (user_id as 'User QQ number' and group_id as 'Group ID'). The description adds no additional meaning beyond what the schema provides, so 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 'Get specified group member detailed info' clearly states the verb (get) and resource (group member detailed info), and the parameters group_id and user_id make the target specific. It is distinguishable from siblings like get_group_info and get_group_member_list, 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 description implies usage: call this when you need detailed info about one specific group member, identified by group_id and user_id. It does not explicitly state when to use alternatives like get_group_member_list (for all members) or get_stranger_info (for non-group context), but the context is reasonably 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?

There are no annotations, and the description says nothing beyond the operation. It does not disclose pagination, rate limits, return structure, or any side effects. For a tool with no annotation support, this is a complete absence of behavioral disclosure.

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

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

The description is short, but this is under-specification rather than conciseness. A single phrase provides no structure or prioritization of key information, failing to earn its place beyond a label.

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 one parameter and no output schema, the description should clarify what is returned (e.g., list of member IDs vs. objects) and any limits. It does neither, leaving the tool's purpose ambiguous and unusable 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% and the only parameter, group_id, is documented as 'Group ID' in the schema. The description adds nothing extra, but the baseline of 3 is appropriate since the schema already defines the parameter adequately.

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 'Get group member list' essentially restates the tool name without adding specificity or distinguishing it from siblings like get_group_info or get_group_member_info. It names a verb and resource but offers no detail on scope or uniqueness, so it barely rises above a tautology.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any mention of prerequisites or typical call context. An agent has no clue which of the many group-related tools to pick.

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 reveals that the result contains IDs and OneBot fields, but it says nothing about ordering, default count, behavior when message_seq is omitted, read-only safety, errors, or rate limits. This is too thin for an agent to predict side effects or response behavior.

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

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

The description is a single sentence with no wasted words ❤ and front-loads the action. The phrase 'structured OneBot fields' is slightly vague, but it does not bloat the description.

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

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

With no output schema Gent and no annotations, the description alone must provide enough context. It lacks details about the return format, default behavior, existing alternative tools, and pagination mechanics. Given the large sibling set and the need to decide between similar message-history tools, this is incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description's mention of 'pagination or follow-up actions' hints at the relationship between count/message_seq and the returned IDs, but it doesn't add concrete semantics beyond the schema, so the 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 verb 'get' and resource 'group message history', and adds meaningful detail that it returns IDs and structured OneBot fields for pagination or follow-up actions. It doesn't explicitly distinguish itself from the sibling 'read_group_messages', but the core purpose is immediately 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?

There is no guidance about when to use this tool versus alternatives like 'read_group_messages' or 'get_friend_msg_history'. The phrase 'for pagination or follow-up actions' implies a use case, but it doesn't state exclusions or comparison conditions, leaving selection ambiguous among many 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?

No annotations exist, so the description carries the full behavioral burden. 'Get' implies a read-only action, but the description discloses no side-effect safety, auth/permissions, list contents, pagination, or whether the root list includes subfolders. Behavioral information beyond the superficial verb is absent.

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

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

The description is a single, short, front-loaded sentence with zero filler. Every word contributes directly to the tool's purpose, making it appropriately concise.

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

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

For a one-parameter read-only list tool, this description is mostly sufficient, but the lack of an output schema and annotations leaves the agent guessing about the returned list's exact shape. It also does not disambiguate from sibling file tools, which is relevant in the broader tool set.

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 the only parameter group_id with 100% coverage. The description itself adds no meaning, so the baseline score of 3 applies because the schema carries the semantic 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 clearly states a specific verb and resource: get the file list at the group's root directory. The 'root' qualifier sets it apart contextually from sibling tools like get_group_files_by_folder, though it does not explicitly name a sibling. The meaning is unambiguous.

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

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

There is no guidance on when to select this tool over alternatives such as get_group_files_by_folder or get_group_file_system_info. The 'root directory' wording provides only an implicit hint; no exclusions, prerequisites, or alternative tool names are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without revealing what a 'system message' is, whether the operation is read-only, what the response format looks like, or any side effects. The description adds minimal behavioral context beyond the tool name.

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

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

The description is a single concise sentence with no wasted words. It is front-loaded with the verb and resource, but it is so brief that it sacrifices clarity and context.

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

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

Given the tool has no output schema, no annotations, and a vague description, the definition is incomplete. An agent cannot tell what 'system messages' are, what the return value looks like, or how this tool differs from similar group message tools. More context is needed for correct invocation and interpretation.

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% for the single parameter group_id, so the schema already documents the parameter. The description does not add any extra meaning about the parameter, such as format, constraints, or how it is used. Baseline 3 is appropriate since the schema covers the parameter fully.

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 'Get group system messages' states a clear verb and resource, but it is vague about what 'system messages' means and how it differs from siblings like get_group_msg_history or read_group_messages. It is not a tautology, but it lacks specificity to distinguish it from other group-related message tools.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_group_msg_history or read_group_messages. The description does not mention any context, exclusions, or alternative tools, leaving the agent to guess based on 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 of behavioral disclosure. It only states 'get image information' without explaining what is returned, whether the file must exist, or if there are any side effects. For a simple read tool this is less severe, but the lack of any detail about the return value or error behavior is a notable gap.

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

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

The description is extremely concise at one sentence, but it is under-specified rather than efficiently informative. It front-loads the verb but omits any substantiating detail. While brevity is positive, the sentence does not earn its place because it adds little beyond the tool name.

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

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

With no annotations, no output schema, and only one parameter, the description is the only source of context. It fails to clarify what 'image information' includes, what the return format is, or how it relates to sibling tools like 'ocr_image'. An agent cannot confidently predict the tool's behavior or output from this description.

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 describes the single parameter 'file' as 'Image file path', which is clear. Schema description coverage is 100%, so the description adds no extra meaning about the parameter. It does not specify expected format (e.g., absolute path vs relative) or constraints, but the schema already provides the essential semantic.

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 'Get image information' uses a specific verb and resource, but 'information' is vague – it does not specify whether this means metadata (dimensions, format, size) or something else. It does not distinguish itself from the sibling 'ocr_image', which also processes an image file, so an agent could confuse the two.

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

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

No guidance is provided on when to use this tool versus alternatives like 'ocr_image' or other getters. There is no mention of use cases, prerequisites, or when not to use it. An agent is left to infer that this tool is for basic image metadata, but the description does not say so.

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 merely says 'Get' and does not disclose behavior such as whether the tool requires an active login, what data is returned, or whether it is strictly read-only. The agent must infer safety and scope from a single verb.

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

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

The description is a single short sentence with no filler. It is appropriately concise for a zero-parameter tool and front-loads the essential operation and target resource.

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

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

For a parameterless getter this is minimally sufficient, but there is no output schema and no behavioral or selection context. The description does not clarify what 'login account information' includes or how it differs from credentials or cookies, leaving a notable gap for an agent trying to choose and use the tool confidently.

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 there is no parameter semantics to document. The description adds no irrelevant detail, and the baseline for a parameterless tool is appropriately high.

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

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

States a clear verb and resource: 'Get login account information.' The intent is understandable, but it does not specify exactly what 'login account information' includes or distinguish it from sibling tools like get_credentials, get_cookies, or get_csrf_token.

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

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

No guidance on when to use this tool compared to alternatives. Given siblings such as get_credentials, get_cookies, and get_status, the description does not explain which one is appropriate for a given login or credential need, leaving selection ambiguous.

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 states only 'Get message details' — no mention of read-only semantics (though implied), error behavior for nonexistent IDs, required permissions, or the shape of the response. With zero annotation coverage, this is a significant gap.

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

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

The description is extremely short (three words), but this reflects under-specification rather than efficient conciseness. There is no substantive content that earns its place; it is essentially a restatement of the tool name without added value.

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

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

The tool is simple (one parameter) and has no output schema, so the description should at least clarify what details are returned. It does not. While low complexity lowers the bar slightly, the total absence of return-value or behavior information makes it incomplete for reliable invocation.

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

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

Schema description coverage is 100% — the single parameter message_id is already documented as 'Message ID' in the schema. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 applies; nothing is missing, but nothing is added either.

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

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

The description states a specific verb ('get') and a resource ('message details'), which conveys the basic function. However, it is vague regarding which message scope it covers — with siblings like get_group_msg_history, get_friend_msg_history, and get_forward_msg present, the description does not distinguish what kind of message this retrieves, so an agent cannot reliably differentiate it from alternatives.

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

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

No guidance is given on when to use this tool versus its many message-related siblings (get_group_msg_history, get_friend_msg_history, get_forward_msg, read_group_messages). There are no when-to-use, when-not-to-use, or alternative-routing instructions at all, leaving the agent to guess the appropriate 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 provided, the description carries the full burden of behavioral disclosure. It conveys that the tool retrieves a list, but does not mention whether it requires authentication, what the response format is, or any side effects. The single line is insufficient for a tool that could have nuanced behavior.

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

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

The description is a single, front-loaded sentence with no extraneous content. It states the purpose immediately and avoids any wasted words, making it appropriately concise for a zero-parameter tool.

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

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

For a tool with no parameters and no output schema, the description is minimal but adequate for basic understanding. However, it lacks details about the return value or any edge cases, and given the ambiguity of 'online client', it could be more complete to ensure 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 tool has zero parameters, so the schema fully covers parameter semantics. The description adds no parameter-specific information, but none is needed. Baseline 4 applies for zero-parameter tools.

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 'Get online client list' clearly states a specific verb and resource, and is distinct from sibling tools like get_group_list or get_friend_list. However, it does not clarify what constitutes an 'online client', leaving some ambiguity about the exact scope.

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

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

There is no guidance on when to use this tool versus alternatives. The description simply states the action without any context on prerequisites, exclusions, or alternative tools, leaving the agent to infer usage from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and resource without revealing any side effects, required permissions, or return characteristics. For a read-like operation, it doesn't clarify whether the file path must be local or remote, or whether the operation is safe and non-destructive.

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

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

The description is a single concise sentence, front-loaded with the action and resource. It has no wasted words. However, it is so terse that it sacrifices usefulness for brevity, which prevents a higher 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?

Given the simplicity of the tool, the description is insufficiently complete. There is no output schema, and the description doesn't indicate what information will be returned (e.g., duration, size, format). It also doesn't clarify the purpose of 'out_format' or provide any examples. An agent would need additional context to use 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?

The input schema already provides descriptions for both parameters ('Voice file path' and 'Output format'), so schema coverage is 100%. The description adds no extra meaning beyond what the schema states. The term 'Output format' is vague and not clarified in the description, but since the schema covers it, 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 states the verb 'Get' and the resource 'voice record information', which clearly indicates the tool retrieves data about a voice record. It is distinct from siblings like can_send_record (which checks capability) and get_image (which retrieves images), so the purpose is reasonably clear, though it doesn't specify what 'information' includes.

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. It doesn't mention prerequisites, whether it should be used before sending a voice record, or how it relates to other retrieval tools like get_msg or get_group_msg_history. The description leaves the agent to infer its use case.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Get running status' without mentioning side effects, return format, or whether it's a read-only operation. The name implies read-only but this is not stated.

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

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

The description is a single short phrase, but it is under-specified rather than concise. It lacks any structural elements that would help an agent parse key information. The brevity is not an asset because it omits essential context.

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

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

For a tool with no parameters and no output schema, the description is still incomplete. It doesn't explain what 'running status' means, what the return value contains, or how it differs from related tools like get_login_info. An agent would have to infer the purpose and output.

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 no parameters, so schema coverage is 100%. The description adds no parameter details, but none are needed. Per the baseline rule for zero parameters with high coverage, a 3 is appropriate, though the description contributes nothing 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 states a verb and resource ('Get running status'), so it's not a tautology, but it's vague about what entity's status and what fields are returned. It doesn't differentiate from siblings like get_login_info or get_version_info, which also fetch state, leaving ambiguity about the exact scope.

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

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

No guidance is given on when to use this tool versus the many siblings that retrieve similar state (e.g., get_online_client, get_version_info). There is no context about prerequisites or typical invocation scenarios.

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

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

No annotations exist, so the description carries the full burden for behavioral disclosure, but it only states a read-like intent without mentioning caching behavior, error conditions, or permissions. It doesn't even mention that the no_cache parameter affects 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 short enough, but it is under-specified rather than concise: all three words merely restate the name. It provides no front-loaded useful assertion that 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?

With no output schema, no annotations, and a vague description, the agent is missing information about what 'stranger information' actually includes and when the call is appropriate. The complete parameter schema is the only reason this is not a 1.

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%, with user_id explained as 'User QQ number' and no_cache as 'Whether to skip cache'. The tool description adds no parameter meaning 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 'Get stranger information' is essentially a restatement of the tool name get_stranger_info, adding no detail about what specific fields or entity are covered. It does not distinguish this from sibling tools like get_group_member_info or get_friend_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 guidance is provided about when to use this tool instead of sibling get-group/get-friend tools, and no exclusions or prerequisites are given. An agent must infer usage from the name alone.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states that it retrieves version information, but says nothing about whether it's read-only (likely), any side effects, authentication requirements, or the format/structure of the returned data. This is a significant gap.

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

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

The description is a single, concise sentence that is appropriately front-loaded. It avoids verbosity and wasteful filler. However, the brevity borders on under-specification given the low amount of contextual information, though for a simple tool it's acceptable.

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, no annotations, and a terse description, the tool is incomplete. An agent would not know what the response will contain (e.g., a version string, object with version numbers, platform details) or any behavioral nuances. For such a simple tool, a couple of sentences clarifying the return value would be sufficient, but they are 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 tool accepts zero parameters, and the schema confirms this with an empty properties object. Per the baseline rule for 0 params, no parameter documentation is needed, and the description doesn't need to add meaning beyond the schema. It correctly implies no input is required.

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

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

The description states a clear verb ('Get') and resource ('version information'), so it's not a tautology. However, it doesn't specify what kind of version information (system, application, API version) or differentiate from many sibling get_* tools like get_status or get_login_info. The purpose is clear but overly generic.

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 the many related get_* tools. There are no explicit conditions, exclusions, or alternatives mentioned. The intended use is implied by the name, but there's no context about the correct scenario (e.g., when you need the software version vs. runtime status).

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

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

There are no annotations, so the description carries the full behavioral burden, yet it only restates the tool's basic effect. It does not disclose idempotency, whether the message must already exist, any state change consequences, or how it interacts with other message-read operations. This is a minimal functional statement rather than transparent behavior disclosure.

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

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

The description is a single concise sentence with no filler or redundant detail, and the key action is placed at the front. It is appropriately brief for a one-parameter tool, though it does not add differentiation.

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 absence of annotations and output schema, the minimal description leaves important context unspecified, especially the distinction between marking a single message read and the sibling read_group_messages. The agent can infer the basic call but not the appropriate selection among related message-read tools.

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

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

The schema covers 100% of parameters, but the parameter description is terse ('Message ID'). The tool description adds no additional parameter semantics. Per the high schema coverage baseline, a 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 uses a clear verb and resource ('Mark message as read') that states the tool's core operation. However, it does not distinguish the singular mark_msg_as_read from the sibling read_group_messages, which may perform a similar bulk 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?

No usage context is given: the description does not say when to mark a single message as read, when to prefer read_group_messages, or any prerequisites. An agent must infer the intended use solely from the tool name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only 'OCR image recognition' and says nothing about whether the operation is read-only, what output format the OCR returns, whether network authentication is needed, or what happens on failure. This is a significant gap for an OCR tool.

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

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

The description is extremely terse ('OCR image recognition') to the point of under-specification. It is a fragment that mostly repeats the tool name, and it does not front-load any useful operational detail such as 'Extract text from an image provided as a path or base64.'

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 tool, the schema is sufficient to invoke the call, but the description never mentions the kind of result the OCR produces, whether it returns extracted text, a confidence score, or a structured result. Without an output schema and without a richer description, an agent cannot fully anticipate the tool outcome.

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% for the single 'image' parameter, which already specifies 'Image path or base64'. The description adds no extra semantic detail about parameter constraints, accepted formats, or how the image value should be structured, so the schema carries the load and the description provides no additional 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?

'OCR image recognition' states the tool's general purpose (performing OCR on an image), which is more specific than a pure tautology. However, it does not clearly express the action as 'extract text from an image' and offers no differentiation from the many sibling tools; it relies heavily on the tool name itself.

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 rather than alternatives such as get_image or send_msg. The description provides no context about prerequisites, preferred input sources, or conditions for use, leaving the agent to infer everything from the function name and schema.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does mention that the output is a 'minimal human-readable timeline', which indicates a simplified format, but it does not clarify default behavior for the optional 'count' parameter, what 'recent' means, or whether any message types are excluded. These omissions leave some ambiguity for the agent.

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

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

The description is two sentences long, with the primary purpose front-loaded and the usage guidance following. There is no redundancy or extraneous information; every sentence contributes to the agent's understanding.

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

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

The description covers the essential aspects: the tool's purpose, output format, and when to use it. While it lacks details on edge cases or error behavior, for a simple read-only tool this is adequate. The absence of an output schema is mitigated by the description's clear indication of a human-readable timeline.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description does not add additional parameter-specific semantics beyond what the schema provides, which aligns with the baseline score of 3 for full 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 verb 'Read' with resource 'recent group messages' and specifies the output format as 'minimal human-readable timeline'. It explicitly differentiates from the sibling get_group_msg_history by contrasting the use cases, making the tool's purpose unambiguous.

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

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

The description provides explicit guidance on when to use this tool ('Prefer this for understanding chat') and when to use the alternative ('use get_group_msg_history only when IDs, pagination, or raw segments are needed'). This is exemplary usage guidance that directly addresses tool 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?

Because there are no annotations, the description carries the full burden of disclosing behavior, but it only repeats the operation implied by the name. It does not explain whether forwarding requires prior message IDs, how the JSON should be structured, or what side effects or permissions are involved.

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

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

The description is compact and front-loaded, but it achieves brevity by omitting useful context entirely. It is under-specified rather than efficiently scoped, and the four words restate the tool name without adding substantive 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 forwarding operation with no annotations and no output schema, the agent still lacks critical information: what messages JSON should contain, whether previous message IDs are needed, limits on forwarded content, and what the response looks like. The schema covers parameter names only, not the domain semantics needed 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 already covers both parameters with 100% coverage, so the baseline is 3 even though the description adds no parameter detail. The description does not clarify the expected structure of the messages JSON string or the meaning of group_id 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 names a concrete action and object: 'send' a 'group forward message'. The word 'forward' provides some distinction from sibling tools like send_group_msg, but the description mostly restates the tool name and does not explain what makes a message 'forward' versus a normal group message.

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 send_group_msg, send_private_msg, or send_msg. No context, prerequisites, or exclusions are provided, so the agent must infer usage entirely 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates the action and gives no information about return values, message ID, auto_escape behavior, side effects beyond sending, or requirements such as group membership or permissions.

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

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

The description is three words with no filler and the core action is front-loaded. It is maximally concise, though the brevity borders on under-specification rather than being a fully helpful definition.

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

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

The description plus complete schema coverage is enough to make a basic call with the required group_id and message. However, with no annotations and no output schema, important context is missing: return value, side-effect profile, auto_escape semantics, and how this differs from send_group_forward_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 is 100%, so the baseline is 3 even though the description itself adds no parameter-level detail. The parameters group_id and message are already documented clearly in the schema, and the description does not introduce any additional 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 uses a specific verb ('Send') and a clear resource ('group message'), so the primary action is unambiguous. However, it does not differentiate from similar siblings like send_group_forward_msg or the generic send_msg, leaving the agent to infer the distinction from the tool 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?

No when-to-use guidance is provided. The description does not mention when to prefer this tool over send_private_msg, send_msg, or send_group_forward_msg, and no exclusions or alternative conditions are stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Send group announcement' and does not mention permissions, side effects, return data, CSRF/auth requirements, or failure behavior. This is effectively no behavioral information.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It front-loads nothing useful and provides no structured or scoped information.

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

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

The schema fully covers parameters and the tool is simple, but the description omits usage context, behavioral details, and any distinction from closely related sibling tools. An agent would still lack enough information to understand what invoking this tool involves.

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 descriptions cover 100% of the three parameters with basic meaning ('Announcement title', 'Announcement content', 'Group ID'). The description adds nothing 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 'Send group announcement' is essentially a restatement of the tool name 'send_group_notice'. It identifies a verb and resource, but adds no detail to distinguish it from siblings like send_group_msg or get_group_announcement_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 guidance is given about when to use this tool versus alternatives such as send_group_msg or get_group_announcement_list. There are no conditions, exclusions, or prerequisites stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Send like' with no mention of side effects, target semantics, limits, authentication, or expected result.

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

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

Two words are under-specified rather than concise. The description repeats the tool name without earning its place or conveying meaningful 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?

Even for a simple two-parameter tool, the description fails to explain what the like operation does, what it acts on, or what the agent should expect. Without output schema or annotations, an agent cannot confidently use the tool.

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

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

Schema description coverage is 100%, with user_id described as 'User QQ number' and times as 'Like count'. The description itself adds no further parameter semantics, so the baseline score 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 'Send like' simply restates the tool name without specifying the actual resource or action. It does not disambiguate from other send_* or get_* 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?

No guidance is given on when to use this tool versus alternatives like send_msg, send_group_msg, or send_private_msg. The description provides no usage context or 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?

Annotations are none, so the description carries the full burden. It doesn't disclose side effects, permissions, or whether the message is actually sent asynchronously. No info on rate limits or error conditions, which is significant for a message-sending 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?

Single concise sentence with no waste. It is short but not overly verbose.

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

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

Given the tool has 5 parameters and no annotations, the description is too brief. It doesn't explain the relationship between user_id/group_id and message_type, nor any behavior like auto_escape's effect. No guidance on choosing this over siblings.

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 describes all parameters. The description adds nothing about parameters. 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 the verb 'send' and resource 'message', but it is very generic and doesn't distinguish from siblings like send_group_msg and send_private_msg. However, the message_type parameter does clarify that it can be either group or private, which adds some specificity.

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

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

No guidance on when to use this generic tool versus the more specific send_group_msg and send_private_msg siblings. It doesn't mention any prerequisites, such as needing a user_id for private messages or group_id for group messages.

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, but it only restates the action. It does not disclose side effects, permission requirements, rate limits, or what happens after send, although 'Send' at least implies a mutating action.

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

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

A single short sentence with no filler, front-loading the core action. It is appropriately concise, though the brevity comes at the cost of useful context.

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

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

Despite 100% schema coverage, the absence of annotations, output schema, or usage guidance leaves the agent without context on when to choose this tool, how it behaves as a write operation, and how it differs from sibling send tools.

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

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

Schema description coverage is 100%, so the schema already documents the parameters. The description adds no additional semantic detail about user_id, message, or auto_escape, 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 uses a clear verb and resource ('Send private message'), so an agent knows the operation. However, it does not distinguish this from sibling tools like send_msg and send_group_msg, leaving the differentiation to the tool name.

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

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

There is no guidance on when to use this tool versus alternatives. No mention that this is for direct/private messages only and that group messages should go to send_group_msg or send_msg.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not indicate that this is a mutation, its side effects, permissions required, or the return value. The single sentence offers no behavioral information.

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

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

The description is extremely short, but the brevity harms usefulness rather than aiding it. It lacks a full sentence and provides no front-loaded key information, making it under-specified rather than concise.

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

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

Given no output schema, no annotations, and a single parameter, the description should at least clarify what 'essence message' means and what setting it does. It fails to provide any contextual information, making the tool impossible to use 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 schema already describes message_id as 'Message ID' with 100% coverage, so the description adds no parameter-specific meaning. Per the baseline for high schema coverage, a 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 'Set essence message' is vague and essentially restates the tool name. It doesn't explain what an 'essence message' is or what 'setting' it entails. It fails to distinguish from sibling tools like get_essence_msg_list or delete_essence_msg.

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

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

No guidance is provided about when to use this tool versus alternatives. There are no prerequisites, conditions, or exclusions mentioned, leaving the agent without any context for invocation.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. 'Handle friend request' reveals nothing about side effects, permissions required, reversibility, or whether it adds a friend or merely processes the request. This is essentially a tautology of the tool name.

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 very short, but brevity comes at the cost of usefulness. The words 'handle' and 'friend request' add little beyond the tool name, so the sentence does not earn 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?

Given the lack of annotations and output schema, the description is insufficient for an agent to know when and how to invoke the tool correctly. It does not explain what 'flag' represents, how 'approve' changes system state, or what happens after the 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%, so the parameters are already documented in the schema. The description adds no additional meaning beyond what the schema provides, which keeps this at baseline.

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

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

The description identifies the resource ('friend request') and implies handling, but the verb 'handle' is generic and does not specify the actual operation (approve, reject, modify). It distinguishes from sibling 'set_group_add_request' only by mentioning 'friend', but not from other friend-related tools.

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

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

No guidance is given on when to use this tool versus alternatives. Sibling tools like 'set_group_add_request' exist, but the description does not explain that this tool is for friend requests specifically, nor does it state any conditions or prerequisites.

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, yet 'Handle group join request' reveals nothing about side effects, required permissions, outcome of approval or rejection, or reversibility. An agent cannot anticipate what happens when calling this tool.

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

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

The description is a single short sentence, which is structurally concise, but it is under-specified and doesn't earn its place by clarifying behavior. It is too vague to be considered effective, resembling a placeholder rather than a useful one-liner.

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 four parameters, no annotations, and no output schema, this description is severely incomplete. An agent lacks sufficient information about prerequisites, effects, or return values to call it confidently.

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 explains flag, reason, approve, and sub_type. The description adds no parameter context, leaving the baseline of 3 appropriate for a tool whose schema fully documents its parameters.

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

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

The description names a resource (group join request) but uses the vague verb 'handle,' which doesn't specify whether the action is approving, rejecting, or otherwise managing the request. It is too generic to distinguish clearly from related tools like set_friend_add_request or get_group_system_msg without inspecting 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?

There is no guidance on when to use this tool versus alternatives. The schema implies approving/rejecting a request, but the description never states the trigger condition, such as 'when a group join request is pending' or 'instead of set_friend_add_request for group requests.'

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

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

No annotations are provided, so the description must disclose behavioral traits. The description only says 'Set group admin' without stating whether this operation is reversible via the 'enable' parameter, whether it requires elevated permissions, or what side effects occur (e.g., notifying users). Given it is a mutation tool, the lack of behavioral context is a significant gap.

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

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

The description is a single, short sentence with no fluff. It is concise and to the point. It could be improved by adding a mention of the 'enable' parameter, but for a simple tool, this is appropriately minimal.

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 moderate complexity (3 parameters, toggling behavior) and the absence of an output schema or annotations, the description is somewhat minimal. The schema covers parameter semantics well, but behavioral aspects like reversibility and permissions are absent. The description is adequate but would benefit from clarifying the toggling behavior.

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

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

The schema covers 100% of parameters, each with clear descriptions (e.g., 'group_id: Group ID', 'user_id: User QQ number', 'enable: Whether to set as admin'). The description does not need to add much, as the schema is sufficient. However, the description could mention that 'enable' toggles admin status, which it does not, but the schema already carries that meaning, so a high score is warranted.

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 'Set group admin' clearly identifies a specific verb and resource, and implies toggling the admin status of a user in a group. It distinguishes itself from sibling tools like set_group_kick or set_group_ban by naming the action (setting admin) rather than kicking or banning. However, it lacks explicit mention of the 'enable' parameter, which could add clarity that it both grants and revokes admin status.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not list any conditions, prerequisites (e.g., must be group owner), or situations where this tool should be preferred over similar group management tools. The agent must infer from the tool 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 of behavioral disclosure. It only says 'Mute group member' and does not explain what happens when duration is omitted, whether this is permanent, what permissions are needed, or how the mute can be lifted.

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 very short with no filler or redundant wording. However, it is so minimal that it functions more like a label than a structured explanation, so it earns a strong but not perfect conciseness 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 mutation tool with no annotations and no output schema, the one-line description is thin. An agent lacks guidance on default mute duration, behavioral side effects, and how this relates to similar group moderation tools, leaving important context 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 covers all three parameters with descriptions, giving a baseline of 3. The description adds little beyond the word 'mute' to clarify the effect of duration, so it does not meaningfully supplement 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 ('Mute') and target ('group member'), making the operation clear and distinct from siblings like set_group_kick or set_group_whole_ban. It does not explicitly name alternatives, but the action is unambiguous enough for an agent to infer the tool's purpose.

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

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

The description gives no guidance on when to use this tool versus set_group_kick, set_group_whole_ban, or other sibling tools. There is no mention of prerequisites, permissions, or scenarios where this tool is preferred.

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 only says 'Set group member card' – it doesn't mention side effects (e.g., overwriting existing card), required permissions, what happens when 'card' is omitted, or any error behavior. This is severely insufficient 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 description is extremely short (one sentence), which makes it concise, but it's under-specified. It lacks structure, such as separating core action from optional details or edge cases. The brevity is not an asset here because it omits essential context.

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

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

For a simple 3-parameter tool with no output schema, the description is incomplete. It doesn't mention that 'card' is optional, what happens if omitted, or the effect on the member's display. An agent would have to infer or experiment to understand the behavior.

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

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

Schema description coverage is 100%, so each parameter has a basic description ('Group card', 'User QQ number', 'Group ID'). The tool description adds no extra meaning beyond that, so it stays at the baseline of 3.

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 action ('Set') and a specific resource ('group member card'), which distinguishes it from sibling tools like set_group_name or set_group_special_title. However, it doesn't clarify what a 'group card' is (likely a member's display nickname), so it's not fully explicit.

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

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

There is no guidance on when to use this tool versus alternatives, no context about prerequisites, and no mention of when not to use it. With many sibling tools available, the agent gets no routing help.

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. 'Kick member from group' does not mention side effects, permissions, irreversibility, or the meaning of the optional reject_add_request parameter, so the agent is under-informed about a mutating operation.

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

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

The description is exceptionally concise: four words, no filler, and the core action is front-loaded. There is no wasted text.

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

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

For a very simple mutation with complete parameter documentation, the one-liner may be minimally sufficient. However, with no annotations, no output schema, and no explanation of the reject_add_request side effect, the context is thinner than ideal for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter semantics, and the optional reject_add_request behavior is only present in the schema, not enriched in the tool description.

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

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

The description uses a specific verb and resource: 'Kick member from group'. This clearly identifies the operation and differentiates it from related sibling tools like set_group_ban or set_group_leave, even 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?

There is no guidance on when to use this tool versus alternatives. The description only states the action; it does not explain, for example, that kicking removes a member permanently while set_group_ban mutes them temporarily.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only states a mutation ('leave/dismiss') without covering reversibility, permissions, side effects, or what happens to the group or member. This is a significant gap for a state-changing 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?

Five words, front-loaded with the action, and no filler or repetition. Every word carries meaning, making this an example of efficient writing.

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

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

With no annotations and no output schema, the description should clarify key operational details: what 'dismiss' means, whether is_dismiss is required for each behavior, and what the outcome is. The description is too sparse to be complete for an agent to correctly choose and invoke 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?

The schema covers both parameters with descriptions (group_id: 'Group ID', is_dismiss: 'Whether to dismiss group'), so the schema does the heavy lifting. The tool description adds little beyond mapping the top-level action to the is_dismiss flag, and does not clarify default behavior when is_dismiss is omitted.

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 ('leave/dismiss') and resource ('group'), distinguishing it from sibling actions like set_group_kick or set_group_ban. However, 'dismiss' is ambiguous—it does not clarify whether it means disbanding the group or removing oneself from it—so it is clear but not fully differentiated.

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

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

There is no guidance about when to use this tool versus alternatives, no mention of prerequisites, and no indication of the difference between 'leave' and 'dismiss'. The description leaves the agent to guess from the parameter names which action applies in a given 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 provided, the description carries the full burden of behavioral disclosure. It only says 'Set group name' and does not mention whether the operation requires special permissions, whether it is reversible, what happens if the group name is invalid, or what the response looks like. The mutation is implied but not elaborated.

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

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

The description is extremely short and front-loaded, which is efficient, but it is under-specified rather than concise. It earns its place as a minimal label but does not provide enough substance for an agent to use it confidently.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It does not explain return values, error conditions, permission requirements, or side effects. The two parameters are documented in the schema, but the behavioral context 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?

Schema description coverage is 100%, so the schema already documents both parameters (group_id and group_name). The description adds no extra meaning beyond the schema, but the baseline of 3 applies because the schema fully covers 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 'Set group name' states a clear verb and resource, so an agent can tell it performs a rename operation on a group. However, it does not distinguish it from sibling tools like set_group_card or set_group_special_title, which also modify group-related attributes. The name and description are nearly identical, adding little beyond the tool name itself.

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

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

No guidance is given about when to use this tool versus alternatives. There is no mention of prerequisites (e.g., admin permissions), no exclusions, and no reference to sibling tools. The description only restates the function name, leaving the agent to infer 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 full burden for behavioral disclosure. The description only states the action without any details on side effects (e.g., whether it overrides existing titles), permissions required, or reversibility. For a mutation tool, this is a significant gap.

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

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

The description is a single, efficient sentence with zero waste. It front-loads the action and resource. Could be slightly more descriptive, but it's concise.

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

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

Given the tool mutates stateate (sets a title), has 4 parameters but no output schemacripts, and no annotations, the description is incomplete. It lacks information about expected outcomes, necessary permissions (e.g., group admin), and how it relates to similar tools. An agent might need to open the schema for parameter details, but the behavior is opaque.

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 covers 100% of parameters with descriptions, so baseline is 3. The description adds no parameter-specific meaning beyond the schema, but the schema is sufficient. The description's purpose is not to explain parameters, so this is acceptable.

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 'Set' and resource 'group special title', making the purpose clear. It distinguishes from siblings like set_group_card (group card) and set_group_name, but doesn't explicitly name them. The title is redundant but the description is unambiguous.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance. However, given the sibling list, an agent can infer that this is for setting a special title for a specific user in a group, distinct from similar group operations. No alternatives are named, but the context is clear enough.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure, but it only states the action. It does not explain that this is a state-changing operation toggleable via the enable parameter, whether admin permissions are required, whether the effect is reversible, or what response is returned.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to conveying the core function, making it appropriately concise.

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

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

Even with full schema coverage, the description is incomplete for a mutation tool with no annotations and no output schema. It omits the enabling/unmuting behavior implied by the enable parameter, permission needs, side effects, and when to use this tool over the related set_group_ban 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?

The schema already covers both parameters (group_id and enable) at 100% coverage, so the baseline is 3. The description adds no further parameter context, but the schema descriptions are sufficient for basic usage.

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 ('Mute') with a clear resource and scope ('all members in group'). This distinguishes it from siblings like set_group_ban, which targets individual members, so an agent can immediately understand what the tool does.

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

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

No when-to-use guidance is provided. The description does not mention that this tool is for muting the entire group as opposed to an individual member, nor does it reference any alternative tool like set_group_ban or set_group_kick.

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 only says 'Set' with no information about side effects, permissions, whether omitted parameters preserve existing values, whether an empty call is a no-op, or what response to expect.

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

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

The description is short but not meaningfully concise because it repeats the tool name without providing any additional information. It does not earn its place: a one-line tautology is under-specification rather than efficient writing.

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

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

The schema fully describes the three optional parameters, but the description itself provides almost no surrounding context. An agent can infer basic intent from the name, but nothing explains the scope, mutation semantics, or behavior when no parameters are provided, so the description is not complete enough for a mutation tool with no annotations.

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 each parameter already has a clear description in the schema. The tool description adds no additional parameter meaning, but the baseline of 3 applies because the schema fully documents the parameters.

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

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

The description 'Set QQ profile' is essentially a verbatim restatement of the tool name and does not clarify that this is the current user's personal profile, what aspects it changes, or how it differs from profile-like sibling tools such as set_group_card or set_group_name. It names a resource and an action but adds no specificity beyond the name itself.

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

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

There is no guidance about when to use this tool versus alternatives. With many sibling tools that modify group-level profile fields, an agent gets no help deciding whether set_qq_profile is the right choice for a given request.

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, but it only states the action itself. It does not reveal side effects, overwrite behavior, file size limits, permission requirements, or what happens on success/failure. This is a meaningful transparency gap for a tool that mutates group state.

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

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

The description is extremely short and free of filler, which is structurally clean status quo, but it is also under-specified as a definition. It is more of a title than a descriptive sentence, so it does not quite earn the top conciseness marks for providing a complete, front-loaded explanation.

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 definition is incomplete for an upload operation with four parameters and no output schema. It does not explain how the optional folder_id affects behavior, what kind of file path is expected, or what the agent should expect as a result. Given the lack of annotations agonist, the sparse description leaves too much unstated.

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

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

The input schema has 100% description coverage for its four parameters, so the schema already explains file, name, group_id, and folder_id. The description adds no additional parameter context, but the schema covers the bare semantics, warranting 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 identifies the action ('Upload') and the resource ('group file'), making it easy to tell apart from sibling tools like delete_group_file or get_group_file_url. It lacks some useful scope detail, such as whether the file goes to the group root or a subfolder, but the core purpose is unambiguous.

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

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

There is no guidance about when to use this tool over alternatives, nor any exclusions or prerequisites. The agent must infer the usage solely from the tool name and the presence of sibling file tools. No mention is made of when upload_group_file is appropriate versus, for example, send_group_msg or get_group_root_files.

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