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

No annotations are provided, so the description carries the full burden for a destructive operation. It never says the deletion is irreversible, whether related riders/claims are affected, what authorization is required, or what the response confirms – the 'terminated only' precondition is the single behavioral fact conveyed.

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

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

A single front-loaded sentence with no filler, but its brevity comes from omission rather than efficiency. For a destructive mutation tool this is under-specification, not concision.

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?

An output schema exists, so return values needn't be explained, but a three-parameter destructive tool with a security PIN input and zero annotations needs far more: authorization context, reversibility, side effects, and the meaning of 'pin'. The description supplies none of this.

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 0% across three parameters, and the description names none of them. user_id and policy_id can be inferred from the tool name, but the optional 'pin' parameter (nullable, default null) is completely unexplained in both schema and description, leaving an opaque security-sensitive 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 states a specific verb and resource ('해지한 보험 계약을 삭제합니다' – deletes a terminated insurance contract) and adds a real scoping constraint that only terminated/cancelled contracts qualify. It doesn't refer to the tool's own name (user policy vs insurance contract) or distinguish it from siblings like list_user_policies or register_user_policy, but the intent is unambiguous.

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

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

The only guidance implied is that the contract must already be terminated, which is useful but incomplete. There is no statement of prerequisites, permissions, when to choose deletion over alternatives, or what to do if the policy is still active.

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

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

With no annotations, the description carries the full burden. It discloses one valuable behavioral trait — claim data is never stored, stated twice (Korean and English) — but says nothing about whether this is a pure calculation vs. a submission, what the pin requirement means, permission/auth needs, or behavior on unrecognized codes.

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 short and front-loaded: purpose first, then the plan-specific field list, then the privacy note. The Korean and English sentences are near-duplicates, which is acceptable localization rather than waste.

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?

An output schema exists, so return values need no explanation, and the privacy note plus US field guidance cover the essentials. Still, for a nested-object input with 12+ claim fields and no annotations, the description leaves the non-US path and most cost/classification fields unexplained.

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?

Description enumerates six US-plan fields, which genuinely adds meaning by grouping them per plan type (icd10 vs kcd_code). But at 33% schema coverage many fields go undocumented in both places — cost_covered, cost_uncovered, hospital_type, treatment_code/name, prescribed_drugs, pin — so it only 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?

Names a specific verb and resource — estimate insurance benefits from receipt/prescription data — which is unambiguous. It does not differentiate against siblings (register_user_policy, resolve_user_rider, etc.), though those are clearly a different family so confusion is unlikely.

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?

'US plans: send icd10_code, is_inpatient...' is a conditional input guideline that implies kcd_code is for the Korean path, which is useful. However, there is no explicit when-to-use/when-not-to-use statement, no prerequisite for user_id registration or the pin parameter, and no routing against sibling tools.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose one useful trait: for US_* policy types it returns an English schedule-of-benefits checklist. It does not state read-only/no-side-effects or any auth or rate-limit context, leaving gaps for a no-annotation tool.

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

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

Two sentences, front-loaded with the core return contents and then the US_* variant. Efficient, with no filler.

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

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

An output schema exists so return structure needn't be explained, and the US_* conditional is covered. However, with 0% schema coverage and zero annotations, the unexplained parameters and missing usage/precondition context leave the definition only minimally complete.

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

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

Schema coverage is 0%, so the description must compensate, but it only hints that policy_type drives output language/format for US_* values. product_name is never explained, and the enum values are uninterpreted, leaving most parameter meaning to be inferred.

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

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

The description states a specific verb+resource: it returns a list of securities/terms to request from the insurer, request wording, and official request channels. This is distinguishable from the user/profile/policy siblings, though it doesn't explicitly name an alternative 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?

There is no guidance on when to call this versus other guide-like tools (e.g. get_onboarding_guide) or what prerequisites exist. The only implicit condition is the US_* policy-type switch, which is about output rather than when-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?

No annotations exist, so the description carries the full burden. It discloses the return payload (onboarding procedure plus bound_user_id), which implies a read-only, side-effect-free call, but it never explicitly states read-only behavior, whether the guide is static or user-specific, or any auth/prerequisite requirements around bound_user_id.

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

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

Two tight sentences with zero waste, and the critical ordering instruction ('call first') is front-loaded ahead of the return-value note.

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?

An output schema exists and is flagged, so the description needn't enumerate return fields in depth; mentioning the procedure and bound_user_id is sufficient orientation. Combined with the entry-point guidance, an agent has enough to invoke it correctly, with only the user-scoping/statefulness question left implicit.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. The baseline of 4 applies: the empty schema is self-explanatory and the description correctly adds no parameter detail.

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

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

Names a concrete verb+resource (retrieves the onboarding guide) and states what it returns: the onboarding procedure and bound_user_id. The 'call first at service start' framing positions it as the entry point, which meaningfully separates it from siblings like register_user or get_user_profile, though it never names those siblings explicitly.

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

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

Gives clear positive guidance: call this first when starting the service. That is an actionable ordering instruction an agent can follow. It stops short of naming alternatives or stating when not to call it (e.g., after onboarding is already complete), so it is not a full 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?

No annotations are provided, so the description carries the full disclosure burden. '조회합니다' implies a read, but nothing is said about whether the operation is safe, whether the pin is required for authentication, or what happens when a user has no onboarding record. The presence of a sensitive 'pin' parameter with zero explanation is a notable disclosure gap.

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

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

A single compact sentence with no waste, but it is arguably under-specified rather than concise. There is no front-loaded statement of what the tool returns as a whole (a profile object) beyond the enumerated fields.

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?

An output schema exists, so return values needn't be spelled out, but the tool has two parameters with zero schema documentation and no annotations, and the description closes none of that gap. The unexplained 'pin' parameter alone makes the definition incomplete for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate and it does not — it never mentions user_id or pin. The 'pin' property (nullable string, default null) is particularly mysterious: is it a credential, an optional filter, or a legacy field? An agent cannot determine how or whether to supply it.

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

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

States a specific verb and resource ('조회합니다' = retrieve user profile) and enumerates the three data points returned: onboarding status, registered policy count, unmapped riders. That is far more informative than the bare name/title, but it makes no attempt to distinguish this from siblings like list_user_policies or list_standard_rules, which overlap in subject matter.

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

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

No guidance on when to call this versus the ten sibling tools, no prerequisites, and no exclusions. The agent must infer from the tool name alone that this is the profile-summary entry point while list_user_policies is the detailed-policy 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?

With no annotations, the description carries the full behavioral burden, and it does disclose one meaningful trait: `verified` is False until checked against policy text, warning the agent about data trustworthiness. It does not otherwise state that this is a safe read-only listing or comment on result size/caching, so the disclosure is partial.

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

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

Two short sentences, front-loaded with the action and followed by a single high-value caveat about the `verified` field. No waste.

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?

An output schema exists, so return values needn't be explained, and the zero-parameter signature is simple. However, the description never clarifies what 'standard' rules are relative to the user-policy siblings or confirms read-only semantics in the absence of annotations, leaving a modest gap for an agent routing between the two list tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is also 100% regardless.

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

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

States a specific verb and resource ('Return the standard coverage rules'), which is enough to distinguish it from mutation siblings like register_user_policy. It stops short of explicitly contrasting with list_user_policies, so the 'standard' vs 'user' distinction is left implicit.

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

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

There is no statement of when to use this tool versus alternatives, no preconditions, and no exclusions. The agent must infer from the name that this is the no-argument baseline-rules lookup.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a genuine behavioral constraint — only '활성' (active) contracts and riders are returned, not terminated ones — which is real information beyond the name. However, it says nothing about authorization, what the pin parameter implies for access, or any limits.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient to the point of under-specification, but nothing in the text wastes space.

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

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

The output schema exists, so return values need not be described. But with no annotations, 0% parameter coverage, and an unexplained optional pin, a two-parameter retrieval tool needs more than one sentence to be safely invocable.

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 0% across two parameters, so the description must compensate and largely fails. '사용자의' hints at a user identifier, but the pin parameter — optional, nullable, defaulting to null — is never explained at all, leaving the agent to guess whether it gates access or is a verification secret.

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

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

The description states a specific verb (조회합니다 = retrieve) and a specific resource (사용자의 활성 보험 계약 및 특약 = the user's active insurance contracts and riders), adding the rider dimension that the name 'policies' does not convey. It is clear enough to distinguish from mutation siblings like register_user_policy or delete_user_policy, though it never names them.

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

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

The description offers no when-to-use context, no prerequisites, and no mention of the related siblings (e.g. list_standard_rules, resolve_user_rider, get_user_profile). An agent must infer from the name alone that this is the read path for per-user policy data.

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

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

No annotations are provided, so the description carries the full burden. It implies a persistent write ('등록합니다') but never states permission requirements, behavior when user_id already exists, whether the operation is idempotent, or what happens to the returned record — significant gaps for a creation tool with zero annotation coverage.

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

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

Two short sentences with the primary action front-loaded and no filler. It is tight, though the brevity contributes to the documentation gaps noted elsewhere rather than being purely a virtue.

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?

An output schema exists, so return values need not be explained, but with four undocumented parameters, no annotations, and no sibling differentiation, the definition leaves an agent unable to call this tool confidently beyond supplying a user_id and a 4-digit PIN.

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 0%, so the description must document all four parameters. It adds real meaning only for 'pin' (minimum 4 characters, should not collide with others), while user_id, birth_year, and display_alias receive no explanation of format, validation, or purpose.

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

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

The description names a specific verb and resource ('신규 사용자를 등록합니다' – register a new user), which is clearly distinct from siblings like register_user_policy or update_user_rider. It does not explicitly route away from those siblings, but the creation scope is unambiguous.

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

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

There is no guidance on when to use this tool versus register_user_policy or the onboarding guide tools, and no mention of prerequisites such as whether the user must not already exist. Usage must be inferred entirely from the tool name.

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

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

No annotations exist, so the description carries the load. It does disclose a real behavioral rule: calculations only apply when both the contract and riders are POLICY_CERTIFICATE. However, it never explains what 'update' does to an existing policy, what the replace_riders flag (default false) destroys, or whether the operation requires a PIN — significant gaps for a 12-parameter mutation with zero annotation coverage.

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 key facts (register/update, resolve_user_rider pointer) are front-loaded, but the entire content is duplicated verbatim in Korean and English, and the source_type rule is stated twice within the English block alone. Roughly half the tokens are redundant restatement.

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?

An output schema exists, so return values need no explanation. Still, for a mutation tool with no annotations and 12 parameters, the description leaves the overwrite/replace semantics and the meaning of several optional fields unresolved, so an agent could call it correctly structurally but not confidently behaviorally.

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 0%, so the description must compensate; it does partially, clarifying source_type, issuer, issued_on format, the US policy_type values, dollar amounts, and rule_config_override placement. But roughly half the parameters (pin, replace_riders, enrolled_year, silson_generation, coverage_amount units per rider) receive no explanation anywhere.

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

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

States a specific verb+resource ('보험을 등록하거나 갱신합니다 / Register or update a policy') and enumerates the US policy_type variants, so the agent knows exactly what resource is being created or modified. It does not distinguish itself from siblings like update_user_rider or register_user beyond one pointer to resolve_user_rider.

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

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

Gives a concrete routing rule: unmapped riders should be confirmed via resolve_user_rider first. It also conditions the source_type/issuer/issued_on combination on reading from a contract, which tells the agent when to supply those fields. No explicit when-not or exclusion against update_user_rider is given.

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

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

No annotations are provided, so the description carries the full burden for what is clearly a mutation that finalizes state. It says nothing about the effect on downstream calculation, whether re-resolution is allowed or destructive, why a 'pin' credential is required, or how MAPPED vs CUSTOM vs IGNORED differ in consequences. The only added behavior is that rule_config_override applies to POLICY_CERTIFICATE-sourced riders.

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 first sentence is front-loaded and waste-free. The second is dense and awkwardly punctuated, embedding a raw JSON example mid-sentence, and it explains the least-used optional parameter while ignoring the required ones.

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 an 8-parameter mutation with zero annotation coverage and no schema descriptions, the description is far too thin; an output schema exists so return values needn't be covered, but permissions, reversibility, and the role of most parameters are missing.

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

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

Schema coverage is 0% across 8 parameters, and the description explains only rule_config_override (with an example) plus, implicitly, the mapping_status enum. Six parameters — pin, user_id, rider_id, mapped_rule_id, coverage_amount, custom_rule_config — are undocumented in both schema and description, including the critical distinction between custom_rule_config and rule_config_override.

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 first sentence gives a specific verb+resource (confirm the mapping of an unmapped rider) and enumerates the three resulting statuses (MAPPED, CUSTOM, IGNORED). The scoping word '미매핑' (unmapped) partially separates it from sibling update_user_rider, though the distinction is implied rather than stated.

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

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

Usage is only implicitly scoped: the tool is for riders that are not yet mapped. There is no explicit guidance on when to call it versus update_user_rider, no prerequisites (e.g. that the rider must already exist for the user), and no exclusions such as re-resolving an already mapped rider.

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

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

No annotations exist, so the description carries the entire behavioral burden, yet it discloses almost nothing: not whether the change is reversible, not that a pin is a required authentication/verification credential, and not whether existing coverage is overwritten. It does at least signal a targeted mutation of one field on one record, which is marginally more than the tool name alone.

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

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

A single front-loaded sentence with no filler, which is efficient. The brevity is arguably under-specification rather than over-writing, so it is penalized under other dimensions, but the structure itself is clean.

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

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

For a mutating, likely authenticated operation (optional pin) with no annotations and zero schema description coverage, the description omits essentially all context an agent needs beyond the bare action. An output schema exists, so return values need not be explained, but the auth and side-effect story is absent.

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 0% across four parameters. The description implies coverage_amount and rider_id by naming the coverage amount of one rider, but says nothing about user_id scoping or the optional pin field, whose purpose (PIN verification for a sensitive mutation) is completely undocumented anywhere. With a 0% coverage schema the description should compensate, and it does not.

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

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

The description names a specific verb (가입금액을 변경합니다 – change the coverage amount) and a specific resource (특약 1건 – a single rider), so the agent knows exactly what operation is performed. It does not, however, differentiate itself from nearby siblings such as resolve_user_rider or register_user_policy, which an agent could plausibly confuse with a rider mutation.

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

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

There is no statement of when to use this tool versus resolve_user_rider or register_user_policy, no preconditions, and no exclusions. The only implicit guidance is '1건' (a single rider), which hints at single-record scope but does not route the agent among alternatives.

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