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

With no annotations, the description carries the full burden. It usefully discloses a filesystem side effect (writes the file to disk) and the return value (path), plus the accepted media types and default destination. It omits auth requirements, overwrite/collision behavior, size or rate limits, and what happens if the message has no attachment.

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

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

A single compact sentence that front-loads the verb and resource, then the effect and return value. No filler, no repetition of the schema, nothing wasted.

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

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

For a tool with no annotations and no output schema, the description covers the essential outcome (path returned) and the save behavior. Gaps remain around failure modes, overwrite semantics, and when to prefer a sibling such as get_message_image, leaving it adequate but not complete.

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

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

Schema description coverage is 100%, so chatMid, messageId, and saveDir (including its default) are already documented in the schema. The description adds no extra parameter meaning, so the baseline of 3 applies.

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

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

The description states a specific verb (ดาวน์โหลด/download) and resource (ไฟล์แนบจากข้อความ/attachment from a message), enumerates the accepted attachment types, and states the outcome (saved locally, returns the file path). It is clear and concrete, but never differentiates itself from the close sibling get_message_image, so an agent must infer the boundary.

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

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

Usage is only implied: saving to disk and returning a path suggests you call this when you need a local file rather than in-memory content. There is no explicit when/when-not, no mention of prerequisites, and no reference to alternatives such as get_message_image for the same message's image.

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

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

No annotations exist, so the description carries the full burden, and it does disclose one genuinely useful behavioral trait: image/file messages are surfaced as [IMAGE]/[FILE] with a messageId. However, it says nothing about permissions, ordering of results, or whether 'recent' is bounded by the limit parameter.

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; the return-format caveat is attached rather than given its own bloat sentence.

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

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

With no output schema and no annotations, the description should carry more of the return contract. It explains the image/file placeholder but not the shape of a normal message (sender, timestamp, text), nor ordering/pagination behavior, which an agent needs to use the result correctly.

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

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

Schema description coverage is 100% (both limit and chatMid are documented in the schema), so the baseline is 3. The description adds no syntax or format detail beyond the schema, only the loose notion of 'recent'.

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+resource ('read recent chat message history') and even specifies a return-format quirk ([IMAGE]/[FILE]). It does not differentiate itself from close siblings such as get_new_messages or wait_for_message, which is the only thing keeping it from a 5.

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

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

The description only restates the purpose; it never says when to use this tool instead of get_new_messages, wait_for_message, or get_message_image. No prerequisites, no exclusions, no alternative 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?

No annotations are provided, so the description carries the full burden. It does add one meaningful behavioral fact: the tool returns something the model can observe visually, not just a file path. It omits error behavior (non-image message, missing image), size/format limits, and permission needs.

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

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

A single front-loaded sentence that names the resource and the ID-based lookup with no padding. It is efficient, though very brief for a tool with zero annotation support.

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

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

For a 2-parameter read tool with no output schema and no annotations, the description covers the core purpose but leaves return format and failure modes unstated. It is minimally sufficient rather than complete.

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

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

Schema description coverage is 100% with both chatMid and messageId documented in the schema, so the baseline is 3. The description adds no format or syntax detail beyond what the schema already provides.

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

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

States a specific verb and resource: fetching the image from a message identified by ID, and adds the intent (so the AI can view it directly). This distinguishes it reasonably from download_message_file and send_image, though it never names those siblings 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 'so the AI can see the image directly' implies the use case (vision/inspection rather than saving a file), but there is no explicit when-to-use guidance and no comparison against download_message_file, which an agent could easily confuse it with.

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

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

With no annotations, the description carries the full burden. It discloses that the operation is a read of one's own account and lists the returned fields, but says nothing about authentication prerequisites, error behavior, or rate limits. Adequate but shallow for an unannotated 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 compact sentence that front-loads the action and resource and parenthesizes the returned fields. Every element earns its place with no filler.

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

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

For a zero-param read with no output schema, listing the returned fields (name, MID, status message) compensates for the missing output schema. Only error and auth behavior are unaddressed, which is minor for this simple operation.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly adds nothing about parameters, and the field list refers to output, not input.

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

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

States a specific verb (ดู/view) and resource (โปรไฟล์บัญชี LINE) and enumerates the returned fields (ชื่อ, MID, ข้อความสถานะ). It is clearly distinct from the sibling update_my_profile via the read verb, though it never names that sibling 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 'ของเรา' (our own) implies this fetches the authenticated user's profile, which is useful implied context, but there is no explicit when-to-use or when-to-prefer-an-alternative guidance.

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

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

No annotations are provided, so the description must carry the full burden. It usefully discloses the non-blocking, immediate-return behavior and the 'since starting to listen' buffer window, but says nothing about auth requirements, return format, or how the clear flag interacts with subsequent reads.

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 the core action and key behavioral trait (non-blocking) front-loaded. No filler or redundancy.

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

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

For a read-only buffer-drain tool with no output schema and fully documented parameters, the description covers the essential behavior (non-blocking, buffer scope). Return values need not be described, but auth/return-shape details are left unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (clear, chatMid). The description adds only indirect context via the 'since starting to listen' framing and does not elaborate on parameter syntax or effects beyond what the schema provides.

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

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

States a specific verb (ดึง/retrieve) and resource (ข้อความใหม่/new messages) and adds scope ('since starting to listen'). The parenthetical 'ไม่รอ คืนทันที' (non-blocking, returns immediately) implicitly contrasts with the sibling wait_for_message, giving some differentiation, though it does not name that sibling.

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 clear usage context ('use to check if anyone replied while you were away'), which implies when to reach for it. However, it names no explicit alternative (e.g., wait_for_message) and gives no when-not guidance, so usage is only implied.

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

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

With no annotations provided, the description carries the full disclosure burden. It usefully states the result set (private + group chats) and the ordering (most recent conversation first), but says nothing about pagination, auth requirements, or whether the list is scoped to the authenticated user.

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, zero padding, with the resource and its scope front-loaded and the ordering constraint appended compactly.

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

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

For a simple, parameter-light read tool with a fully documented schema and no output schema, the description covers what is returned and how it is ordered. Only pagination/scope details are missing, which is a minor gap rather than a blocking one.

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

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

Schema description coverage is 100% and the single 'limit' parameter (with default 30) is fully documented in the schema. The description adds no further meaning about the limit or how it interacts with recency ordering, so the baseline 3 applies.

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

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

States a specific verb and resource ('ดึงรายชื่อแชท' = list chats) and scopes it precisely to both 1-on-1 and group chats, sorted by latest conversation. This is enough for an agent to distinguish it from get_chat_messages or list_friends, though no sibling is named 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?

Usage is only implied: an agent can infer this is the entry point for enumerating a user's conversations, but there is no explicit when-to-use framing, no statement of when to prefer get_chat_messages or list_friends instead, and no prerequisites.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose the returned fields (MID, status message), which is useful, but says nothing about whether the operation is read-only (only implied by 'list'), how many friends are returned, whether results are paginated or truncated, or whether auth is required.

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

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

A single compact sentence that front-loads the verb and resource and adds the return payload without filler. Every clause 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?

No output schema and no annotations, so the description must carry everything; it names the returned fields, which helps, but omits pagination/limit behavior and auth or permission requirements. Adequate but with clear gaps for a list endpoint that could return an unbounded set.

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

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

Schema description coverage is 100% and the single optional 'search' parameter is documented in the schema (กรองชื่อเพื่อนที่มีคำนี้). The description adds no information about the filter syntax or matching behavior (partial vs exact, case sensitivity), so the baseline 3 applies.

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

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

States a specific verb (ดึง = fetch) plus the resource (รายชื่อเพื่อนทั้งหมดในสมุดรายชื่อ LINE) and even names the returned fields (MID, status message). It is clear the agent can distinguish it from get_my_profile or rename_friend, though it never explicitly contrasts itself with sibling list tools such as list_chats.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as searching or filtering by other criteria. The agent must infer that this is the tool for enumerating contacts versus listing chats.

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 behavioral burden. It usefully discloses the returned payload, including the non-obvious inclusion of invited-but-not-accepted members and the creator's MID, but says nothing about permissions/auth requirements or read-only safety.

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 covering verb, resource, scope, and return contents with no wasted words. Slightly under-specified on usage rather than verbose, but structurally 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?

For a simple single-parameter read tool, the definition covers the action, the target, and the returned fields (which compensates for the absent output schema). Missing only auth/permission context, a minor gap for a read operation.

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

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

There is only one parameter (chatMid) and schema description coverage is 100%, so the schema already documents it fully (MID of the group, starting with 'c'). The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific verb (ดึง = retrieve) and resource (รายชื่อสมาชิก = member list) scoped to a group, and even names what is returned (MID, group creator, pending invitees). It is distinguishable from siblings like list_chats and list_friends by resource, though it does not explicitly name any alternative.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as list_friends or list_chats. The use case is only inferable from the resource noun, 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 exist, so the description carries the full burden, and it delivers the two facts that matter most: the rename is device-local, and the friend's real name is unaffected. It also discloses reversibility via the empty-string reset. It omits auth/permission requirements and error behavior, so it is strong but not exhaustive.

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

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

A single tight sentence with three clauses, ordered as purpose → scope → reset mechanism, so the most important information is front-loaded. The parenthetical analogy is a small luxury but earns its place by clarifying intent. No filler.

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

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

For a simple two-required-parameter tool with no nested objects and no output schema, the description covers purpose, side effects, and the reset path. The only real gap is not telling the agent where to obtain userMid and what happens on an invalid MID, which is minor at this 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 coverage is 100% — both newName and userMid already carry Thai descriptions including the empty-string reset semantics. The description restates the same empty-value behavior rather than adding new meaning. Baseline 3 is correct when the schema does the heavy lifting.

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

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

The description states a specific verb + resource (setting a friend's display name) and immediately scopes it: the change is local to the caller's device and does not alter the friend's real name. That scope detail differentiates it from any server-side profile tool, though it never explicitly names a sibling. Clear and specific, just short of the 5 bar that requires explicit sibling differentiation.

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

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

Usage is implied rather than stated: the analogy '(like editing a friend's name in the app)' and the instruction to pass an empty value to restore the original name give a hint of the gesture. However, it never says when to prefer this tool, nor where the required userMid comes from (e.g., list_friends), and there are no exclusions. Implied usage only.

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

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

With no annotations, the description carries the full behavioral burden and does not disclose size limits, auth/permission requirements, whether the file is uploaded or referenced by URL, synchronous behavior, or failure modes. It only adds the filePath/fileUrl exclusivity, which is closer to parameter semantics than behavior. For a mutation 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?

One dense sentence plus a short constraint clause, front-loaded with the action and resource and with zero filler. Every element earns its place.

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

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

For a write/send operation with no annotations and no output schema, the definition covers the minimum (target chatMid, source choice, supported types) but omits limits, error behavior, and what happens on success. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so baseline is 3, but the description goes beyond the schema by asserting that filePath and fileUrl are alternatives and that one is needed — the schema marks neither as required, so this adds genuine meaning. It does not explain syntax or precedence when both are supplied.

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 (send) and resource (file) and enumerates supported types (PDF, Word, Excel, ZIP, video, audio), which distinguishes it from send_message and send_image in the sibling list. It does not explicitly name those siblings as alternatives, so it stops short of a 5.

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

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

The clause 'specify either filePath or fileUrl' gives a real selection rule for the two source parameters, but there is no guidance on when to use this tool versus send_image, send_message, or download_message_file, nor any stated prerequisites or constraints.

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

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

With no annotations, the description carries the full behavioral burden, yet it only says what is sent and from where. It is silent on authentication requirements, whether the local file is uploaded or read remotely, size/format limits, failure modes, and whether the recipient must already be a contact or member of the chat.

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 carrying the action, the target, and the parameter constraint with no filler or repetition.

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

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

For a simple three-parameter tool with no annotations and no output schema, the description covers the action and the source modes adequately. It remains thin on behavioral expectations (delivery result, error conditions) that an agent would need when the call fails or the image is rejected.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds a genuine semantic constraint absent from the schema: the two optional source parameters are alternatives ('one of the two'), which cannot be derived from the property definitions alone.

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: send an image to a chat room or individual recipient, which is clearly distinct from text messaging or non-image file sending. However, it does not explicitly contrast itself with the sibling send_file, which plausibly also transmits binary content, so sibling differentiation is only partial.

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

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

The description gives one concrete usage rule — supply either filePath or imageUrl, not both — which is implied mutual exclusivity. It offers no guidance on when to pick this tool over send_file or send_message, so tool-selection context must be inferred 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 supplied, so the description carries the full behavioral burden, and it discloses nothing beyond the basic action: no permission/auth requirements, no rate limits, no statement about whether the send is idempotent, whether the recipient must already be a contact/friend, or what happens on failure. For a mutation tool with zero annotation coverage this is a notable gap.

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

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

A single short sentence with no filler, front-loaded on the verb and resource. Nothing is wasted.

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

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

For a two-parameter mutation with no output schema and no annotations, the description is minimally viable but thin: it omits delivery semantics, failure modes, and constraints an agent would want before sending. Adequate rather than 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% and both parameters are documented in the schema, so the baseline is 3. The description adds only the mild clarification that chatMid may be a room or a person, and gives no format details (e.g. MID syntax, message length limits, plain text vs markup).

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?

Names a concrete verb ('ส่งข้อความ' = send a message) and resource (message) plus the target envelope (chat room or person), which is more than a restatement of the name. It does not explicitly say how it differs from the adjacent send_image/send_file siblings, so it stops short of a 5.

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

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

No when-to-use, when-not-to-use, or alternative is given. With siblings like send_image, send_file, and wait_for_message present, the agent gets no explicit routing guidance beyond the implicit 'text message' distinction.

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 notes a required user confirmation, which is a useful behavioral trait, but omits other important details such as permanence of changes, authentication requirements beyond the implicit user context, rate limits, or what happens if only one field is provided. With no annotations, this is a significant gap.

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

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

The description is a single sentence for the action plus a short pre-condition sentence. It is concise and front-loaded with the tool's purpose. No wasted 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 mutation tool with no annotations and no output schema, the description should provide more behavioral context such as side effects, permissions, or error conditions. It mentions the confirmation requirement but leaves many agent-relevant details unaddressed, making it incomplete for safe invocation.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (character limits, default behavior). The description simply restates the two parameters without adding syntax, format, or edge-case details beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

States a specific verb (เปลี่ยน = change) and resources (displayName, statusMessage) of one's own LINE account. Distinguishes from sibling get_my_profile (read vs update) and rename_friend (friend vs self). The specific fields make it clear what is updated, though it doesn't explicitly name 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 explicitly states a pre-condition ('ต้องยืนยันกับผู้ใช้ก่อนเปลี่ยน' = must confirm with user before changing), which is useful usage guidance. However, it doesn't list when to use this tool versus alternatives or any other exclusions; the usage is only implied by the context of a profile update.

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 max wait time (50 seconds) and that it can be called repeatedly, which are useful behavioral traits. However, it doesn't mention rate limits, authentication requirements, or what happens on timeout (e.g., empty response), leaving key operational details unspecified.

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 (in Thai) that front-loads the core purpose and includes key constraints. It avoids waste, though the addition of 'call again if no message' is somewhat redundant with the real-time waiting concept.

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 complexity (long-polling mechanism) and lack of output schema, the description should explain the return format or timeout behavior more thoroughly. It covers the basics but misses important context like what happens if the wait times out or how messages are returned, leaving gaps 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?

Schema description coverage is 100%, so the schema already documents both parameters (chatMid and timeoutSec with defaults and max). The description adds little beyond repeating the optional chatMid filter and 50-second limit already present in the schema.

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

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

The description states a clear verb+resource: waiting for new LINE messages in real-time, returning messages that arrive during the wait. It distinguishes itself from siblings like get_new_messages and get_chat_messages by emphasizing the real-time waiting behavior and optional chatMid filter. However, it doesn't explicitly name an alternative tool to avoid confusion with get_new_messages.

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

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

The description implies usage by mentioning 'call again if no message yet' and optionally specifying chatMid to wait for a specific room. However, it does not state when to use this versus get_new_messages or get_chat_messages, leaving the agent to infer from the sibling names.

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