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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds behavioral context beyond annotations by explaining the priority chain (per-user override, OA Manager vs API-built menus) and listing the return fields. No contradiction with annotations.

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 sentences. It front-loads the key diagnostic question and then lists the return fields in a structured format. Every sentence adds value without 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?

Given no output schema, the description covers the return structure adequately. It addresses purpose, usage context, and behavioral logic. Minor gaps: error cases or prerequisites (like OA token) are not mentioned, but overall it's sufficient for a read-only diagnosis 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 has 2 parameters: oa (string, not required, no description) and user_id (required, minLength, described). Schema coverage is 50%. The description mentions passing user_id and explains its role, partially compensating for the missing oa description. However, oa remains unexplained, limiting parameter clarity.

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 purpose as diagnosing why a user sees a specific menu. It specifies the verb 'Diagnose', the resource 'rich-menu priority chain', and distinguishes itself from sibling tools like line_link_rich_menu and line_set_default_rich_menu by focusing on auditing/debugging.

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

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

The description explains when to use the tool via the diagnostic question 'why is user X seeing menu Y?' and mentions the priority chain logic. It does not explicitly state when not to use it or list alternatives, but the context is clear enough for an agent to infer its diagnostic role.

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?

Beyond annotations (non-readOnly), the description reveals indexing delay (~5-10 min), status in list endpoint, user_id limit, and region restrictions. No contradictions.

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

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

Concise, front-loaded with purpose, followed by timing, limits, region, return format, and example. 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?

Covers key aspects: purpose, behavior, limits, region, return format. With no output schema, it explains returns. Lacks prerequisites but acceptable.

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 high (75%). Description repeats user_ids limit and is_ifa usage, and adds region context for 'oa'. Does not add new parameter details beyond 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 tool creates a LINE audience by uploading user IDs or IFAs, specifically for the CSV-to-retargeting-audience flow. It distinguishes from sibling 'line_build_audience_from_engagement' by focusing on user IDs.

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 context on when to use (uploading IDs from CSV, retargeting), indexing time, and region gating. Lacks explicit contrast with siblings but is clear enough for an agent to infer.

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 indicate mutation and non-idempotency; description adds critical behavioral constraints (age requirement, minimum user count, region gate) and explains return format, going beyond annotation hints.

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

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

Three sentences: front-loaded purpose, then key details, then return format. No redundant words; each sentence adds value.

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

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

Given 5 parameters and no output schema, the description covers purpose, parameters, constraints, integration, and return format, making it fully self-contained for an agent.

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

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

Schema covers 60% of parameters with descriptions; the description adds context for source_request_id (linking to prior message) and type (specifying default and click_url filter), though 'oa' parameter is not explained.

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 purpose: 'Create a LINE audience from people who clicked or opened a previous broadcast/narrowcast' and differentiates it from sibling tools like line_build_audience_from_csv by specifying the engagement source.

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 explicit guidance: when to use (retarget without CRM), constraints (source message ≥24h old, needs ~50+ users, region-gated), and how to integrate (feed audience into line_send_message).

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

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

Annotations indicate a mutation tool (readOnlyHint=false, destructiveHint=false). The description adds context: it mentions the internal workflow (validate → create → upload image → set as default), the critical domain switch for image upload, and constraints like image requirements and the 1,000-menu limit. No contradictions with annotations.

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 paragraph with clear front-loading of purpose. Each sentence contributes useful information, though it could be slightly more structured (e.g., bullet points for constraints). 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?

Returns values are specified ({ rich_menu_id, name, set_as_default, warnings[] }) despite no output schema. Constraints (image size, aspect ratio, file size) and limits (max 1,000 menus per OA) are provided. Input parameters are covered by the schema, but the description adds 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?

Schema description coverage is 88%, so the schema already documents most parameters. The description adds minor detail (e.g., 'must fit inside the image bounds' for areas) but largely restates schema info (image_url constraints, size dimensions). 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 verb 'Create' and the resource 'LINE Rich Menu', distinguishing it from the sibling tool line_design_rich_menu_image which renders images from labels. The title also specifies 'single panel' for precise scope.

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

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

The description explicitly tells when to use ('single-panel menus only') and when not to, directing users to line_design_rich_menu_image for alternate image generation. It also explains the advantage of collapsing 4 API calls.

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 indicate readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable context beyond annotations: it warns in Thai when less than 7 days remain, describes the 401 error scenario, and clarifies the return shape. No contradictions found.

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 with no wasted words. It front-loads the main purpose and provides all necessary details in a few sentences. Every sentence adds value, making it highly efficient for agent understanding.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description fully covers the input, behavior (thai warning, error handling), and return shape. Annotations cover safety. No gaps remain for an agent to use this tool correctly.

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

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

The only parameter (oa) has a schema description stating it's optional and defaults to active OA. The tool description does not add further parameter-level semantics beyond what the schema already provides, so baseline 3 applies.

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

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

The description clearly states it verifies the active OA's channel access token and reports bound client_id, remaining lifetime, and granted scope. This purpose is unique among siblings (no other tool checks token validity), so it effectively distinguishes itself.

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

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

The description explicitly advises running before a campaign to avoid silent failure from mid-send expiration. It also explains the 401 error for invalid/expired tokens. However, it lacks explicit guidance on when not to use this tool or mention of alternatives, which would elevate to 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?

The description adds that the action is irreversible and requires confirm=true, which goes beyond the annotations. The annotations already indicate destructiveHint=true and readOnlyHint=false, and the description confirms the destructive nature. It also discloses the return format {success, deleted_id}, adding behavioral context the annotations lack.

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: two sentences that front-load the key action and provide essential details without redundancy. Every word serves a 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 deletion tool, the description adequately covers the purpose, required parameter source, confirm flag, and return format. No output schema exists, but the return snippet clarifies what to expect. The description is complete enough for an agent to use the tool correctly.

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

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

With schema description coverage at 0%, the description must illuminate parameters. It explains audience_group_id (numeric, from line_list_audiences) and highlights the confirm parameter's necessity. However, the 'oa' parameter is left unexplained, and the description does not fully compensate for the missing schema descriptions.

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

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

The description starts with 'Delete an audience group', clearly stating the verb 'delete' and the resource 'audience group'. It distinguishes from sibling delete tools like line_delete_rich_menu by specifying 'audience'.

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 notes that confirm=true is required and that audience_group_id comes from line_list_audiences, providing clear usage context. However, it does not explicitly state when not to use this tool or mention alternatives (e.g., line_update_audience), which would strengthen the 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?

Annotations already indicate destructive and write operations. Description adds specific side effects: silent breaking of user links, the need for confirm flag, and return shape. This goes beyond annotations, though idempotency is not discussed.

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

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

Three sentences, no fluff. Nearly every word adds value. Sentences are well-ordered: action, requirement, side-effect/alternative, return. Front-loaded with key info.

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

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

Despite no output schema, the description covers return format, side effects, and prerequisite. Missing explanation of 'oa' parameter, but overall complete for a simple deletion tool with good annotations.

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

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

Schema coverage is low (33%). The description adds context only for 'confirm' (guards against prompt drift) but does not explain 'oa' or 'rich_menu_id' beyond what schema provides. The return value is mentioned but not parameter semantics.

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

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

The description clearly states 'Delete a rich menu by ID' and distinguishes it from siblings like build, list, audit, and link tools. The purpose 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?

Provides explicit when-to-use: requires confirm=true. Warns against using when menu is linked to users without auditing, and suggests alternative tool line_audit_user_menu. Excellent 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds further transparency by stating 'DESIGN ONLY — never calls the LINE API' and describing the validation and return format. There is no contradiction with annotations, and the description provides useful behavioral context beyond the safety hints.

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

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

The description is well-structured with bullet points and an example, making it easy to parse. It front-loads the key message about design-only and JSON return. While it is somewhat long, the content is valuable and organized. Minor improvement: could be slightly more concise, but overall 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?

Given 7 parameters (2 required) and no output schema, the description covers the important aspects: return format ({ message, usage_hint }), key constraints per kind, and an example. The only gap is the lack of detail on the 'usage_hint' field, but overall it provides sufficient context for an AI agent to use the tool correctly.

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

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

The input schema covers 100% of parameters, but the description adds significant value by explaining the different kinds (buttons, confirm, etc.) and their specific constraints (e.g., text length limits, action count rules). It also clarifies the required fields per kind and the expected structure of actions. This goes beyond mere schema listings.

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 purpose: to build a validated LINE Template message (card message) and return JSON for use with line_send_message. It emphasizes it is design-only and never calls the LINE API, distinguishing it from sibling tools like line_send_message that actually send 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 explains when to use this tool: to design a card message before sending it via line_send_message. It provides explicit constraints per kind (e.g., buttons, confirm) and notes that the tool is design-only. While it contrasts with line_send_message, it does not explicitly mention other alternative methods (e.g., manual JSON construction), but the guidance is still clear.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds rich behavioral context: it validates, never calls the LINE API, returns a structured response with preview_url, size_bytes, and warnings[], and warns about the 30KB bubble limit. It also notes Thai localization of templates. These details go well beyond what annotations provide.

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

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

The description is well-structured and front-loaded with purpose, then modes, usage, return format, and an example. Every sentence contributes information without fluff. The length is justified by the tool's complexity, and the example aids comprehension without redundant 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?

With no output schema, the description explicitly lists the return fields (flex_json, alt_text, preview_url, size_bytes, warnings[]) and notes the 30KB limit. It explains the two modes, provides integration steps with line_send_message, and includes a Thai-language example. The only omission—detailed required fields per template—is addressed by the list_templates mode, making the description complete for practical use.

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

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

Schema coverage is 100%, providing a baseline of 3, but the description adds significant value by grouping parameters into modes (template+data, flex_json+alt_text, list_templates), reinforcing mutual exclusivity, and giving a concrete example with template data fields. This helps the agent understand parameter combinations beyond the schema's individual descriptions.

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

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

The description opens with a specific verb+resource: 'Compose a validated Flex Message for line_send_message.' It clearly distinguishes itself from siblings like line_design_imagemap and line_design_card by focusing on Flex Messages, and explicitly states 'DESIGN ONLY — never calls the LINE API,' differentiating it from line_send_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?

It provides explicit guidance on when to use each mode (template mode recommended, raw mode advanced, list_templates for catalog), and explains how to integrate with line_send_message via message.flex_json or direct template/data passthrough. The 'DESIGN ONLY' note clarifies that this tool is not for sending, addressing when-not-to-use.

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

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

Annotations already mark this as read-only and idempotent, but the description adds substantial behavioral detail beyond that: 'never calls the LINE API,' returns a { message, usage_hint } shape, validates the output, forces canvas width to 1040, and explains the hosting behavior with LINE's lack of upload API. It fully discloses the tool's side-effect-free, design-only nature and its integration with image preparation.

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 moderately long but well-structured, opening with the core purpose, then hosting paths, constraints, return value, and examples. It front-loads the most critical info (design-only, never calls API) and includes two examples that are compact and illustrative. Some repetition with schema details exists (e.g., the /1040 size variants), but the examples and flow explanation justify the length.

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

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

This is a complex tool with two hosting modes, coordinate constraints, optional video, and integration with other tools. The description covers all of these, including the return value shape (not provided by any output schema), the recommended workflow via line_prepare_image, and the fact that LINE has no upload API. It is complete enough for an agent to select and invoke the tool correctly without missing context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond individual field docs by explaining the relationship between prepared_key and base_url/base_height, the two mutually exclusive hosting paths, and the coordinate system (all px on a 1040-wide canvas). The illustrative example shows how to combine alt_text, areas, and either prepared_key or base_url, giving the agent a concrete usage template.

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

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

The description states a specific verb and resource: 'Build a validated Imagemap message' and 'return it as JSON to hand to line_send_message via message.message_json.' It clearly distinguishes itself from siblings like line_send_message and line_design_flex by noting it only designs and never sends. This makes the tool's purpose unambiguous and distinct.

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 offers explicit guidance on when to use this tool vs alternatives: it says 'DESIGN ONLY — never calls the LINE API,' implying sending should go through line_send_message. It also gives a recommended vs self-hosted path, explicitly telling the agent to run line_prepare_image first when possible, and when to choose base_url instead. This is clear, actionable 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?

The description discloses key behavioral traits beyond the annotations: 'auto-deletes the orphaned menu on any post-create failure', 'LINE caps the PNG at <1MB (gradients auto-flatten to solid once)', and 'brand auto-corrects label contrast for readability'. These are important for an agent to understand side effects and constraints. No contradiction with annotations.

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

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

The description is well-structured with a clear overview, workflow steps, template table, important notes, and an example. It is concise without being terse, and every sentence adds value. There is no repetition of schema information that is already clear from the input 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?

Given the tool's complexity (9 parameters, nested objects, multiple modes, no output schema), the description is remarkably complete. It covers all modes, templates, parameter relationships, deployment behavior, and return values. The example at the end ties everything together, leaving no significant 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?

While schema coverage is 100%, the description adds significant meaning: template enumeration with visual descriptions (e.g., '3×2 grid, 6 equal cells — the classic LINE OA menu'), explanation that cells[] length must equal template's cell count, and that per-cell action is required only for deploy. The example further clarifies usage. This goes well 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 tool's purpose is clearly stated: 'Design a professional LINE rich menu PNG from labels alone'. It distinguishes itself from sibling tools by explaining it is a pure-JS renderer requiring no design tool or headless browser, and mentions optional deployment. The description makes it easy to understand what the tool does and how it differs from related tools like line_build_rich_menu or line_upload_rich_menu_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?

Explicit workflow guidance is given: 'ALWAYS preview first: mode="preview" (default) returns the PNG as an image block — LOOK at it, iterate with the user, then call again mode="deploy"'. It also explains when to use save mode and deploy mode, and provides template descriptions. This helps the agent decide when and how to invoke the tool.

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 already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds meaningful behavioral details: it explains the cost formula (message_count × recipients), how recipient counts are derived for different target types, and that results are unknown for filter/everyone. This goes beyond the annotations without contradicting them, though it omits potential edge cases like quota exhaustion behavior.

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

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

The description is three well-structured sentences that front-load the primary purpose. Each sentence adds value: the first states what it does, the second explains the key input semantics, the third discloses output format. No word is wasted, and the formatting is easily scannable.

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

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

The description covers the essential aspects: purpose, usage context, parameter nuances, and return format. It even mentions the recommended alternative for a specific case. Given the rich schema for target and the explicit output shape, the description is fully adequate for the tool's complexity. Sibling tools are effectively differentiated.

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 low (33%), but the description compensates significantly. It explains that 'target uses the same shapes as line_send_message' and clarifies the semantic meaning of message_count ('LINE charges message_count × recipients'). It also describes how the target type affects the accuracy of recipient estimation. The 'oa' parameter is not explained, but the description still adds substantial meaning beyond the schema.

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

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

The description opens with a specific verb+resource: 'Estimate how many quota messages a planned send will consume, without sending.' It clearly distinguishes itself from the related sibling line_send_message, which actually sends messages. The purpose is unambiguous and includes the key qualifier that it is for estimation only.

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 when to use this tool ('before confirmation, especially for narrowcast/broadcast') and when not to ('without sending'). It also provides an alternative for an unsupported case: for filter/everyone targets, it recommends line_send_message dry_run instead. This gives the agent clear decision 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?

Annotations already declare readOnlyHint/idempotentHint=true and destructiveHint=false. The description adds useful behavioral context beyond annotations: the curated catalog scope, the limitation to LINE's official sticker list, and the return object shape. No contradiction with annotations is present.

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

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

The description is highly concise and front-loaded: the first sentence states the core purpose, the second adds usage context, and the third provides the return structure. There is no filler or redundant repetition of schema fields, making every sentence valuable.

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

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

Despite lacking an output schema, the description provides the exact return shape and integration guidance with line_send_message, covering the main invocation context. The only notable gap is the lack of detail about 'limit' and 'response_format' behavior, but the tool is otherwise sufficiently described for selection and invocation.

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

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

Schema description coverage is 33%, with only 'query' having a schema description. The description reinforces query semantics with Thai/English examples and intent-based matching, but it does not explain 'limit' or 'response_format', both of which lack schema descriptions. It partially compensates but leaves parameter behavior under-specified.

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 action: 'Find LINE stickers from a curated catalog by mood or keyword.' It specifies the resource (LINE stickers) and distinguishes itself from sibling tools by emphasizing intent-based selection and returning package_id/sticker_id for use with line_send_message, which no other sibling 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 explains when to use the tool ('Bots may only send stickers from LINE's limited official list, so this picks by intent... instead of guessing IDs') and the next step ('Pass the chosen package_id + sticker_id to line_send_message via message.sticker'). It does not explicitly list alternative tools or exclusions, but no sticker-search sibling exists, so the context is clear.

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

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

The description discloses that LINE has no dedicated redemption endpoint and that the tool 'combines signals', including account-dependent behavior ('some accounts include usage inline'). It also prominently warns about the proxy nature of click-audience size, which is critical behavioral context. The description adds value beyond the annotations (readOnly, idempotent) without contradicting them.

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 information-dense but appropriately structured: purpose, mechanism, caveat, and return shape. It is longer than the minimal example but every sentence adds value, including the caveat and return object. A slight reorganization could make it more skimmable, but it remains efficient and front-loaded.

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 output schema and moderate complexity, the description is very complete. It specifies the return shape ('Returns { coupon_id, raw, click_audience?, estimated_redemptions?, notes[] }'), explains the data source, covers the caveat, and provides an alternative path for exact counts. It also links to line_manage_coupon for coupon_id, making the tool self-contained.

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 only 25% (only click_audience_id has a description). The description adds meaning for coupon_id ('comes from line_manage_coupon') and click_audience_id ('enrich the stats with click-through count'), but it does not explain 'oa' or 'response_format', leaving gaps. Given low schema coverage, the description partially compensates but is not fully sufficient.

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 'Read available stats for a LINE coupon' with a specific verb and resource. It distinguishes from sibling tools like line_get_message_stats by focusing on coupons, and clarifies that it provides available stats rather than true redemptions. The scope ('for a LINE coupon') is precise, and the mention of coupon_id provenance further disambiguates.

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 explains when to use the tool (to read available coupon stats) and provides a clear when-not: 'click-audience size approximates clickthroughs, NOT actual redemptions'. It offers an alternative for real counts ('build the coupon Flex with a postback action and listen via webhook') and instructs that coupon_id comes from line_manage_coupon. This meets the explicit when/when-not/alternatives 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?

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral context beyond annotations: data lag, privacy thresholds, broadcast type restrictions, and the shape of the return object. No contradiction with annotations.

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 succinct, with two paragraphs. The first sentence states the core purpose, and the second paragraph adds caveats. Every sentence is informative with no fluff.

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

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

Given the tool has 3 params, no output schema, and annotations indicate safe read-only operation, the description covers all necessary aspects: what it does, the return object structure, important caveats (lag, privacy, broadcast types). It is complete for an agent to decide and 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 coverage is low (33%), but the description reinforces the meaning of request_id and its broadcast type requirement. It does not explain oa or response_format beyond what schema provides. Overall, the description adds moderate value to param understanding, but could be more explicit about optional 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 it fetches per-broadcast engagement stats for a request_id, listing specific metrics (impressions, opens, clicks, CTR, per-URL click breakdown). It distinguishes from siblings by specifying it's for a prior line_send_message, which is unique among the listed LINE tools.

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

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

The description provides explicit caveats: ~24h data lag, stats stable at T+1; returns null for privacy below ~20 users; only for narrowcast/multicast/broadcast. It also directs to use request_id from a prior line_send_message. This gives clear when-to-use and when-not-to-use 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?

Annotations already mark it read-only, open-world, idempotent, non-destructive. Description adds polling behavior and return phase details, confirming safe usage.

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 well-structured sentences with front-loaded purpose, zero wasted words, includes return field sketch.

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, but description compensates with a pseudo-schema of return fields and phase enum values. Fully adequate for agent invocation.

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

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

Schema coverage is 100%, so baseline 3. Description adds meaning: request_id comes from prior send, oa defaults to active OA.

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?

Clearly states it polls delivery progress of an async narrowcast, naming the endpoint and distinguishing from sibling tools like line_send_message which initiate sends.

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?

Implicitly instructs to use after a narrowcast send that returns a request_id. No explicit when-not-to, but the context is clear.

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

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

Beyond the annotations (readOnlyHint, destructiveHint, idempotentHint), the description adds critical behavioral details: data lags T-2, a privacy floor of ~20 users, and that demographics require enough consented friends. These are not captured by annotations and significantly help an agent understand data limitations.

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 just three sentences. It is front-loaded with the main purpose, then covers parameter details, behavioral caveats, and the return structure. Every sentence adds value without 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?

Given there is no output schema, the description's outline of the return fields ('oa_id, range, delivery{total,daily[]}, followers, demographic_available, quota, notes[]') is sufficient. It also explains key data limitations. The tool has moderate complexity (3 params), and the description covers essential context for use.

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

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

The description provides rich context for the 'range' parameter, including all preset strings, default, and custom object format. This compensates for the schema's 33% description coverage. However, it does not describe the 'oa' or 'response_format' parameters, though the response_format is partially covered by mentioning markdown report and the return structure.

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 it is a 'Digest of LINE OA performance over a date range' and specifies it bundles 8+ API calls into a Thai-friendly report. This differentiates it from sibling tools like line_get_message_stats or line_list_followers, which provide individual metrics. The verb 'get' and resource 'report' are specific.

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

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

The description explains the date range parameter and its formats, including presets and custom ranges, and provides defaults. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it. The usage is implied but not guided with exclusions or alternatives.

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 already declare the tool as read-only and idempotent. The description adds detail on aggregating 4 API calls and specifies the return structure with fields like health status and warnings, which provides transparency beyond annotations.

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

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

The description is three sentences, each serving a clear purpose: stating the tool's function, providing usage guidance, and detailing the return structure. 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?

Despite lacking an output schema, the description provides a complete return structure and explains how the tool aggregates multiple calls. It fits well within the sibling tool set as a standalone health check.

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?

Input schema coverage is 100% with descriptions for both parameters. The description does not add further semantic detail beyond what the schema already provides, meeting the baseline expectation.

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

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

The description clearly defines the tool as a quick health check aggregating friend count, monthly quota usage, webhook status, and current default rich menu into one call. It is distinct from sibling tools like line_get_oa_report or line_audit_user_menu, as it provides a high-level status overview.

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 recommends using it as the first call of a session because quota and webhook state inform later decisions. It gives clear context but does not list specific exclusions or alternatives.

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 already declare readOnlyHint, idempotentHint, destructiveHint. Description adds failure behavior context (ambiguous 404) and return structure, going beyond annotations. No contradictions.

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: first states purpose, second states usage conditions and return type. No wasted words, information is front-loaded.

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?

Describes return shape and failure behavior, but does not explain the 'oa' and 'response_format' parameters. With 3 parameters and no output schema, the description should cover all parameters to avoid confusion.

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 33% (only user_id described in schema). The description mentions user_id but adds no new info beyond the schema. Two parameters (oa, response_format) are not addressed in the description, leaving their purpose unclear.

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 'Fetch a LINE user's profile' with specific fields (display name, picture, etc.). The tool is distinct from siblings which are about rich menus, sending messages, and other LINE management tasks.

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?

Explicitly states conditions: user must have added the bot, not blocked it, and consented. Also explains failure behavior (404 returned as Thai explanation). Does not name direct alternatives, but sibling tools are clearly different.

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 already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context beyond annotations by explicitly stating 'READ-ONLY — never starts a tunnel or downloads anything', reinforcing the safety profile and disclosing the specific side effects it avoids. It also outlines the return shape ({ providers, tunnel, store }). This is more than minimal, though it stops short of deep behavioral details like error scenarios.

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 paragraphs, with the first paragraph front-loading the purpose and components, and the second providing usage guidance and return shape. Every sentence carries informational weight; there is no redundant or filler content. It is efficiently structured.

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

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

For a read-only status tool with no parameters and no output schema, the description covers the necessary essentials: what state it reports, when to use it, and the top-level return keys. It could optionally detail the nested structure of providers/tunnel/store, but the absence of an output schema makes the current level of detail acceptable. The sibling context and annotations round out the completeness.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%. Per the guidelines, a baseline of 4 is appropriate. The description does not need to explain parameters; it instead focuses on what the tool inspects and returns, adding value beyond the empty 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 opens with a specific verb-resource pair: 'Report the Image Hosting Layer's current state'. It enumerates concrete components (provider, tunnel, store) and explicitly names the sibling tool line_prepare_image, distinguishing this diagnostic tool from the action-oriented prepare tool. This is a clear, unambiguous purpose.

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

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

Provides explicit trigger scenarios: 'Use when line_prepare_image fell back to handoff, a verify failed, or the user asks "why can't it host automatically?"'. This gives the agent direct guidance on when to select this tool and implicitly contrasts with line_prepare_image's role, satisfying the 'when' and 'alternatives' 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?

The description adds context beyond annotations: explains auto-chunking of user_ids into batches of 500, the return format including linked_count/unlinked_count, and the fact that rich_menu_id is required for link only. This is consistent with the idempotentHint=true and destructiveHint=false annotations.

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, well-structured, and front-loaded. It starts with the core action, provides context, then parameter details, return shape, and an example, all in efficient language.

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 adequately describes the return object. It covers all parameters, the mode concept, the sibling tool distinction, and the bulk chunking, making it fully informative.

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?

Even though schema coverage is 100%, the description adds crucial meaning: clarifies that user_id and user_ids are alternatives not both needed, explains the auto-chunking behavior, and specifies that rich_menu_id is required for link and ignored for unlink.

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 attaches or detaches a rich menu for specific LINE users, using 'link' and 'unlink' modes. It distinguishes itself from the sibling tool line_set_default_rich_menu, which sets the account-wide 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 explains when to use this tool (per-user menu override) and when not (for account-wide default, use line_set_default_rich_menu). It also explains the effect of unlinking, providing clear 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral detail: it explains status meanings (READY usable, IN_PROGRESS wait ~10 min, FAILED, EXPIRED need recreate) and how filtering/pagination works. No contradictions with annotations.

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

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

The description is dense but well-organized, starting with the tool's core purpose, then statuses, filters, and return format. Every sentence adds value with no filler. The structure is logical 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?

The description covers filtering, pagination, status meanings, and the response structure (shows JSON-like format). However, it does not explain the 'oa' parameter (which OA to use) or the 'response_format' parameter (though the response structure is shown). With no output schema, the description does a good job but could be more explicit about input parameters.

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 67% (4 of 6 parameters have descriptions). The description adds meaning for status_filter (enum values clarified) and name_contains (case-insensitive), and explains pagination via limit/page. However, the 'oa' parameter is not explained in either schema or description, which is a gap. Overall, it adds useful context 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 tool lists audience groups on the OA, including those created via OA Manager UI. It distinguishes from siblings by noting that some audiences (chat-tag, friend-path, web-traffic) cannot be created via Messaging API, which differentiates this list-only tool from audience creation tools.

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

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

The description provides context on when to use this tool (listing audiences, including those from OA Manager) and explains filtering by status and name. However, it does not explicitly state when not to use it or suggest alternative tools for creation or deletion, leaving some ambiguity for an AI 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?

Beyond annotations (readOnlyHint, destructiveHint), the description discloses region-gating, pagination with continuation_token, page_size limits, and the return format. No contradictions with annotations.

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

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

Very concise: three sentences that front-load the main action, cover gating, pagination details, and alternatives. 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?

Complete coverage for a paginated read tool: purpose, when to use, region/tier restrictions, pagination mechanics, return shape (JSON object), and alternative tool. No output schema needed given the description.

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

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

The schema has only 25% description coverage. The description adds useful info for page_size and continuation_token, but the 'oa' parameter is not described, and the response_format default ('markdown') conflicts with the described return format (JSON object). Partial compensation.

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

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

The description clearly identifies the tool's purpose with a specific verb ('page through') and resource ('every user that has added the OA as a friend'). It distinguishes from siblings by mentioning an alternative for large OAs and specifying region/tier restrictions.

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?

Explicit guidance on when to use this tool vs. alternatives: 'For very large OAs (50k+), prefer an engagement audience via line_build_audience_from_engagement over pulling all IDs.' Also notes region and tier gates.

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 already declare readOnlyHint=true and idempotentHint=true, confirming no destructive side effects. The description adds context about the data source (config file or env mode) and the return structure (active_oa, oas array with fields), going beyond annotations. No contradictions.

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: two sentences plus a line showing return format. It is front-loaded with the core purpose and usage hint, with 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?

Given there is no output schema, the description includes a return structure, which is helpful. It also explains the data source. For a simple list tool with one optional parameter, it is reasonably complete, though it could mention that response_format controls output style.

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

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

The only parameter, response_format, is self-explanatory from the schema (enum with default). However, with 0% schema description coverage, the description should compensate by explaining its effect, but it does not mention the parameter at all. The agent must rely solely on the schema, which is sufficient but not enhanced.

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 lists all LINE Official Accounts available to the MCP instance, specifying the context (multi-OA or single-OA mode). It distinguishes itself from siblings by indicating it should be called before line_use_oa to discover OA IDs.

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 advises to call this tool before line_use_oa to discover OA IDs, providing clear when-to-use guidance. However, it does not mention when not to use it or alternatives, preventing a higher score.

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

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

Annotations already confirm read-only, idempotent, and non-destructive nature. Description adds return structure and cap warning, providing additional behavioral context beyond annotations.

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

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

Three sentences: purpose, usage guidance, return format. Front-loaded with the verb, resource, and key details. No redundancy or fluff.

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

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

Covers purpose, usage, and return format adequately for a list tool, but lacks parameter-level descriptions (oa, response_format). Without an output schema, the return format description helps, but parameter ambiguities reduce completeness.

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

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

Schema has 0% description coverage. Description does not explain the 'oa' parameter or the 'response_format' parameter, leaving their semantics unclear. The return structure description indirectly implies output, but parameters are not elucidated.

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' and the resource 'rich menus on an OA' and adds the specific task of identifying the default. It distinguishes from sibling tools like line_delete_rich_menu and line_build_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?

Provides explicit guidance: run before line_build_rich_menu to avoid the 1,000 cap and before line_delete_rich_menu to clean up. Does not include exclusions or when not to use, but context is clear.

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

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

Description states discontinue is 'irreversible' and requires confirm, but annotations have destructiveHint=false. This contradiction creates confusion for the agent, resulting in a score of 1 per evaluation rules.

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?

Well-structured with bullet points and examples; every sentence adds value without redundancy. Front-loaded with core purpose and modes, then details and examples logically follow.

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?

Covers all key aspects: modes, parameter details, side effects (irreversible), rate limit, integration with sibling tools, and includes examples for common use cases. No gaps despite lack of output schema.

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?

Adds significant meaning beyond the input schema: explains default discount type, required fields for explicit mode, date format handling, and provides concrete examples that map friendly inputs to API expectations.

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 explicitly states 'Coupon CRUD on a LINE OA' and enumerates four modes (create, list, get, discontinue), distinguishing it from sibling tools that handle rich menus, audiences, or messaging.

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

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

Provides clear guidance on when to use each mode, includes an example for discontinue requiring confirm, and directs to line_send_message for delivery, effectively differentiating from alternatives.

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

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

The description adds valuable behavioral context beyond the annotations: mode-specific parameter requirements, the confirm guard for delete, and the auth token limitation. It does not describe return values or error semantics, but at least it flags the confirm requirement and token ownership issue.

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

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

The description is compact and front-loaded with the core purpose. It lists modes, highlights key requirements, includes an auth note, and ends with a concrete example. Each sentence adds value without 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 description covers mode mechanics and parameter requirements, but lacks any mention of return values or response format, which is significant given there is no output schema. It also does not explain the optional 'oa' parameter or behavior when omitted, leaving some gaps for a complex CRUD 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?

With only 40% schema coverage, the description compensates by mapping each mode to its required parameters (e.g., create requires config.view, update requires liff_id + partial config, delete requires liff_id + confirm=true). The concrete example further clarifies how config maps to a real request.

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 explicitly states 'LIFF app lifecycle CRUD' and enumerates all four modes (create, list, update, delete) with specific parameter requirements. This clearly distinguishes it from other LINE management tools that handle rich menus, audiences, or 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 gives clear context for each mode, specifying required parameters (e.g., 'create needs config.view {type,url}', 'delete (liff_id + confirm=true)') and includes an auth caveat for separate-channel setups. It does not explicitly reference alternative tools, but the mode guidance is sufficiently actionable.

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

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

The description adds significant context beyond annotations: it explains the tab-switching mechanism, that delete only removes the alias not the menu, and that create/update require rich_menu_id. It also clarifies the non-idempotent nature (modify) and does not contradict any annotation.

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

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

The description is well-structured with clear sections for modes, parameters, return values, and an example. It is slightly verbose but every sentence adds value. The use of Thai example is helpful but could be omitted for brevity.

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

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

Given the tool's complexity (4 parameters, 5 modes) and no output schema, the description fully covers the return format for each mode and provides a complete example. It leaves no major gaps for an AI agent to understand invocation and expected outcomes.

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%, but the description adds meaning by stating parameter rules (alias_id required except list, rich_menu_id required for create/update) and explaining the role of each mode. It also clarifies that 'oa' is optional and defaults to active OA.

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 it manages rich menu aliases for tab-switching, with specific verb+resource (CRUD on aliases). It distinguishes from sibling tools by focusing on alias management rather than menu building or linking.

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

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

The description explains when to use each mode (create, update, delete, get, list) and specifies required parameters per mode. It provides practical guidelines but does not explicitly contrast with sibling tools for when-not-to-use.

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

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

Annotations are minimal (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false). The description goes far beyond by disclosing the provider chain, auto-teardown on failure, handoff package fallback, keep-alive behavior tied to LINE's fetch-on-first-view timing, and the guarantee that 'NEVER claims false success'. This is rich, non-redundant 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 long but every section serves a purpose: a one-sentence overview, provider chain rationale, critical timing caveat, return contract, and a step-by-step example. It is well-structured with clear paragraph breaks and front-loaded with the most important 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?

Despite lacking an output schema, the description fully explains the return shape (prepared_key, provider, base_url?, etc.) and failure behavior. It covers operational nuances like process lifetime, NAT traversal, and handoff instructions, making the tool actionable in real-world scenarios.

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%, but the description adds substantial value beyond the schema: warns base64 can silently corrupt and produce blank images, recommends file_path, explains Google Drive/Dropbox link rewriting for source_url, and contextualizes keep_alive_hours against the LINE fetch timing. This genuinely helps the agent choose the right input.

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

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

The description opens with a specific verb + resource: 'Make any image sendable to LINE with ZERO hosting knowledge' and details the exact pipeline (resize, host, verify, return prepared_key). It clearly distinguishes this tool from sibling tools like line_design_imagemap and line_send_message, which consume the prepared_key.

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 explicit usage context: the tool exists because LINE lacks an upload API, and gives a concrete workflow example (ส่งรูปนี้เป็น Rich Message → prepare → design → send). It names the downstream tools that accept prepared_key, effectively guiding when to use this vs alternatives.

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

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

The description discloses key behaviors: error isolation per OA, parallel concurrency limits, and return structure. These go beyond the annotations, which already declare read-only and idempotent. No contradictions with annotations.

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

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

The description is well-structured with bullet points and an example, but it is slightly verbose. It front-loads the main action and key constraints, 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?

Given the tool complexity (4 parameters, no output schema), the description covers purpose, parameters, behavior, return format, and example. It is self-contained and aids 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 description adds significant context to parameters: it lists supported tools, specifies defaults for oa_ids and parallel, provides concurrency range, and gives an example. Schema description coverage is 75%, but the description compensates fully.

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

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

The description clearly states the tool's purpose: run a read-only line_* tool across multiple OAs in parallel. It distinguishes from sibling tools by specifying it's a batch runner for supported read-only tools, and lists those tools 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 description explains when to use this tool (running read-only tools across many OAs) and includes an example. However, it does not explicitly advise against using it when a single OA result is needed, relying on implicit understanding that individual tools are for single OAs.

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 minimal (readOnlyHint=false, openWorldHint=true), so the description carries the burden and delivers: auto-pick behavior, reply token expiry, quiet-hours warnings, Quota Guardian blocking, and per-mode return shapes. This far exceeds annotation-only knowledge and sets accurate expectations.

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?

Though long, the description is well-structured with clear sections: purpose, modes, safety, returns, and an example. Every sentence adds critical operational detail, and the key purpose is front-loaded.

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

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

Even without an output schema, the description explicitly outlines the return shape for send_now and mentions draft/dry_run shapes. It covers prerequisites, safety, error-avoidance behaviors, and downstream stats timing, making it thoroughly complete for a tool of 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 coverage is 100%, so baseline is 3, but the description enriches parameter semantics by explaining the mapping from target shapes to API types and from message shapes to content types. It also ties confirm, force, quiet_push, and mode to real-world behaviors, adding value beyond schema descriptions.

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

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

The description opens with 'Universal LINE sender' and immediately explains the auto-pick logic for API and message type, which is specific and clear. It also differentiates from siblings by referencing line_design_*, line_manage_coupon, and line_prepare_image as inputs for this tool.

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

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

Explicitly tells when to use draft (for scheduling, because Messaging API can't schedule) versus send_now and dry_run. Includes safety guidance about quota, quiet-hours, and broadcast confirmation, plus references line_get_message_stats for narrowcast follow-up.

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 already indicate idempotentHint=true and destructiveHint=false. Description adds that setting a new default replaces the previous one (implied by 'set or clear'), but does not explicitly state that. Still sufficient for a non-destructive, idempotent 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 sentences with clear front-loading. Every sentence provides essential information without redundancy. Very 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?

Given the tool's simplicity, good annotations, and full schema coverage, the description covers purpose, modes, prerequisites, return format, and relation to sibling tool. No gaps.

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

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

Schema coverage is 100%, baseline 3. Description adds value by clarifying mode behavior ('set' needs rich_menu_id, 'clear' ignores it) and the optionality of oa. Provides more context than schema descriptions 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?

Description clearly states the tool sets or clears the account-wide default rich menu and explains its scope (shown to every follower without per-user menu). It distinguishes from sibling line_link_rich_menu by mentioning override behavior.

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?

Description explicitly covers both modes ('set' and 'clear') and their prerequisites (rich_menu_id required for set). It also notes that per-user links override the default, guiding when not to use this tool for per-user customization.

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 indicate idempotent and non-destructive behavior. The description adds that it makes PUT/GET requests and returns { endpoint, active } after a set, which gives the agent behavioral context beyond annotations.

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 wasted words. The first sentence front-loads the purpose and endpoints, and the second provides key details and a sibling reference.

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

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

Given no output schema, the description explains the return format. It covers both modes and references the sibling tool. Slight lack of error handling details, but sufficient for this simple tool.

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

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

Schema coverage is 100%, but the description reinforces constraints (HTTPS, ≤500 chars) and explains the mode parameter's effect. It adds value by clarifying the 'endpoint' requirement only for '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 it reads or writes the webhook URL, specifies the API endpoints, and distinguishes between the two modes ('set' and 'get'). It also mentions the sibling tool line_test_webhook, providing context for its 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?

Explicitly states when to use 'set' (requires a public HTTPS URL ≤500 chars) and when to use 'get'. It also explains how it complements line_test_webhook, guiding the agent on a typical workflow.

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?

Goes beyond annotations by detailing the LINE server's verification process (200, timeout, signature), error reasons (INVALID_REPLY, UNAUTHORIZED, etc.), and timeout of 10s. Annotations only indicate idempotency and non-destructiveness; the description adds rich 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?

Two concise sentences plus a clear return structure line. All information is front-loaded and every sentence adds value. No redundant or vague phrasing.

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

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

Given 2 parameters, no output schema, and good annotations, the description fully covers purpose, usage, behavior, parameters, and return values. The agent can select and invoke this tool correctly without additional 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 description explains the 'override_endpoint' parameter explicitly ('test a URL other than the configured one'). The 'oa' parameter is implied by context ('Ping the OA's webhook URL') but not defined in the description. Schema coverage is 50% due to the undocumented 'oa', so the description partially compensates.

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 it pings the OA's webhook URL and reports HTTP status and latency, with specific checks by LINE. This verb+resource combo is distinct from all sibling tools, which focus on other LINE 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?

Explicitly says 'Use this FIRST whenever a bot stops responding, before debugging anything else.' This provides clear when-to-use guidance and implies it's the initial diagnostic step. No alternative tool exists among siblings for this specific task.

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?

Discloses return structure per mode, example usage, and that LINE will reject non-upload audience mutations. Annotations already indicate mutation (readOnlyHint=false) and no destructiveness, so description adds context beyond annotations.

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?

Well-structured with two paragraphs and example. Front-loaded with main purpose. Every sentence is informative, though example could be slightly more compact.

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

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

Despite no output schema, description specifies return types per mode. Covers behavioral nuances (read-only audiences) and provides example. Sufficient for 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 coverage is 100%, but description adds value by linking audience_group_id to line_list_audiences, explaining required parameters per mode, and providing an example that clarifies usage patterns.

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?

Explicitly states 'mutate an existing LINE audience group' with two specific modes. Distinguishes from sibling tools like line_list_audiences and line_delete_audience by focusing on mutation rather than listing or deletion.

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

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

Provides clear when and when-not to use: only for Messaging-API-created upload audiences; audiences from OA Manager UI are read-only. Also tells where to get the audience_group_id (from line_list_audiences).

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 already indicate readOnlyHint=false, idempotentHint=true, destructiveHint=false. The description adds context beyond annotations: it details the download-and-upload process, the SSRF guard, the validation of JPEG/PNG and <=1MB, the domain switch, and the return format. This extra info helps an agent understand side effects and requirements, though rate limits or authentication details 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 two short sentences plus a one-line example. Every sentence is informative and earned its place. The purpose is front-loaded, and the structure is efficient with 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?

Given the tool is a mutation with no output schema, the description covers key aspects: what it does, constraints (public URL, format, size), what is preserved (richMenuId, tappable areas), and the return values. The example adds practical context. It is mostly complete, though error scenarios are not addressed, but the core is well-covered.

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

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

Input schema has 100% description coverage, so each parameter is already documented. The description does not add new semantic meaning beyond what the schema provides; it only reiterates the validation rules for image_url. With full schema coverage, a score of 3 is appropriate as no extra value is contributed by the 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 tool replaces the image on an existing rich menu without recreating it, preserving richMenuId, tappable areas, and per-user links. This specific verb+resource combination distinguishes it from siblings like line_build_rich_menu (which creates a new menu) and line_design_rich_menu_image (which designs images).

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 advises when to use this tool: to replace an image on an EXISTING rich menu, and implies that if you need to change layout or other aspects, you should use different tools. It also mentions the SSRF guard and domain switch, guiding users on prerequisites (public HTTPS URL, valid format and size). The example further clarifies 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?

Annotations include idempotentHint=true and no destructive hint. Description adds that the change is only in-memory and persistent only for the session, which is valuable beyond annotations. It also specifies the return value.

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?

Extremely concise: two sentences clearly stating purpose and behavior, plus a return description. No unnecessary words. Front-loaded with the main action.

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 state-switching tool with one parameter, the description covers the action, side effects, parameter source, and return value. It is complete for the complexity level, though could note error handling briefly.

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

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

The only parameter oa_id has 100% schema coverage with a description stating it comes from line_list_oas. The tool description repeats this but adds no extra meaning. 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 tool switches the active LINE OA for subsequent calls, using the verb 'switch' and specifying the resource 'active OA'. It distinguishes from siblings like line_list_oas which lists OAs.

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

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

The description explains when to use: to set the default OA for all following tools. It provides important context like in-memory only and the source for oa_id (from line_list_oas). Does not explicitly exclude scenarios but is clear enough.

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