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. The only signal is 'Use with caution,' which vaguely hints at potential impact but does not disclose specific behaviors such as message quota consumption, irreversibility, or error handling. An agent cannot assess the full consequences of broadcasting to all followers from this description.

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 short sentences with the primary action and target front-loaded. Every word contributes: the action, the resource, the audience, and a caution. 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?

For a broadcast tool with no annotations and no output schema, the description is insufficiently complete. It fails to mention that broadcasting consumes message quota, that the action is irreversible, or that it requires followers to exist. The vague caution does not compensate for the lack of concrete risk and operational details an agent needs to call this tool safely.

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

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

Schema description coverage is 100%, so both parameters (altText and contents) are already documented in the schema. The description adds no parameter-specific details, only the general note that it is a 'rich layout,' which does not go beyond the schema. 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 clearly states the action ('Broadcast'), the resource ('a Flex Message (rich layout)'), and the precise target ('ALL followers of the LINE Official Account'). This distinguishes it from push (single user) and multicast (subset) tools. The parenthetical clarifies the message type, making the 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 scope is explicitly defined as ALL followers, which provides clear context for when to use this tool over push or multicast. However, it does not explicitly name alternatives or provide exclusion conditions, and the cautionary note is generic rather than a direct comparison. Still, the target scope is clear enough to imply usage.

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

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

With no annotations, the description carries the full burden. It discloses the target audience (all followers) and includes a generic warning ('Use with caution'), but it does not explain potential side effects, rate limits, or consequences of broadcasting to a large audience. The warning is vague and lacks specificity.

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, using two short sentences. It delivers the essential information (action and target) without unnecessary elaboration. Every word serves a purpose, and the 'Use with caution' warning adds important context without bloating the 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 simple tool with one parameter and no output schema, the description covers the core purpose and scope. It omits details about return values or error handling, but given the simplicity and the presumed API context, it is reasonably complete. The lack of explicit mention of response or failure modes is a minor gap.

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

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

The schema provides full coverage for the single parameter 'text' (type, min/max length, description), so the tool description adds no additional meaning. According to the guidelines, when schema coverage is high, the baseline score is 3. The description does not elaborate on any nuances or usage constraints beyond the schema.

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

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

The description clearly states the action (broadcast a text message) and the target (ALL followers), distinguishing it from multicast and push tools that target specific audiences. It also specifies the message type (text), differentiating it from other broadcast variants like flex or image.

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

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

The description implies the appropriate use case by emphasizing 'ALL followers' and warns with 'Use with caution.' However, it does not explicitly state when to prefer this over multicast or push, nor does it specify conditions where this tool should be avoided. The scope is clear but the guidance is implicit.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says 'Cancel the default rich menu' without explaining what cancellation entails—whether it removes the default assignment, deletes the menu, or affects users. No side effects, reversibility, or prerequisites are disclosed.

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. It is appropriately sized for a simple tool, though it lacks any supplementary 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?

The description is too terse to be complete. It does not explain the effect of canceling the default rich menu, such as whether it deletes the menu or just unsets it. Given the simplicity of the tool, a brief clarification of the action's scope would suffice.

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 description does not need to add parameter semantics. The baseline of 4 is appropriate since there is nothing to clarify or expand upon.

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

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

The description clearly states the action 'Cancel' and the resource 'default rich menu'. It distinguishes from sibling tools like set_default_rich_menu and delete_rich_menu by specifying the default setting, making the intent 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 provided on when to use this tool versus alternatives. The description does not mention that this is the inverse of set_default_rich_menu, nor does it clarify differences from delete_rich_menu. An agent is left to infer 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'create', which implies mutation, but does not mention any requirements, side effects, or return behavior. For a create operation, important details like whether an ID is returned or what happens on validation failure are omitted.

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 minimal and front-loaded with the action. Two short sentences with no filler or redundancy. For a simple single-parameter tool, this level of conciseness is appropriate.

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 (one parameter, no output schema), the description should still clarify what the tool returns (e.g., created rich menu ID) and any constraints. It does not mention success/failure behavior, making it incomplete for an agent to fully understand the tool's contract.

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% since the parameter 'richMenu' is described as 'Rich menu object as a JSON string'. The description adds 'Pass the rich menu object as a JSON string', which essentially repeats the schema. It provides no additional semantic detail beyond the schema, 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 clearly states the action 'Create a new rich menu' with a specific resource. It distinguishes from sibling tools like list_rich_menus, get_rich_menu, and delete_rich_menu by the verb 'create'.

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 doesn't mention prerequisites, conditions, or scenarios where a different rich menu operation would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Delete a rich menu by its ID' without mentioning that deletion is permanent, that the ID must exist, or any side effects (e.g., removing default status). For a destructive operation, 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, clear sentence with no wasted words. It is front-loaded with the action and resource, making it easy to parse. This is an example of appropriate conciseness.

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

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

For a simple delete operation with one parameter and no output schema, the description is largely sufficient. However, it omits important operational context such as whether deletion is irreversible or what happens if the ID is invalid. While not strictly necessary, mentioning permanence would improve completeness for an agent deciding to call this tool.

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

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

The input schema fully describes the single parameter 'richMenuId' as 'Rich menu ID' with 100% coverage. The description reinforces this by saying 'by its ID' but adds no additional semantic detail beyond what the schema provides. Baseline 3 is appropriate since the schema handles the burden.

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 'rich menu' with a clear method 'by its ID', distinguishing it from sibling tools like get_rich_menu or create_rich_menu. An agent can immediately understand the action and target.

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

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

The description clearly indicates the operation (deletion) but provides no explicit guidance on when to use it versus alternatives, nor any conditions or prerequisites such as obtaining the ID from list_rich_menus or warnings about irreversibility. It is clear enough for a straightforward delete, but lacks contextual routing.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It indicates a read operation ('Get information') and lists the returned fields, but it does not mention side effects (likely none), authentication requirements, rate limits, or error behavior. For a zero-parameter getter, this is acceptable but not richly detailed.

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

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

The description is a single, concise sentence that front-loads the action and resource, then specifies the key returned fields. Every word earns its place, 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?

For a tool with no parameters, no output schema, and no annotations, the description covers the essential purpose and the type of information returned. It does not specify the output format or any conditions, but given the simplicity of the operation, the definition is adequate for an agent to invoke it correctly.

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

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

The input schema is an empty object with 0 parameters, so schema coverage is 100% by default. The description correctly omits parameter details because there are none. It adds value by enumerating the fields returned, which is helpful for agents expecting a structured response.

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 the resource 'information about the LINE Official Account bot', and lists specific fields (name, ID, chat mode, mark-as-read mode). This is distinct from all sibling getters which target users, groups, rooms, rich menus, or analytics, so there is no confusion with 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?

While no explicit when-to-use or exclusions are stated, the purpose is self-evident and there is no overlapping sibling for bot info. The description implicitly signals that this is a read-only retrieval tool to be used when bot-level settings are needed, though it could mention that it does not require parameters 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, the description carries the behavioral burden. 'Get' clearly implies a read-only retrieval and the result is named as the ID, but the description doesn't disclose what happens when no default rich menu is set or describe the return shape. This is a small but real gap.

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

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

A single, front-loaded sentence with no filler. Every word contributes directly to the tool's purpose.

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

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

For a zero-parameter getter, this is nearly complete: the agent knows what to call and what result to expect. However, the absence of an output schema and the unstated no-default behavior keep it from being fully self-sufficient.

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

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

The tool has zero parameters and the schema description coverage is 100%, so there are no parameter semantics to document. The baseline of 4 applies because nothing more is needed.

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

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

The description uses a specific verb and resource: 'Get the ID of the default rich menu.' It clearly distinguishes this from sibling tools like set_default_rich_menu, cancel_default_rich_menu, and get_rich_menu by focusing on reading the current default.

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

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

The intended use is implied: call this when you need the default rich menu ID. However, it doesn't explicitly say when to prefer this over list_rich_menus, get_rich_menu, or set_default_rich_menu, so the guidance is left to inference rather than stated.

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

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

With no annotations, the description carries the full burden. It discloses the read-only nature implicitly, mentions pagination via a start token, and states the output is a list of user IDs. However, it does not mention any limits, rate limits, or how to obtain subsequent tokens, leaving some behavioral gaps.

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 sentences with no filler. The primary purpose is front-loaded, and the pagination detail is stated succinctly. Every word earns its place.

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

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

For a simple read-only paginated list with one optional parameter and no output schema, the description covers the essentials: what is returned, the scope, and pagination. Minor omissions like response format details are not critical given the simplicity. It is sufficiently complete for an agent to call it correctly.

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

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

The input schema already documents the single parameter 'start' with the description 'Pagination token from a previous response', which fully covers its meaning. The description only repeats that pagination is supported, adding no new information. With 100% schema coverage, baseline is 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 clearly states the verb (get), the resource (list of user IDs), and the specific scope (users who added the LINE Official Account as a friend). It distinguishes from siblings like get_number_of_followers (count) and get_friend_demographics (demographics) by the resource returned. No ambiguity or 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 on when to use this tool versus alternatives. It does not mention when not to use it or point to sibling tools like get_number_of_followers for counts. The context is implied but not explicit, leaving the agent to infer selection criteria.

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

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

There are no annotations, so the description carries the full burden. It implies a read-only operation (Get) but does not disclose response format, potential errors, or side effects. The mention of 'breakdowns' gives some indication of output structure, but it is not detailed.

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

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

The description is a single sentence with no redundant words. It is concise and well-structured, conveying the essential purpose without extraneous details.

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

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

The description is adequate for a tool with no parameters and no output schema. It identifies the resource (friends of the LINE Official Account) and the kind of data (demographics with breakdowns), which is sufficient for an agent to decide when to call it.

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

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

The tool has zero parameters, so the empty schema is fully covered. The baseline for 0 parameters is 4; the description adds no parameter information because none is needed. No ambiguity exists.

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 action ('Get') and resource ('demographic information about friends'), and specifies the breakdowns ('gender, age, area'). This distinguishes it from sibling tools that retrieve other friend-related data like follower IDs or counts.

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

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

The description does not explicitly state when to use this tool versus alternatives, but the tool name and description make its purpose obvious. It lacks explicit guidance on conditions or exclusions, but the straightforward nature of the read operation reduces ambiguity.

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

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

No annotations are provided, so the description carries the full burden. It discloses the membership requirement, which is a behavioral constraint. However, it does not describe what happens if the bot is not a member (e.g., error), nor the return format (an integer count). For a simple read operation, this is adequate but not rich. It adds the key prerequisite beyond what the schema provides.

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 concise sentences with no filler. The core purpose is front-loaded, and the prerequisite follows naturally. Every word earns its place; it is appropriately sized for a simple one-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?

Given the tool's simplicity, the description covers the essential aspects: what it returns (count), the resource (group chat), and a key prerequisite (bot membership). It does not explicitly state the return type or error handling, but these are largely inferable. The single parameter is fully documented in the schema. No output schema exists, so the description could mention the return value, but the name implies an integer. Overall, it is sufficient for an agent to call it correctly.

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

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

The schema description for groupId already covers the parameter semantics: 'LINE Group ID (starts with "C")'. The tool description adds no additional parameter detail. Since schema coverage is 100%, the baseline of 3 applies – the description does not need to compensate, but also adds no value beyond the schema.

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

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

The description states the specific verb 'Get' and the resource 'number of members in a LINE group chat', which clearly distinguishes it from siblings like get_group_member_ids (which lists IDs) and get_room_member_count (which targets rooms). The purpose is unambiguous and action-oriented.

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 includes a clear prerequisite: 'The bot must be a member of the group.' This guides when the tool can be used. While it doesn't explicitly contrast with alternatives, the group vs. room distinction is implicit in the name and description, so agents can infer when to select it. The condition adds practical 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 present, so the description carries the full burden. It states a precondition but does not describe what happens if the bot is not a member, the return format, or any error behavior. The read-only nature is implied but not explicitly 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 two concise sentences with no redundant information. It clearly states the action, the resource, and the prerequisite. Every word contributes to understanding the tool's purpose and requirements.

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 operation, the description is mostly sufficient but omits details about the return value (e.g., format of user IDs) and potential error conditions if the bot is not a member. It is 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?

The schema includes a description for the only parameter (groupId), so coverage is 100%. The tool description does not add any additional 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 uses a clear verb 'Get' and specifies the resource ('user IDs of all members in a LINE group chat'). It also notes a key constraint ('bot must be a member'). However, it does not explicitly distinguish from sibling tools like get_group_member_profile, so it isn't a perfect 5.

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

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

The description includes a precondition ('bot must be a member') but provides no guidance on when to use this tool versus alternatives. It does not mention scenarios where this tool is inappropriate or preferred over other get_group_* 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 discloses the membership requirement, a key behavioral constraint, but does not mention error handling, return format, or other operational details. For a read operation, this is moderate transparency.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently states the purpose and the key precondition (bot membership) without unnecessary words.

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

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

The description is adequate for a simple get operation with two well-documented parameters and no output schema. It states the purpose and the bot membership precondition, which is essential. Missing details like return format are minor given the tool's simplicity.

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 full descriptions for both parameters (LINE User ID and Group ID formats), so the description adds no extra parameter meaning. Per the rubric, with 100% schema coverage, the baseline is 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 clearly states the action ('Get a member's profile') and the specific scope ('in a LINE group chat'), distinguishing it from the sibling get_room_member_profile. It also adds the membership prerequisite, which gives additional context about the tool's intended use.

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

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

The description implies the use case for group chats but does not explicitly contrast with alternatives like get_room_member_profile or get_user_profile. The context is clear, but exclusions are not stated, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden. It does disclose the read-only nature (a 'get' of name and picture URL) and the membership precondition, which is valuable context. However, it omits failure behavior (what occurs when the bot is not a member) and the exact response format, leaving some transparency gaps for a read operation.

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

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

Two tight sentences with zero filler. The core action and returned fields are front-loaded, followed by the one critical prerequisite. Nothing extraneous.

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

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

Complete for a simple 1-parameter getter with full schema coverage and no output schema: purpose, returned data, and the key constraint are all present. Minor gap is the absence of error behavior, which is acceptable for a straightforward read tool.

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

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

Schema coverage is 100% with a clear description of groupId ('LINE Group ID (starts with C)'), so the schema already fully documents the parameter. The description adds only the membership constraint, not additional parameter syntax or format details, matching 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?

States a specific verb and resource ('Get a LINE group's name and picture URL'), clearly identifying what data is returned. This distinguishes it from sibling member tools like get_group_member_count and get_group_member_profile, and from the message-sending tools, though it does not name an alternative explicitly.

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

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

Provides a useful prerequisite ('The bot must be a member of the group') but gives no guidance on when to choose this tool over siblings such as get_group_member_count, get_group_member_profile, get_user_profile, or get_bot_info. No when/when-not routing is offered.

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 behavioral disclosure. It only states what the tool does but does not mention timezone handling (beyond schema), rate limits, authentication requirements, or the structure of the breakdown. For a read-only tool, this is a minimal but not comprehensive 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 sentence that is both concise and front-loaded with the core purpose. Every word adds value, and it avoids redundancy with the schema.

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

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

The tool has one parameter and no output schema. The description mentions 'breakdowns by API type' but does not explain the format or fields of the response. While an agent can infer the basic purpose, the lack of guidance on response structure or usage conditions leaves some gaps, though it is not severely incomplete for a simple query 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 already fully describes the single 'date' parameter with pattern, example, and timezone, achieving 100% schema coverage. The description adds no additional parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

States a clear verb (Get), resource (number of message deliveries), and specific qualifiers (on a specified date, breakdowns by API type). It is distinct from sibling tools like get_sent_push_count, which count sends, not deliveries, and clearly conveys its 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?

Provides no guidance on when to use this tool versus alternatives. It does not mention which sibling tools it overlaps with or when one would choose this over get_sent_reply_count or get_statistics_per_unit. The agent is left to infer usage from the name and description.

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

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

Annotations are absent, so the description carries full weight. It clearly implies a read-only operation ('Get statistics'), but does not disclose response format, pagination, error handling, or whether the result is for a single message or aggregated across 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?

A single, focused sentence conveys the purpose without extra fluff. The structure is clean and directly informative.

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, no output schema), and the parameter is well-described. However, it lacks details on the return structure, possible values (e.g., counts, percentages), and any relationship to sibling statistics tools, leaving some 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 provides a complete description for requestId ('Request ID of a sent message'), achieving 100% coverage. The tool description adds no further meaning to the parameter, so it stays at 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?

Description clearly states the tool retrieves engagement statistics (impressions, clicks, other metrics), using the specific verb 'Get statistics'. It distinguishes itself from sibling tools like get_message_deliveries (delivery status) and get_statistics_per_unit (per-unit data) by focusing on user interaction metrics.

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 explicit guidance on when to choose this tool over alternatives such as get_message_deliveries or get_statistics_per_unit. The description implies usage for engagement analytics but does not state conditions or selection criteria.

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

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

No annotations are provided, so the description carries the burden. It implies a read-only operation (getting quota) but does not explicitly state that it has no side effects or that it only reads data. While the intent is clear, a more explicit statement about being non-mutating would improve transparency.

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

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

The description is a single, concise sentence that directly conveys the purpose without unnecessary details. It is well-structured and easy to parse.

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 an output schema, the description provides reasonable context by indicating the response includes quota type and limit. It does not elaborate on error conditions or additional fields, but for a simple getter, this is adequate. It lacks guidance on when to use it, which is more relevant to usage guidelines.

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 no parameters, so the description does not need to explain parameter semantics. It does mention 'quota type and limit' which hints at the output structure, adding value beyond the empty schema. This is sufficient for a parameterless tool.

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

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

The description clearly states the tool's function: retrieving the message quota for the LINE Official Account, specifying that it includes quota type and limit. This distinguishes it from related tools like get_message_quota_consumption and other messaging-related getters.

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 scenarios where this should be preferred (e.g., checking overall quota) over get_message_quota_consumption or other quota-related tools, leaving the agent to infer from names 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?

Since there are no annotations, the description must convey the behavioral nature of the tool. The description implies a read-only operation ('Get the number of messages sent this month') and does not suggest any side effects or mutations. However, it does not explicitly state that this is a non-mutating, read-only call, nor does it mention potential error conditions or edge cases (e.g., if the monthly quota has been exceeded or if data is unavailable). For a simple getter, this is adequate but not fully transparent.

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

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

The description is a single, succinct sentence with no superfluous words or redundant phrasing. It clearly communicates the primary action and subject without any fluff, making it highly efficient and easy to parse.

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 parameterless getter, the description provides enough context for an agent to understand what data is being retrieved. It specifies the resource ('message quota consumption') and the time frame ('this month'). It does not explain the return format, but since there is no output schema, that is not required. The description is adequate for the tool's apparent simplicity, though it could mention the return value type (e.g., an integer count) for additional clarity.

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 no parameters, so schema coverage is effectively 100% (no parameters to document). According to the rubric, when schema coverage is high, a baseline score of 3 is appropriate even without additional parameter descriptions. Since there are no parameters, the description adds no parameter-specific meaning, which is consistent with the 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 clearly states a specific verb 'Get' and a specific resource 'message quota consumption', which distinguishes it from the many similar 'get_sent_*' and 'get_statistics_*' tools. It is concise but unambiguous about the subject matter, though it could benefit from specifying exactly what 'quota consumption' refers to (e.g., count of messages sent toward the monthly limit).

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

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

The description provides no explicit guidance on when to use this tool versus the many sibling tools that also retrieve message statistics or delivery counts. There is no mention of intended use cases or when alternatives like get_sent_reply_count or get_message_deliveries would be more appropriate. This leaves the agent to infer the tool's purpose solely from the name and minimal description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read operation via the verb 'get' and lists the returned metrics, but does not explicitly state that it is read-only, discuss rate limits, authentication requirements, or error behavior. The description is not misleading but adds limited depth beyond the obvious.

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 that front-loads the primary action and includes the key returned values. There is zero waste, and it is appropriately sized for a simple one-parameter read 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 simple metric tool with one parameter and no output schema, the description covers the core purpose and return values. It could mention behavior when data is missing or clarify that it is account-level data, but given the simplicity, it is largely 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 the date parameter is already well-documented in the schema (format, timezone, example). The tool description adds no additional meaning about the parameter, so it does not go beyond the baseline for high coverage.

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

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

The description states a specific verb (get) and resource (number of followers for the LINE Official Account) plus a temporal qualifier (on a specified date). It also lists what it returns (follower count, targeted reaches, blocks), which distinguishes it from sibling tools like get_follower_ids that focus on IDs rather than counts.

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

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

There is no guidance on when to use this tool versus alternatives such as get_follower_ids or get_statistics_per_unit. The description does not mention exclusions or contexts where another tool would be more appropriate, leaving the agent to infer from the name alone.

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

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

No annotations are provided, so the description carries the full burden. The description indicates a read operation ('get') but does not disclose behavior on missing IDs, error responses, or any other edge cases. It is not contradictory, but adds little beyond the obvious.

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

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

A single, front-loaded sentence with zero filler. It conveys the essential action and selector immediately.

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

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

For a simple single-parameter get tool, the description is sufficient: it tells the agent what to do and what the input is. Since there is no output schema, the phrase 'get a rich menu' implies the return value. It does not mention error handling, but that is not critical for a simple read.

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

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

The input schema already describes the richMenuId parameter fully (100% coverage). The description's 'by its ID' repeats the schema's description without adding syntax, format, or context. 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 (get), a specific resource (rich menu), and the key selector (by ID). It clearly distinguishes from siblings like list_rich_menus and create_rich_menu, leaving no ambiguity about what this 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?

The description does not explicitly mention alternatives or when to use this tool vs list_rich_menus. The usage is implied from the name and the 'by ID' qualifier, but there is no explicit guidance about when this tool is appropriate versus other rich menu 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 discloses the prerequisite (bot must be a member) but does not mention error conditions, response format, or any side effects. Since it's a simple read operation, the lack of detail is a minor gap, but it could have been more explicit about being read-only or about failure cases.

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 with zero redundancy. The primary action is front-loaded, and the prerequisite follows immediately. Every word earns its place.

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

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

For a simple read with one parameter and no output schema, the description covers the essentials: what it does, the target resource, and a key precondition. It could mention the return type (integer count) or error behavior, but these are largely implicit. Overall, it is sufficiently complete for an agent to call it correctly.

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

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

The input schema already documents roomId with 'LINE Room ID (starts with "R")', so the schema provides full coverage. The description adds no additional meaning about the parameter, so it does not exceed the baseline of 3 for high schema coverage.

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

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

The description clearly states the verb 'Get' and the resource 'the number of members in a LINE multi-person chat room', distinguishing it from sibling tools like get_group_member_count (for groups) and get_room_member_ids (for IDs). The condition that the bot must be a member adds 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?

It provides clear context: the tool is for LINE multi-person chat rooms, and the bot must be a member. It does not explicitly mention alternatives or when not to use it, but the purpose is unambiguous, and the prerequisite is stated. This meets the 'clear context, no exclusions' criterion.

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

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

No annotations are present, so the description bears full responsibility for disclosing behavior. It states a requirement (bot membership) but does not mention side effects, error handling, pagination, or what happens if the bot is not a member. This is a significant gap for a read operation.

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

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

Two short sentences with no redundancy. The purpose and a key requirement are conveyed efficiently, making it easy to parse.

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 and the description implies the output (user IDs). However, it does not specify the shape of the output (e.g., list) or potential edge cases. Given the lack of output schema, it is sufficiently complete, but could be slightly more explicit.

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 fully documents the parameter (roomId with format hint). The description adds minimal extra context by referencing the room and membership, but does not elaborate on the parameter beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the action (get user IDs), the resource (all members in a LINE multi-person chat room), and distinguishes it from sibling tools like get_group_member_ids by specifying 'multi-person chat room' and 'bot must be a member of the room'.

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 a clear prerequisite: the bot must be a member of the room. While it doesn't explicitly compare with alternatives, the context makes it obvious that this is the tool for retrieving member IDs in a room, not a group or other 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. It discloses the membership prerequisite but does not mention the read-only nature, error conditions (e.g., if the bot is not a member), or return format. It adds some useful context but lacks comprehensive 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 a single, front-loaded sentence that states the purpose and a critical prerequisite. There is no redundancy or filler, making it highly concise and efficient.

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 tool is simple (2 parameters, no output schema), the description lacks guidance on when to choose this tool over similar siblings and does not describe the profile fields returned. The prerequisite is helpful but the description is not fully complete for an agent to confidently select and invoke the correct 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 input schema describes both parameters fully (roomId and userId with format hints). The tool description adds no additional parameter information, so with 100% schema coverage 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 clearly states the verb 'Get' and the resource 'a member's profile in a LINE multi-person chat room', distinguishing it from sibling tools like get_group_member_profile (for groups) and get_user_profile (general user). The scope is specific and 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 a key prerequisite ('The bot must be a member of the room') but does not explicitly guide when to use this tool versus siblings such as get_group_member_profile or get_user_profile. The usage is implied by the room context, but no alternatives or exclusions are stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes a read-like operation (getting a count) but does not explicitly state that it is read-only, safe, or non-destructive. It also does not disclose any potential rate limits, authentication requirements, or side effects. Given the simplicity, the lack of disclosure is not severe, but it leaves some ambiguity.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently states the purpose without redundancy, making it easy for an agent to parse quickly.

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

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

For a tool with a single parameter and no output schema, the description is largely sufficient. It clearly identifies the resource and scope. A minor omission is the return type (an integer count), which could be inferred but is not explicitly stated. Overall, it is complete enough for an agent to invoke correctly.

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

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

The input schema provides 100% coverage of the single parameter (date), including format, pattern, and timezone. The description merely refers to 'a specified date' without adding any semantic nuance beyond what the schema already documents. This meets the baseline for full 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 specific verb ('Get') and a resource ('number of broadcast messages') with a qualifier ('sent on a specified date'). It is clear and unambiguous, but it does not explicitly distinguish itself from sibling count tools like get_sent_push_count or get_sent_multicast_count, relying on the tool name for differentiation.

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

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

The description provides clear context by specifying 'broadcast messages', which implies its use case. However, it does not offer explicit guidance on when to use this tool over alternative count tools (e.g., get_sent_push_count) or mention any conditions that would make it inappropriate. The 'when' is implied, not 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, and the description does not disclose any behavioral aspects such as side effects, permissions required, error possibilities, or whether it is a read-only operation. The description simply states what it does without revealing any behavioral traits beyond the basic function.

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

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

The description is a single, concise sentence that directly states the purpose without any superfluous words or structures. It is well-organized and easy to parse, containing only the essential 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?

Given the simplicity of the tool (one parameter, no output schema), the description is fairly complete. It tells the agent exactly what the tool does and the required input. However, it does not mention potential return values or error scenarios, which might be expected in a more complex context, but for a simple count retrieval, it is sufficient.

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

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

The input schema provides a clear and detailed description of the only parameter 'date' (format, example, length, timezone). The tool description does not add any additional meaning beyond that, but since the schema coverage is 100%, the baseline is 3. The description adds no extra context about the parameter.

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

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

The description clearly states the action (Get), the resource (number of multicast messages sent), and the scope (on a specified date). It distinguishes itself from sibling tools like get_sent_push_count or get_sent_broadcast_count by explicitly mentioning multicast, making its 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 does not provide any guidance on when to use this tool versus alternatives. It does not mention conditions, prerequisites, or scenarios where this tool is preferred over similar tools like get_sent_push_count or get_sent_broadcast_count. The information is implicit from the tool name, but not explicitly stated.

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

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

With no annotations, the description carries the full burden. It indicates a read operation but does not disclose potential errors, rate limits, or side effects, leaving some behavioral aspects unclear.

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, clear sentence with no unnecessary words, and it directly follows the tool's purpose.

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

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

For a simple query tool, the description provides sufficient context. No output schema is present, and the parameter format is already specified in the schema, so nothing essential is missing.

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

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

The schema already provides detailed parameter description (format, timezone). The tool description only reiterates 'specified date' and adds no new meaning, so it meets the baseline for high schema coverage.

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

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

The description clearly states the specific action (get number) and the resource (push messages sent on a date), making it distinguishable from sibling tools like get_sent_reply_count or get_sent_broadcast_count.

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

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

The description does not explicitly mention when to use this tool over alternatives. The name and context imply it, but explicit guidance is absent.

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 states the core function (getting a count) but does not disclose any behavioral traits such as read-only nature, timezone handling beyond the schema, rate limits, or what the response format looks like. The description is minimal and adds no context beyond the basic 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, concise sentence that front-loads the action and resource. There is zero waste, and it effectively communicates the tool's purpose without unnecessary elaboration.

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 tool with one parameter, no output schema, and no annotations, the description adequately conveys the core functionality. It indicates the tool returns a count and specifies the date input. It does not explain what a 'reply message' is or any edge cases, but given the tool's simplicity and the schema's coverage, the description is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents the 'date' parameter with format, pattern, and timezone. The description does not add any additional semantic meaning beyond what the schema provides, so the score remains at the 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 clearly states the verb 'Get' and the specific resource 'the number of reply messages sent on a specified date'. This distinguishes it from sibling getters like get_sent_push_count or get_sent_broadcast_count by focusing on reply messages. The purpose is unambiguous.

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

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

The description provides the context of a specified date but does not offer explicit guidance on when to use this tool versus its alternatives (e.g., get_sent_push_count, get_sent_multicast_count). It implies usage for reply message counts but does not name exclusions or alternative conditions. An agent could infer the distinction from the resource name, but no explicit routing guidance 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. It only states the action without mentioning side effects, permissions, rate limits, pagination, or return format. The agent is left uninformed about operational constraints or expected output structure.

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 redundant words, front-loading the core action and scope. It is maximally concise while still conveying the essential purpose, earning a top score for efficiency.

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 an output schema and annotations, the description is too sparse to be complete. It does not explain what statistics are returned, how the date range behaves, or any edge cases. An agent would need more context to confidently invoke the tool and interpret results.

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 all three parameters have descriptions. The tool description adds no additional semantic meaning beyond the schema, such as date format nuances or the meaning of a custom aggregation unit. Baseline 3 is appropriate since the schema already 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 clearly states a specific action (Get), a resource (statistics per custom aggregation unit), and a scope (messages within a date range). It distinguishes itself from siblings like push or user-profile tools, though the term 'statistics' is somewhat generic and doesn't specify which metrics are returned.

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 such as get_sent_push_count or get_message_deliveries. It neither names alternatives nor explains why this tool is preferable for aggregate statistics, leaving the agent to infer context.

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

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

With no annotations, the description must carry the burden. It states the returned data but does not mention potential errors, authentication requirements, or side effects. For a simple getter, this is minimally transparent but not comprehensive.

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, clear sentence with no unnecessary words. It is front-loaded with the action and resource, making it easy to parse.

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, the description is sufficient: it lists all return fields. It does not explain error handling or response format, but given its simplicity and the surrounding toolset, it is reasonably complete.

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

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

The input schema has full coverage (100%) for the single parameter 'userId', which already includes a description. The tool description adds no extra semantic detail beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb ('Get'), the resource ('LINE user'), and lists the exact fields returned. This distinguishes it from all sibling tools, which are push/broadcast or other getter operations.

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

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

While there is no explicit 'use this when' statement, the tool is the only one that retrieves user profile data, so the context of sibling tools makes the usage clear. No alternative exists to confuse the agent.

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

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

No annotations are provided, so the description carries the burden. It states the action is permanent, which is a key behavioral side effect. It does not mention irreversibility in terms of re-joining later, but the 'permanently' is sufficient for this simple 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 two concise sentences, front-loaded with the primary action and followed by the key side effect. No extraneous 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?

Given the simple single parameter and no output schema, the description adequately covers the action and its permanent effect. It does not explain return values, but none are expected for a void operation like leaving a group.

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% (groupId is described as 'LINE Group ID (starts with "C")'). The description does not add additional meaning beyond that, but since the schema already explains the parameter fully, 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 clearly states the action 'leave' on a specific resource 'LINE group chat', and distinguishes it from the sibling 'leave_room' by explicitly mentioning 'group'. No ambiguity.

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

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

It is evident this tool is for making the bot exit a group, and the permanent nature is stated. However, it does not explicitly contrast with leave_room (which serves rooms) or mention when not to use it, but the group/room distinction is implicit.

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 behavioral transparency burden. It only notes that the bot leaves permanently, but omits details such as whether the operation is reversible, what happens if the bot is not a member, or any side effects. This is 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 concise, consisting of two short sentences. The first sentence states the core action, and the second adds a key detail (permanence). It is well-structured and front-loaded with the primary purpose.

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

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

For a simple tool with one parameter, the description is somewhat minimal. It does not mention the response or result (no output schema), nor any prerequisites or error conditions. While the action is straightforward, the lack of such context could lead to ambiguity in certain edge cases, so completeness is moderate.

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

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

The schema already provides a description for roomId (LINE Room ID starting with 'R'), so coverage is 100%. The tool description does not add further meaning to the parameter, such as how to obtain it or any constraints. Given full schema coverage, 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 clearly states the action ('Leave') and the specific resource ('LINE multi-person chat room'). It also notes the permanence of the action, which distinguishes it from temporary actions. The resource type is distinct from sibling tools like leave_group, making the 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 does not explicitly state when to choose this tool over alternatives such as leave_group. It implicitly indicates the target is a room, but lacks a direct comparison or condition to guide the agent. Since the sibling list includes leave_group, more explicit selection criteria would be beneficial.

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. 'Link' implies a mutation, but the description does not mention whether linking overrides an existing rich menu, whether the user must already exist, or any permission requirements. This is a significant gap 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 a single, concise sentence that immediately conveys the action and target. It is efficiently front-loaded with no unnecessary words or repetition. The brevity is appropriate for a straightforward operation.

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

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

Given the lack of annotations and output schema, the description is too minimal to fully prepare an agent. It does not explain whether linking is idempotent, whether it replaces an existing link, or any failure conditions. For a mutation tool with no safety annotations, more context is needed 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 input schema provides 100% coverage with descriptions for both userId ('LINE User ID') and richMenuId ('Rich menu ID'). The description adds no additional semantic meaning beyond what the schema already states, 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 states the verb 'Link' and the resource 'rich menu to a specific user', which clearly conveys the operation. It implicitly distinguishes from siblings like unlink_rich_menu_from_user and set_default_rich_menu by specifying 'a specific user', but does not explicitly call out those alternatives. The purpose is unambiguous and easily 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?

No guidance is provided on when to use this tool versus related tools such as set_default_rich_menu or unlink_rich_menu_from_user. The description simply states what it does without mentioning context, prerequisites, or exclusions. An agent would have to infer usage from the name and parameters.

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 no mention of side effects, permissions, output format, or pagination. The description only says 'list', which implies a read-only operation, but does not clarify what the response contains or whether any limits apply.

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, clear sentence with no unnecessary words. It directly states the action and object.

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 operation, the description covers the basic function, but it lacks details about the response structure, such as whether it returns a list of menu objects or includes metadata. Without an output schema, this missing information leaves some ambiguity.

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% since there is nothing to document. The description adds no confusion and is consistent with an empty parameter set.

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 'list', the resource 'rich menus', and the scope 'for the LINE Official Account'. It unambiguously distinguishes this from sibling tools like get_rich_menu which fetches a single menu or create_rich_menu which creates one.

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

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

The description does not explicitly state when to use this tool over alternatives, though the name and phrase 'all' imply it is for retrieving the full set of rich menus. It lacks direct guidance such as 'when you need to see all menus' or contrast with get_rich_menu.

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 disclosing behavior. It only states the send action and the max user count, but does not mention side effects, error handling, permissions, or any operational details.

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

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

The description is a single, clear sentence that front-loads the main action and constraint. It is concise without unnecessary detail.

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, combined with a complete schema, gives enough context for an agent to understand the tool's purpose and parameters. However, it lacks explicit information about the response or potential failure modes, which might be needed for full operational context.

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

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

The schema already provides descriptions for all three parameters, and the tool description does not add significant extra meaning beyond what is in the schema. It only restates that it sends a Flex Message, which is already clear from the schema's contents 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 clearly states the action (send) and the resource (Flex Message) to multiple LINE users, with a specific limit of 500 user IDs. It distinguishes itself from broadcast by implying a targeted multicast.

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

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

The usage is implied from the description (sending to multiple specific users) but not explicitly contrasted with alternatives like broadcast or single push. There is no explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states a basic send action but offers no detail on side effects, error handling, delivery confirmation, or any other operational behavior. The only added constraint (max 500) merely repeats the schema's maxItems, adding no new 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 a single, concise sentence that front-loads the core action and the key constraint. There is no wasted wording or unnecessary detail.

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

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

For a simple two-parameter send tool with full schema coverage, the description is largely sufficient to convey the basic operation. However, it lacks explicit guidance on when to choose this over sibling tools and does not mention any return value or error behavior, leaving some contextual gaps for an agent deciding how to use it.

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

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

Schema description coverage is 100%, so both parameters (text and userIds) are fully documented in the schema. The description adds no additional meaning beyond the schema; it only echoes the max 500 limit already present in maxItems. Therefore, a 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', the resource 'text message', and the recipient scope 'multiple LINE users at once' with a specific cap of 500 user IDs. This clearly distinguishes it from push (single user) and broadcast (all users) tools, even though it doesn't name them explicitly.

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

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

The phrase 'multiple LINE users at once' implies usage for a targeted group rather than a single user or entire audience, but it does not explicitly mention alternatives like push_text_message or broadcast_text_message, nor does it state when not to use this tool. The guidance is implied, not explicit.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'send an audio message', which is a write operation, but it does not mention authentication requirements, potential failures, rate limits, or what happens on success. The description is too sparse to be transparent.

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

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

The description is a single, concise sentence that states the action and target. It is well-structured and front-loaded with the core purpose, with no unnecessary words.

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

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

For a simple send operation, the description covers the essential purpose. However, it lacks information about return values (no output schema) and does not mention any side effects or limitations. Given the tool's simplicity, it is mostly complete but could benefit from a note that it is a one-way push without a response.

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

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

The input schema already provides 100% coverage of parameter descriptions, including details like the 'to' pattern and fallback to DEFAULT_UID. The description adds no additional parameter semantics, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action: 'Send an audio message' with the target being a LINE user, group, or room. It is specific to audio and distinguishes it from sibling push_message tools like push_text_message or push_image_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?

The description implies use when sending an audio message, but it does not explicitly state when to use this over alternatives or any exclusions. No guidance on prerequisites or context beyond the message type 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?

With no annotations provided, the description carries the full burden of disclosing side effects. It mentions 'send' but does not describe potential outcomes like delivery failures, rate limits, or message validation issues, leaving the agent uninformed about behavioral consequences.

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 concise and to the point, using two short sentences that cover the primary action, target, and key input without any redundant or extraneous 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?

Given the context of many sibling push tools, the description fails to provide sufficient context for an agent to decide when to choose this Flex Message tool over alternatives. It also does not mention any output or return behavior, though the schema lacks an output schema, so that omission is partly mitigated.

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

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

The schema already provides descriptions for all three parameters ('to', 'altText', 'contents'). The tool description adds the detail that 'contents' is a Flex container in JSON string form, but this is minimally additive since the schema's description already states the JSON nature and allowed values.

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

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

The description clearly states the action ('Send') and the specific resource ('Flex Message'), which distinguishes it from sibling tools like push_text_message or push_image_message. The phrase 'rich layout' further clarifies the nature of the content.

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

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

The description does not explicitly state when to use this tool over the many sibling push options (e.g., text, image, sticker). It relies on the reader's understanding of Flex Messages, but offers no comparative guidance or conditions for 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 must carry the behavioral disclosure burden. It only says 'Send an image' and does not mention side effects, auth requirements, quota consumption, delivery semantics, or error behavior. For a mutating API call, this is a significant gap beyond what the schema covers.

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, repetition, or unnecessary detail. It states the verb, object, and target destinations in the fewest possible words.

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

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

The full schema compensates for missing parameter prose, but there are no annotations and no output schema. The description does not offer usage exclusions, behavioral caveats, or guidance on when to prefer a broadcast or multicast sibling. It is minimally viable but not rich enough to be fully contextual.

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 all three parameters with 100% coverage, including the 'to' pattern and fallback, plus URL format and size limits. The description adds no parameter-level detail, so the baseline of 3 applies. The schema is doing the semantic 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 uses a specific action ('Send an image') and names the exact resource and target scope ('LINE user, group, or room'). This clearly distinguishes it from the sibling push_text_message, push_sticker_message, push_video_message, and other content-type tools. The singular target phrasing also differentiates it from broadcast and multicast siblings.

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

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

The description makes the use case clear: push an image message to a single LINE conversation, whether user, group, or room. It does not explicitly name alternatives or exclusion criteria, but the content type and target scope provide enough context to route an agent correctly. No misleading guidance is present.

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

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

No annotations are present, so the description carries the full burden. It only states the action without describing side effects, return values, error handling, or any behavioral nuances, which is minimal for a communication 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?

A single, concise sentence that communicates the essential purpose without verbosity or redundancy.

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

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

The tool is simple, but the absence of any output schema or mention of response/behavior leaves some ambiguity. Given the low complexity, this is acceptable 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?

The schema descriptions for parameters are present and cover all fields (target ID, title, address, latitude, longitude). The description itself does not add extra context beyond what the schema provides, so it meets the baseline but does not exceed 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 clearly states the action ('Send a location message') and the target types ('user, group, or room'), making it distinct from sibling push_* tools like push_text_message or push_image_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?

The purpose is unambiguous, so an agent would know when to use it. However, it does not explicitly mention alternatives or when not to use it, though the sibling tools are self-evident.

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

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

No annotations are provided, so the description must carry the burden. It mentions the sticker requirement and the fallback for 'to' via schema description, but it does not disclose return values, potential errors, or side effects beyond sending.

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, using a single sentence and a short reference to the sticker list. No unnecessary words or repetitive 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?

Given the simplicity of a push action and lack of output schema, the description is reasonably complete. It covers the essential action and points to the sticker list for valid IDs. It does not explain return values, but for this tool type that may not be essential.

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 all three parameters (100% coverage). The 'to' parameter is well explained with the fallback to DEFAULT_UID. 'packageId' and 'stickerId' are briefly described but the main description adds the 'See LINE sticker list' context, making them understandable.

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

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

The description clearly states the action ('Send a LINE sticker') with a specific verb and resource, distinguishing it from other push_* tools like push_text_message or push_image_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?

The description does not explicitly explain when to use this tool versus alternatives (e.g., broadcast or multicast message tools). The name 'push' implies a single recipient, but this is not stated. However, the sibling list provides some implicit 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 must convey behavior. It does not mention side effects (e.g., message delivery), rate limits, authentication requirements, or potential errors. The fallback to DEFAULT_UID is present in the schema but not expanded in the description.

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, with two sentences that front-load the core action and target. No redundant or filler content.

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

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

For a simple messaging tool with no output schema, the description is sufficient to understand the primary function. It could benefit from a hint about when to use this over other push types, but overall it is adequately complete given the low complexity.

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 covers 100% of parameters, so baseline is 3. The description adds no new semantic information about 'to' or 'text' beyond what the schema already specifies.

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

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

The description clearly states the action (send a text message) and the target types (user, group, or room), which distinguishes it from other push_* tools. The prefix details reinforce the target 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?

The description implies usage by specifying the action and target types, but does not explicitly contrast with alternative tools like push_image_message or push_flex_message. It lacks guidance on when text messaging is preferred over other content types.

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 action ('Send a video') and reveals nothing about failure behavior, authentication requirements, rate limits, delivery semantics, or what happens on invalid content. For an action tool 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?

A single efficient sentence with zero waste, action verb front-loaded. However, the brevity edges toward under-specification rather than true conciseness — it's short because it omits useful context, not because it distills a rich 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 tool with no annotations and no output schema, the description is thin. It lacks the push-vs-broadcast/multicast usage distinction that would help an agent choose correctly, and doesn't touch on content size limits or delivery constraints. The rich schema compensates for parameter coverage but not for behavioral and usage context.

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

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

Schema description coverage is 100%, with rich per-parameter details (ID pattern ^[UCR], HTTPS/JPEG/PNG and HTTPS/MP4 format constraints, and the DEFAULT_UID fallback). Per the rubric, high schema coverage sets a baseline of 3. The description itself adds no parameter information beyond the schema, which is acceptable 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 states a clear action ('Send a video') with an explicit target scope ('a LINE user, group, or room'). It distinguishes from the sibling message-type tools (push_text_message, push_image_message, etc.) by content type inherently. However, it doesn't explicitly name any sibling or clarify push-vs-broadcast/multicast mechanics, so it stops short of full differentiation.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention when push is appropriate versus broadcast (broadcast_text_message, broadcast_flex_message) or multicast, nor any prerequisites or exclusions. An agent is left to infer usage purely from the tool name.

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

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

No annotations are present; the description states the action but does not disclose side effects such as overwriting existing defaults or requiring the rich menu to exist.

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

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

One sentence, no 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?

Provides enough context for the basic action, but lacks details on prerequisites or consequences.

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 parameter description mirrors the schema; no additional meaning is added by 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 clearly states the action (set), the object (rich menu), and the scope (default for all users), distinguishing it from sibling tools that create, get, or cancel default.

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 implicitly indicates usage when wanting to establish a default rich menu, but does not explicitly mention alternatives or preconditions.

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 for transparency. It only states that a loading animation is displayed, but does not disclose potential side effects (e.g., timing, whether it blocks further actions, or if it auto-dismisses). This lack of behavioral detail is a 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, front-loaded sentence that immediately conveys the action and context. It is concise and contains no redundant information.

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

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

Given the simplicity of the tool and the absence of an output schema, the description covers the basic purpose. However, it omits practical context such as the expected duration of the loading indicator, any prerequisites (e.g., chat must exist), or limitations. This is acceptable for a minimal tool but leaves some gaps.

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

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

The schema already includes a clear description for chatId (including the fallback to DEFAULT_UID), and schema coverage is 100%. The tool description adds no additional meaning to the parameter, matching 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 clearly states the tool's function: 'Display a loading animation in the LINE chat to indicate processing.' It uses a specific verb and resource, and it is easily distinguished from sibling tools that focus on sending messages (push, broadcast, multicast) or managing rich menus.

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

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

The description does not explicitly state when to use this tool versus alternatives, such as indicating it should be used before a push or as a temporary UI state. While the tool's purpose is distinct, comparative usage context is missing.

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

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

No annotations are provided, so the description carries the full burden. It discloses the primary effect (unlinking) but does not mention side effects, reversibility, or any error conditions. The description is minimal and does not elaborate on the behavioral outcome beyond the action itself.

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

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

The description is a single, concise sentence that directly states the action. It is appropriately sized and front-loaded with the verb, making it easy to understand without extra fluff.

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

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

The description is complete for a simple unlink operation. It does not mention return values or side effects, but since no output schema is provided and the action is straightforward, the current description adequately conveys the purpose and expected 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?

The schema provides a description for the only parameter (userId: 'LINE User ID'), which covers 100% of the parameters. The tool description does not add any additional semantic detail beyond what the schema already provides, 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 clearly states the action: 'Unlink the rich menu from a specific user.' It specifies the verb and the resource, and distinguishes it from sibling tools like 'link_rich_menu_to_user' and 'cancel_default_rich_menu'.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It does not mention conditions or contexts where unlinking a specific user's rich menu would be preferred over other operations.

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