APICK Business

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely non-structured information: a per-call cost of 30 points and the 10-page review cap, both of which affect invocation decisions. It does not say how many reviews per page or whether results are paginated/sorted, keeping it below 5.

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?

Short and front-loaded: what it does, what it returns, defaults, and cost in that order. Minor waste from the English and Korean sentences largely restating each other, though the Korean version does add field detail (rating, price, genre).

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 exists, and the description does cover both halves of the return (app metadata fields and customer reviews), the cost, and the pagination limit. Missing only secondary details like reviews per page or ordering, which is acceptable for a simple 3-parameter read tool.

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

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

Schema description coverage is 100%, so page, appId and country are already documented with defaults and bounds in the schema. The description restates the same defaults (country kr, page max 10) without adding format, semantics or edge-case guidance, 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?

States a specific verb and resource ('Get iOS app metadata and customer reviews'), plus the keying mechanism ('by numeric app id'). The 'iOS' scope and 'reviews' payload clearly separate it from the many product/metadata siblings (amazon_product, coupang_product, youtube_metadata) without needing those names.

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

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

Usage is only implied: it describes defaults (country=kr, page up to 10) and cost, so an agent can infer this is a read call on a known App Store id, but there is no explicit when-to-use or when-not-to-use statement and no named alternative.

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 only declare readOnlyHint and openWorldHint; the description adds real behavioral context beyond them: the exact response sections (summary, distribution, competitors, low_rate, insights), the explicit exclusion of raw listings, and the cost of 50 points per call, which matters for a metered API.

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?

Front-loaded with the analysis scope, then the return shape, then the cost caveat. The English and Korean text largely mirror each other, but the Korean portion carries unique details (median rate, HHI, response keys, no raw list, pricing), so it is not pure duplication.

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 compensates by naming all five response sections and stating what is excluded. The remaining gap is pagination: pageNo/numOfRows are offered but it is unclear whether they paginate aggregates or are ignored, which is genuinely ambiguous for a statistics endpoint.

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

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

Schema description coverage is 100%, so the schema already carries parameter meaning (bizType enum with default, date formats, pageNo/numOfRows defaults). The description adds nothing about how date ranges or bizType scope the analysis, 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?

States a specific verb and resource ('Analyze Korean public-sector award results') and enumerates the concrete analyses: success-rate distribution/averages, winner concentration (HHI), and low-rate notices. The note that it returns no raw listings functionally separates it from a raw notice lookup, though the sibling bid_notice is never named.

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

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

Usage is implied by the 'no raw list provided' caveat, which tells the agent this is for aggregate statistics rather than enumerating postings, but there is no explicit when-to-use/when-not or a named alternative (e.g., bid_notice) for retrieving the underlying records.

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 establish readOnlyHint and openWorldHint, but the description adds genuinely non-structured context: the exact response sections (summary·distribution·deadlines·largest·insights), an explicit negative behavior (no raw notice list is returned), the implicit default filter, and a per-call cost of 50 points. That is substantive disclosure beyond the annotations, though permission/rate-limit or pagination interaction details are absent.

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

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

The key scope statement and the exclusion of raw listing are front-loaded, and the cost note is a tidy trailing marker. The full English-to-Korean duplication of the opening sentences repeats information without adding any, which slightly inflates 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?

With 7 optional parameters and no output schema, the description compensates by naming the return sections and the no-raw-list constraint, which is the most important thing an agent needs. The remaining gap is that it never says what date window applies when startDate/endDate are omitted.

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

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

Schema description coverage is 100%, so baseline is 3. The description restates the bizType default already documented in the schema and otherwise says nothing about how bidNtceNo, date ranges, or indstrytyCd interact with the aggregate analysis. It adds no 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?

States a specific verb and resource ('Analyze Korean public-sector bid notices') and enumerates the analytic dimensions: budget bands, agencies, industries, closing urgency, largest opportunities. It also explicitly distinguishes itself from a listing tool by stating '공고 원문 목록은 제공하지 않습니다'. It does not name the sibling tool (e.g., bid_award), which keeps it just short of a 5.

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

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

Provides useful default-behavior guidance ('bizType 을 생략하면 용역 공고를 분석합니다'), which tells the agent what happens when a key filter is omitted. However, it never states when to choose this tool over alternatives or which situations it is unsuitable for; the agent must infer the boundary with bid_award and other bid-related 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, covering safety and external data access. The description adds important behavioral context beyond annotations: a cost of '[호출당 50포인트]' per call and that financial_info=Y returns corporate financial data at no extra charge. It does not contradict the 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 purpose is front-loaded in the first sentence and the cost is placed last. The Korean sentence largely duplicates the English purpose, which adds length without new information for non-Korean readers, but the structure is otherwise 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?

With no output schema, the description usefully enumerates returned fields (대표자, 주소, 직원수, etc.) and covers cost and the optional financial_info behavior. It omits error-handling details beyond the financial_info case, but is otherwise complete for a simple read-only lookup.

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

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

Schema description coverage is 100%, and both biz_no format and financial_info behavior are fully documented in the schema. The description repeats financial_info=Y but adds no syntax or format details beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb ('Look up') and resource ('general status information of a Korean business'), keyed by the '10-digit business registration number', and lists returned fields. It does not explicitly differentiate itself from potential siblings such as venture_biz_info, so it falls short of a 5.

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

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

The description explains what the tool retrieves and what financial_info=Y does, but gives no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. Like the calibration example for update_drive, usage is only implicitly inferable from the purpose.

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 and openWorldHint, so the safety profile is covered. The description adds two things annotations cannot: a per-call cost of 30 points and the precedence rule that supplying PNU causes bunji fields to be ignored. Those are material behavioral facts for planning a call.

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 short sentences, front-loaded with the purpose and then the input requirement and cost. No filler or repetition, though the enumeration of ten register types is dense and could arguably be left to the enum.

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 14-parameter lookup with no output schema and read-only annotations, the description covers purpose, required inputs, type-scoping, and cost. It stops short of describing the shape of the returned register records, but the type enumeration and annotations make it usable as-is.

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

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

Schema description coverage is 100%, so the schema already documents all 14 parameters including type-specific fields. The description restates the PNU (19-digit) vs sigunguCd·bjdongCd requirement but adds no format or syntax detail beyond what the schema 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?

States a specific verb (look up) and resource (Korean building register) and enumerates the ten register types matching the `type` enum, so the agent knows exactly what is returned. It does not name any sibling to contrast with, but the resource is distinct enough from tools like registry_realestate_search or land_rt_price to avoid confusion.

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

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

The description gives the required input combination (PNU or sigunguCd·bjdongCd) and the address-based path, which is genuine usage context. However, it never says when to prefer this over alternatives such as registry_realestate_search or land_rt_price, so selection guidance is only implied.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds meaningful behavioral context: it explains that the tool performs MX lookups and disposable-domain detection, and it discloses the per-call point cost. This goes beyond the schema and annotations 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 compact, front-loaded with the action and purpose, and includes a cost note. The bilingual repetition is justified given the Korean title and likely user base, and no filler or unnecessary detail is present.

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

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

For a one-parameter tool with readOnlyHint and openWorldHint annotations, the description provides enough information to select and invoke it correctly. The only minor gap is that the return value format is not described, but this is mitigated by the clarity of the validation checks listed.

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

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

Schema description coverage is 100%, and the schema already documents the single 'email' parameter with an example. The tool description adds general context about what is validated but does not add new parameter-level detail 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 names a specific verb ('Validate') and a precise resource (email), and enumerates the exact checks performed: syntax, MX availability, and free/disposable domain status. This clearly distinguishes it from sibling tools like check_phone_valid or check_spam_number.

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

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

The description makes the tool's context clear: use it when email deliverability/validity checks are needed. However, it does not explicitly mention when not to use it or name alternative tools, so the usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds genuinely new behavior: it returns a formatted/normalized number plus carrier and line-type analysis, and it discloses a per-call cost of 40 points. Missing is what happens on an invalid number (error vs. negative result), which would complete the picture.

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?

Front-loaded and short, with the useful cost tag at the end. The Korean sentence largely restates the English one, which is redundant for an agent, though it may be an intentional localization choice.

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 must carry the return contract, and it only names three of the outputs without structure or error behavior. Adequate for a single-parameter lookup, but the return semantics remain underspecified.

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

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

Schema description coverage is 100% and the single parameter's format (domestic 010..., overseas +country code) is already documented in the schema. The description adds no syntax or constraint beyond that, so the baseline 3 applies.

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

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

States specific verbs (validate, format) plus the resource (phone number) and the extra outputs (carrier, line type), so the agent knows exactly what it gets. It is implicitly distinct from check_email_valid and check_spam_number by resource, but it never names a sibling to sharpen the boundary.

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

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

The description says what the tool does but never states when to choose it over alternatives or any prerequisites. No guidance on when-not to use it, or how it relates to check_spam_number, which also concerns phone numbers.

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 show readOnlyHint and openWorldHint, which cover safety and openness. The description adds useful behavioral context: the Korea-specific reported-data scope and a cost signal of 10 points per call. It does not contradict the 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 key action is front-loaded and the cost note is clear. The Korean sentence restates the first English sentence, making it slightly redundant, but overall the description remains short and 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?

For a one-parameter, read-only lookup with no output schema, the description supplies enough context: purpose, domain, usage examples, and cost. It does not spell out the response shape, but 'Check whether' strongly implies a boolean-style report.

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

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

Schema description coverage is 100%, with the 'number' parameter already documented and exemplified. The description itself adds no new parameter semantics, so the baseline of 3 applies.

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

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

The description opens with a specific verb and resource: 'Check whether a phone number has been reported for spam, advertising, or criminal use in Korea.' This clearly identifies the tool's purpose and semantically distinguishes it from nearby siblings such as check_phone_valid, which would address phone-number validity rather than report history.

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 explicit use context: '수신 전화 필터링, 이상 거래 탐지 등에 사용합니다' (incoming call filtering, abnormal transaction detection). It does not state exclusions or name an alternative tool, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is free. The description earns credit by disclosing the cost model ('[호출당 50포인트]') and by enumerating the derived metrics returned, which annotations do not cover. It stops short of stating data freshness, failure behavior, or return shape, so 4 rather than 5.

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: the first front-loads the verb, resource and identifying inputs; the second enumerates output content and cost. Nothing is padded, though the bilingual duplication (English action line + Korean detail line) costs a little compactness. The cost tag is well placed at the end.

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 4-parameter tool with 100% schema coverage and no output schema, the description covers inputs, returned statement set, derived ratios and per-call cost — enough to call it correctly. Gaps are minor: no guidance on missing-data behavior or on what 'all' produces versus a single statement section.

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 crno format, the type/scope enums and the bizYear default are all documented in the schema. The description only restates the crno+year pairing at a high level and adds no format, edge-case, or defaulting information beyond it. 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 states a specific verb and resource ('Get a company financial package') and enumerates exactly what is included: 요약재무제표, 재무상태표, 손익계산서, plus computed 부채비율·영업이익률·ROA·ROE and growth rates. This clearly separates it from generic business-lookup siblings, though it never names a sibling it should not be used in place of.

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

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

Usage is implied: call it with a 법인등록번호 and optional year to obtain statements and ratios. There is no explicit when-to-use/when-not, no mention of alternatives such as biz_detail or venture_biz_info, and no prerequisite guidance, so the agent must infer the boundary itself.

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?

Adds genuinely useful behavior beyond the readOnlyHint/openWorldHint annotations: a missing case returns result 0·count 0 rather than an error, and the call is not billed in that case. It also discloses cost ([호출당 60포인트]). However, it says nothing about auth requirements, rate limits, or response shape, so the addition is solid but 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?

The English purpose sentence is front-loaded and the field list is compact. The Korean sentence largely re-states the English with the field enumeration, so there is some bilingual redundancy, but nothing is padded or wasted.

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

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

For a 2-parameter read-only lookup with no output schema, the description covers purpose, returned data fields, empty-result semantics, and per-call cost — enough to call it correctly. The main residual gap is not saying what the caller needs (auth/key) or how court names are matched.

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 both parameters are already documented in the schema (court as name-or-code, case_no with year/부호/number format). The description only restates '사건번호와 법원(이름·코드)' without adding syntax, format, or validation detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb+resource (look up a Korean court auction case) plus the identifying keys (case number, court) and enumerates the returned fields (기본정보·매각기일·감정평가액·최저매각가격·진행상태). It is clearly distinguishable from the bid_award/bid_notice siblings by domain, but it never names or contrasts 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?

Usage is only implied: an agent infers it should call this when it has a 사건번호 and a 법원. There is no explicit when-to-use, no prerequisites (e.g., which court codes are valid), and no routing away from related tools like bid_award or bid_notice.

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 openWorldHint=true, so the safety profile is covered. The description adds genuine behavioral context beyond that: it merges road-name and jibun result sets and ranks by match score, and discloses a per-call cost ('호출당 10포인트'), which is valuable for call planning.

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?

Front-loaded with the core behavior, then usage context, then cost tag. Each sentence carries distinct information with no filler, though the English and Korean sentences partially duplicate the same core statement.

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 does the work of conveying what comes back (ranked, merged road/jibun candidates) and the usage context. Combined with read-only/open-world annotations and a fully documented schema, an agent has enough to call it correctly; only minor gaps like result shape specifics remain.

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 all three parameters (query, size with default/max, category enum) are already documented in the schema. The description's mention of merging road and jibun results loosely maps to the category enum but adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb (return ranked candidates), resource (Korean address candidates), and scope (partial input, merging road-name and jibun results). The 'partial input' and 'merging' framing distinguishes it from a plain full-query address lookup, though it never names a sibling like geo_address_search 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 Korean line '주소 입력 화면의 자동완성에 씁니다' gives a concrete usage context (autocomplete in address input screens), which implies when to use it. However, it offers no explicit when-not or alternative routing (e.g. use geo_address_search for complete queries), leaving the 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 already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds information the annotations do not carry: the output is an aggregation report (duplicate rate, district distribution) and each call costs 40 points. That billing disclosure is genuinely useful for agent planning; the lack of any note on batching or limits beyond the schema's 50 caps it at 4.

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 plus a bracketed cost tag, with the core action front-loaded and no filler. The language mixes English and Korean, which is efficient for a bilingual audience but slightly reduces scanability.

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?

There is no output schema, so the description carries the burden of explaining what comes back, and it does list the main report contents (duplicate rate, district distribution, unmatched addresses). Combined with 100% schema coverage and read-only annotations, an agent has enough to call it correctly; only the response shape (e.g. per-site grouping structure) remains 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?

Schema description coverage is 100% and all three parameters, including the enum for addrType, are documented in the schema. The description mentions 'unmatched addresses with alternatives', which loosely maps to includeSuggestions but adds no syntax or format guidance beyond what the schema already states. 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 states a specific verb and resource: group an address list into real sites and report duplicate rate, district distribution, and unmatched addresses. This is concrete and distinguishable in substance from geo_standardize or geo_address_search. It does not name or exclude any sibling, so it falls short of a 5.

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

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

The Korean sentence '여러 표기의 주소록을 지점 단위로 정리할 때 씁니다' gives implied usage: mixed-notation address books that need branch-level consolidation. However, it never names alternatives such as geo_address_quality or geo_standardize, nor any exclusions, so the agent must guess when this tool beats its neighbours.

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 and openWorldHint, and the description adds value beyond them: alternatives are only produced for addresses that fail, capped at a maximum of 3 candidates, and each call is billed at 30 points. These behavioral details (failure handling, result cap, cost) are exactly the kind of context annotations cannot carry.

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?

Front-loaded with the core purpose and kept short, with the cost note bracketed at the end. The English and Korean sentences largely restate each other, which is mild redundancy, but no sentence is wasted.

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

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

There is no output schema, so the description must convey the return shape, and it does: per-address scores, grades, and up to 3 alternative candidates for failures. For a 2-parameter read-only tool this is reasonably complete, though addrType's behavioral effect (auto/parcel/road) is left to the 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?

Schema description coverage is 100%, so both parameters (addrType enum and the addresses array) are already documented in the schema. The description adds only the notion of a "list" of Korean addresses and does not elaborate on addrType, 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?

Uses specific verbs (score, grade, suggest alternatives) against a specific resource (Korean addresses) with an explicit scope (validity and completeness). It is clearly an address-diagnosis tool, though it never explicitly contrasts itself with siblings like geo_standardize or geo_address_search, so it falls short of full sibling differentiation.

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

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

"고객 주소 데이터 정제에 씁니다" (used for cleaning customer address data) gives an implied usage context but no explicit when-to-use/when-not-to-use guidance and no naming of alternative tools such as geo_standardize or geo_address_autocomplete.

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?

Annotation hints (readOnlyHint, openWorldHint) set a low bar, and the description clears it by disclosing that road-name and jibun results are merged with duplicate removal, plus an explicit cost of 20 points per call — a rate limit/cost trait not captured by 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?

Purpose is front-loaded and the cost disclosure is well-placed, but the entire content is duplicated verbatim in Korean and English, doubling length without adding information. The bilingual repetition is a structural inefficiency.

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 carries the return-value burden and does so by naming the returned fields (standardized address, parcel number, region code, coordinates), and it adds cost and dedup behavior. Pagination is covered by the schema, so remaining gaps are minor.

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

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

Schema description coverage is 100%, so the schema already documents query, page, size, and the category enum (auto/road/parcel). The description adds no parameter-level detail such as query syntax or how category interacts with the merge behavior, 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?

States a specific verb (Search) and resource (Korean road-name/jibun addresses) plus the return content (standardized text, parcel number, region code, coordinates). However, it never distinguishes itself from close siblings like geo_address_autocomplete, geo_standardize, geo_place_search, or search_juso, so an agent cannot tell them apart from the description alone.

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

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

The description explains what the tool returns but gives no when-to-use, when-not-to-use, or alternative routing. With so many near-identical geo_* and address-search siblings, the absence of any selection guidance is a real gap.

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 and openWorldHint, so safety is covered. The description adds the useful cost trait ([호출당 20포인트]) and enumerates return fields, but says nothing about rate limits, accuracy behavior for ambiguous addresses, or error cases when neither address nor coordinates resolve.

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 core English sentence is front-loaded and efficient, but the content is then repeated verbatim in Korean and followed by an annotation sentence, roughly doubling the length. The point-cost note is relevant, but the duplication costs space without adding distinct 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?

With no output schema, the description usefully enumerates the returned fields (sido/sigungu/eupmyeondong/admin dong/lawdCd), which is exactly what an agent needs to interpret the response. It is less complete on input precedence (address vs. coordinates vs. point) and on how addrType affects results.

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

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

Schema description coverage is 100%, so all six parameters (x, y, point, address, addrType, includeZipcode) are already documented in the schema. The description only restates the address-or-coordinates duality and adds no syntax or precedence guidance beyond that.

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 (extract) plus the exact resource (administrative names and codes: sido, sigungu, eupmyeondong, admin dong, lawdCd) and the two input forms (address or coordinates). It is clear what the tool returns, though it never explicitly positions itself against close siblings like geo_reverse, geo_standardize, or geo_neighborhood.

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 usage signal is that lawdCd is the code used for 실거래가 (real transaction price) lookups, plus a per-call point cost. There is no statement of when to choose this tool over geo_reverse/geo_standardize/search_juso, nor any prerequisite or exclusion.

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 openWorldHint=true, so safety is covered. The description adds genuinely non-derived behavior: a per-call cost of 40 points, a hard 50-address batch cap, and default deduplication. These are operationally useful facts an agent cannot get from the schema or 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?

Front-loads the core action, then context, then cost, with each sentence earning its place. The bilingual English/Korean pairing is somewhat redundant, but it serves the provider's audience and does not bury the key 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?

There is no output schema, but the description compensates by describing the return shape (coordinates, lot number, administrative code) plus a success/failure summary. Combined with full schema coverage and disclosed cost/limits, an agent has nearly everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents addresses, dedupe, and addrType. The description restates the 50-item limit and deduplication, which overlaps the schema's own text, and adds no syntax or format detail for addrType. Baseline 3 is appropriate when the schema carries the load.

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

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

States a specific verb and resource (geocode a list of Korean addresses) and adds scope details: batch up to 50, deduplication, and a return of coordinates/lot numbers/admin codes with success-failure summary. The 'list at once' framing implicitly separates it from single-address geo siblings, but it never names an explicit counterpart tool, so it stops short of full differentiation.

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

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

The Korean clause '엑셀·DB에 쌓인 주소를 한 번에 정리할 때 씁니다' gives a clear use context (bulk cleanup of accumulated addresses). However, there are no exclusions or named alternatives to route an agent between this and single-address tools such as geo_address_search or geo_standardize.

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 openWorldHint=true, so the safety profile is covered. The description adds genuinely new context: the per-call cost ([호출당 10포인트]), the internal mechanism (each address is geocoded to coordinates), and the shape of the result (same parcel/building verdict with distance and similarity).

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?

Front-loads the core decision in the first clause and adds only the use case and cost afterward. The English/Korean duplication is mild redundancy but serves a bilingual audience; no sentence is wasted.

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

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

With no output schema, the description compensates by stating the return content (same-parcel/same-building verdict, distance, similarity) and disclosing the point cost. A read-only tool with full schema coverage and annotations needs little more.

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 all three parameters including the addrType enum are already documented in the schema; baseline 3 applies. The description mentions converting '두 주소' to coordinates but adds no format, syntax, or addrType guidance beyond what the schema provides.

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

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

States a specific verb and resource: decides whether two Korean addresses refer to the same parcel or building, and returns distance plus text similarity. This is clearly distinguishable from siblings like geo_address_search or geo_standardize, which normalize or look up rather than compare a pair.

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 use case ('고객·거래처 주소 중복 정리에 씁니다' – deduplicating customer/vendor addresses), which implies when to reach for it. However, it names no alternative tool (e.g., geo_standardize for normalization) and states no exclusions or prerequisites, so routing versus siblings is left to inference.

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 readOnlyHint and openWorldHint annotations, the description adds two useful behavioral facts: auto-simplification when vertices exceed 3000 and a cost of 20 points per call. It does not describe error behavior or authentication requirements, but the added rate and auto-processing details are meaningful.

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 purpose is front-loaded, but the English sentence is immediately followed by a Korean translation that repeats the same information, wasting tokens. The cost note is useful and placed at the end, but the bilingual duplication weakens overall conciseness.

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

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

With no output schema, the description carries the burden of describing return values, and it does list the computed outputs (area, perimeter, centroid, bounding box) and the simplified GeoJSON. Annotations cover safety and openness, and the schema documents all parameters, so only minor details like output units or error handling 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 100%, so the baseline is 3, but the description adds operational meaning for the simplify parameter by explaining the automatic simplification threshold and framing includeGeometry as an optional simplified GeoJSON return. It also implicitly maps the Korean province/city/county/township terminology to the level enum.

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: look up an administrative district boundary and compute area, perimeter, centroid, and bounding box. It distinguishes itself from generic GeoJSON tools by naming the administrative-district domain, and from measurement tools by listing the exact geometry metrics it returns.

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

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

The purpose strongly implies when the tool is useful—when boundary geometry and derived metrics are needed—but it gives no explicit when-to-use, when-not-to-use, or alternative sibling guidance. An agent can infer usage from the specific resource, but there is no direct routing advice.

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 readOnlyHint and openWorldHint annotations already establish the safety profile, and the description adds useful behavioral context: area is returned in m², 평, and km², and each call costs 10 points. It does not contradict the annotations and does not overclaim destructive 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 English sentence is front-loaded and informative, but the entire description is duplicated in Korean, which doubles the length without adding new agent-relevant information. The pricing note is useful but appended at the end rather than integrated.

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 does a good job naming the returned values: area, perimeter, centroid, bounding box, point-inclusion result, and simplified boundary. It remains slightly incomplete on how point versus x/y should be chosen, but the schema covers most invocation details.

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

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

Schema description coverage is 100%, so the schema already explains geojson, x, y, point, simplify, and includeGeometry. The description adds output-unit semantics for area but does not clarify parameter choices such as when to use point versus x/y.

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 resource (GeoJSON) and concrete operations: area, perimeter, centroid, bounding box, point-in-polygon, and boundary simplification. It is clear what the tool does, but it does not explicitly distinguish itself from nearby geo tools such as geo_measure.

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

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

Usage is implied by the stated operations: an agent can infer it should use this when it has GeoJSON and needs geometric analysis. However, there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives like geo_measure.

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 establish readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds a genuinely non-annotated behavioral fact: a per-call cost of 10 points ('[호출당 10포인트]'), which matters for agent budgeting. It still says nothing about error behavior or coordinate-system assumptions, keeping it below 5.

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 definition is short and front-loaded, leading with the computed outputs before the usage hint and cost note. The Korean line largely mirrors the English sentence, which is some duplication, but for a bilingual tool it is defensible and nothing is wasted.

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

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

With no output schema, the description carries the return-value burden and does so by listing every computed quantity (distances, bearings, length, area, perimeter, centroid, bounding box). Combined with a fully documented 4-parameter schema and read-only annotations, an agent has what it needs; only error handling and coordinate-system expectations are unstated.

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

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

Schema description coverage is 100%, so the baseline is 3: mode, unit, matrix and coordinates are all documented in the schema with enum values and the 200-coordinate cap. The description's enumeration of outputs loosely maps to the path/polygon modes but adds no syntax, default, or format detail 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 first sentence gives a precise verb (measure) plus the exact resource set (segment distances, bearings, total length, polygon area, perimeter, centroid, bounding box) from a coordinate list. An agent can immediately tell this is a geometric measurement tool rather than a geocoder or address tool. It stops short of naming a sibling such as geo_geojson_analyze to draw the boundary 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 Korean sentence '지도에서 그린 경로나 필지 좌표를 바로 측량할 때 씁니다' gives concrete scenarios (a path drawn on a map, parcel coordinates) that select this tool. It is clear context but offers no explicit exclusions or named alternatives, so it does not reach the top tier.

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 openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context beyond the schema and annotations: a per-call cost of 40 points and the nature of the response (nearest lists plus average distance). It does not, however, disclose pagination or exact response shape.

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?

Purpose is front-loaded and the sentences are dense with useful specifics. The English and Korean versions largely duplicate each other, which is reasonable for a bilingual audience but slightly inflates 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?

With no output schema, the description carries the return-value burden and does so adequately by naming nearest lists and average distance. Combined with the 100% schema coverage and readOnly annotation, an agent has enough to invoke it correctly, though exclusions versus other geo tools remain unaddressed.

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

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

Schema description coverage is 100%, so all seven parameters (x, y, point, address, radius, limit, categories) are already documented in the schema. The description restates the category set and radius concept but adds no syntax or default detail beyond what the schema provides, so the baseline 3 applies.

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

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

The description states a specific verb and resource: analyzing daily-life facilities (convenience stores, subway stations, schools, hospitals, pharmacies) around an address or coordinate by category, returning nearest lists and average distance within a radius. This is far more specific than neighboring geo_* tools like geo_measure or geo_district_boundary, so an agent can distinguish it without opening the schema.

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

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

It offers one use context ('상권·입지 분석에 씁니다' / used for commercial-district and location analysis), which implies when it is appropriate. However, it names no alternatives and gives no when-not guidance, despite a crowded geo_* sibling family (geo_place_search, geo_measure, geo_reverse) where routing guidance would be valuable.

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 annotations already cover read-only and open-world behavior, but the description adds useful context: results are enriched with category hierarchy, addresses, distance and bearing, nearest-first sorting is used when an origin exists, radius excludes out-of-range results, and each call costs 20 points.

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 front-loaded with the core purpose and then adds sorting/filtering behavior plus point cost. It is concise overall, though the English-Korean pairing repeats some information, and the Korean line adds details such as nearest-first sorting and radius exclusion.

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 search tool with no output schema, the description explains what is searched, what each result contains, when distance/bearing are computed, how sorting works, and how radius filters results. Pagination details are left to the schema, which is reasonable given full schema coverage.

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

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

Schema coverage is 100%, so the schema already documents all eight parameters in detail. The description reinforces the origin-dependent distance sorting and radius filtering but does not significantly add parameter semantics beyond what the schema provides.

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

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

The description gives a specific verb and resource: search places by name and enrich each result with category, address, distance and bearing. It is clearer than a generic place search, though it does not explicitly contrast itself with nearby siblings such as geo_address_search or google_maps_search.

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?

Use is implied by the search-by-name framing and the conditional note that distance/bearing are computed only when an origin exists. However, there is no explicit guidance on when to use this instead of geo_address_search, geo_address_autocomplete, or google_maps_search.

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 openWorldHint=true, so safety is covered. The description adds a genuinely useful behavioral fact beyond them: '[호출당 20포인트]', a per-call cost of 20 points, which an agent needs for budgeting. It does not cover failure modes for out-of-range coordinates, so it stops short of 5.

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?

Front-loaded with the conversion and its outputs, then the use case and the cost tag; nothing is buried. The English and Korean sentences carry near-identical content, which is mild redundancy, but it is short and every element (outputs, use case, cost) earns its place.

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

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

With no output schema, the description compensates by enumerating the returned fields (jibun/road address, postal code, legal and administrative dong codes), plus cost and a usage scenario. For a single read-only conversion call with fully documented parameters, this is close to complete; only edge-case behavior for invalid coordinates is unaddressed.

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

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

Schema description coverage is 100%, so x, y, and point are each documented with ranges and the mutual-exclusivity note ('point 를 쓰지 않을 때 필요합니다'). The description adds no coordinate syntax or precedence detail beyond that, so the baseline 3 is appropriate.

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

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

States a specific verb+resource pair (좌표→주소·행정구역) and enumerates the concrete outputs: jibun and road addresses, postal code, and legal/administrative dong codes. The coordinate-to-address direction is clear enough to separate it from address-input siblings like geo_address_search, though it never names an alternative explicitly.

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

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

The Korean sentence '지도에서 고른 지점의 주소와 행정구역을 바로 확인할 때 씁니다' gives a real usage scenario (checking the address of a map-picked point), which is more than pure implication. However, it offers no when-not guidance and does not distinguish this single-point tool from geo_batch_geocode or geo_standardize, leaving the agent to infer the choice.

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 openWorldHint=true, so the description's main added value is the cost disclosure '[호출당 50포인트]' (50 points per call), which is exactly the kind of operational context annotations cannot convey. It also sketches what the response contains (components and grade). It does not mention latency, batching, or whether calls are deterministic, keeping it just short of a 5.

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 short sentences in a deliberate order: what it produces, what feeds the score, when to use it, then cost. No filler, and the cost caveat is placed last without burying the core purpose.

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

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

With no output schema, the description still tells the agent the return is a 0-100 score plus components and grade, which is adequate. Seven parameters are fully covered by the schema, and the address/coordinate duality is stated. Minor gap: it does not say whether the score is comparable across calls or how grade thresholds work.

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

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

Schema description coverage is 100%, so every parameter (x/y/point/address/radius/categories/limit) is already documented in Korean. The description only restates that you pass an address or coordinate and does not add defaults, interactions, or the address-vs-coordinate precedence rule beyond the schema. Baseline 3 applies.

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

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

States a specific verb+resource (score an address or coordinate for site selection) and enumerates the exact inputs to the formula (daily-infrastructure accessibility, category diversity, address confidence) plus the output shape (0-100 score with components and grade). No sibling in the geo_* family produces a composite score, so differentiation is implicit but 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 Korean sentence '후보지 여러 곳을 같은 기준으로 비교할 때 씁니다' gives a clear usage condition: comparing multiple candidate sites on a consistent basis. It stops short of naming alternatives (e.g. geo_place_search, geo_neighborhood) or stating when not to use it, so it is clear context without exclusions.

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

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

Annotations only cover readOnlyHint and openWorldHint, so the description usefully adds that the call costs 30 points (a cost/quota trait annotations do not expose) and that the PNU path deliberately skips coordinate resolution. It still omits failure behavior for unparseable or ambiguous addresses, but the added operational context is real 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?

Front-loads the core purpose in the first sentence, then adds the PNU branch and cost tag compactly. The English/Korean bilingual restatement of the same content is mildly redundant for an agent, but overall the definition is tight and well ordered.

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 compensates by enumerating the returned fields (standard text, codes, coordinates, postal code). Combined with 100% schema coverage and read-only annotations, an agent has enough to call it correctly; only ambiguous-address and error semantics 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 description coverage is 100%, so the schema already documents pnu, address, addrType and includeZipcode in detail — including the 'pnu or address, one required' rule. The description largely restates the PNU branch the schema already spells out, adding no syntax, defaults or interaction detail beyond it, which lands at the baseline.

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

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

States a specific verb (normalize) and resource (Korean jibun/road address) and enumerates the exact outputs it produces — standard text, legal/administrative codes, coordinates and postal code — which separates it from single-purpose siblings like geo_admin_code or geo_reverse. It signals it is the bundled 'one response' tool, but never names which sibling to prefer, so differentiation is implicit 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?

Offers one concrete usage branch: supply a 19-digit parcel number instead of an address and you get codes without a coordinate lookup. However, there is no when-to-use versus geo_address_search, geo_address_quality or geo_admin_code, and no statement of when this tool is the wrong choice. Usage is implied rather than guided.

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 cover only safety/idempotency hints, but the description adds substantial non-annotation behavior: billing of 126P on first result, free re-inquiry within the validity window, PARTIAL_SUCCESS still incurring the unit price, and RESULT_EXPIRED semantics. It also explains why readOnlyHint=false despite being a lookup (the charge), so no contradiction arises.

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?

Front-loaded with purpose, then status handling, then billing, then result structure — a sensible order with no filler. Minor redundancy: the first-result charge and free re-inquiry are stated twice (mid-text and again in the bracketed pricing line).

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?

There is no output schema, so the description carries the return-value burden and does so: resultAvailable, status, errorCode, and the per-certificate result.businessRegistrationCert/vatTaxBaseCert/financialStatementCert fields, plus terminal statuses. An agent has everything needed to interpret and poll correctly.

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

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

Schema description coverage is 100% and the single transactionId parameter already documents its source, format, and 32-char hex pattern. The description restates the source but adds no syntax or meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (조회) and resource (승인 상태와 사업자 증빙서류 통합발급 결과), and explicitly ties itself to the upstream sibling req_business_cert_bundle as the source of the transactionId. An agent can distinguish this polling/result tool from the request tool without opening either schema.

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

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

Gives explicit conditional routing: AUTH_WAITING means wait for phone approval, COLLECTING means re-poll with the same ID shortly, and RESULT_EXPIRED after resultExpiresAt means a new authentication submission is required. This is a complete when/when-not protocol, not implied 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 already mark the tool as read-only and open-world, and the description adds a billing note about points per call. However, it does not disclose what the response looks like or caveats about record availability, which is more noticeable because there is no output schema.

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 behavior. The English and Korean sentences are somewhat redundant, but this bilingual structure is reasonable for the target market and adds a use case and cost note without becoming bloated.

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

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

For a simple two-parameter lookup tool, the description covers purpose, identifiers, use case, cost, and safety via annotations. It is adequate for an agent to select and invoke the tool, though a brief note on the return format would make it fully complete.

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

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

Schema description coverage is 100%, with type and value already explained in the schema. The main description restates the two lookup modes but does not add meaningful new parameter semantics beyond what the schema provides.

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

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

The description states a specific verb (check) and a specific resource (Korean vehicle flood damage record), scoped by VIN or license plate. This makes the tool's function unambiguous and inherently distinct from siblings like get_car_scrap, which covers a different vehicle record type.

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 provides a concrete use case: checking flood history before purchasing a used car. It does not mention exclusions or alternatives, but the stated context is clear enough for an agent to understand when this tool is appropriate.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds beyond them by disclosing the per-call point cost and the Korean-vehicle scope. It does not describe response details, but this is a simple read-only lookup and no contradiction exists.

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 English and Korean sentences are compact and front-loaded with the core purpose before cost and use case. The Korean sentence largely repeats the English sentence, causing slight redundancy, but the overall entry remains efficient.

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

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

For a simple two-parameter, read-only lookup with no output schema, the description covers what, how, why, and cost. It could improve by naming related car-lookup siblings or describing the response format, but nothing essential is missing for invoking correctly.

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

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

Schema description coverage is 100% and both type and value are already documented in the schema. The description only restates the type-to-VIN/plate mapping without adding new format or validation details, so it earns the baseline score.

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

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

The description states a clear verb and resource: checking whether a Korean vehicle has a scrap/total-loss accident record, keyed by VIN or license plate. It does not explicitly differentiate itself from sibling tools such as get_car_flooding or get_pccc, so it stops short of 5.

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

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

It gives an explicit intended use case: used before buying a used car. It does not, however, mention when to prefer an alternative or when not to use this tool, so it lacks the exclusions needed for 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?

Annotation readOnlyHint=false could look surprising for a 'get_*' tool, but the description discloses why: it bills on first result return (60P base, 0.5× per extra incomeYear) and re-queries within the validity window are free, matching idempotentHint=true. It also enumerates the outcome state machine (AUTH_WAITING/COLLECTING/RESULT_EXPIRED) and the expiry trigger, so the side-effect profile is fully clear.

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?

Front-loaded with purpose, then behavior, then the billing note in brackets. Every sentence carries operational meaning, though the pricing formula and status enumeration make it dense; nothing is clearly removable but it is heavier than strictly necessary.

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 compensates by naming the return fields (resultAvailable, status, errorCode, result.cashReceiptDeduction, resultExpiresAt), so an agent knows both what to check and where the payload lives. Nothing needed for a correct async-fetch call is missing.

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

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

Only one parameter and schema coverage is 100%, so the format/pattern burden sits on the schema. The description confirms that transactionId must come from the req_cash_receipt_deduction response, but that origin is already stated in the schema description, so it adds little beyond the baseline.

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

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

States a specific verb and resource (조회한다 – 조회 of approval status and deduction result) and explicitly anchors the tool to the req_cash_receipt_deduction transactionId, cleanly distinguishing it from the sibling that creates the request. An agent can tell this is the polling/result-fetch half of a two-step flow without opening the schema.

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

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

Gives an explicit status-driven calling protocol: AUTH_WAITING means wait for phone approval, COLLECTING means re-query with the same ID shortly after, RESULT_EXPIRED means a new authentication request is required. This is exactly the when/when-not guidance an agent needs to avoid mis-calling it.

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 well beyond the annotations by disclosing the billing model (charged on first result return, free re-query within the validity period), the state machine (AUTH_WAITING/COLLECTING/RESULT_EXPIRED), the fields to check (resultAvailable, status, errorCode), and where the payload lives (result.drivingLicense). This explains why readOnlyHint=false despite the 'get' framing, so there is no contradiction.

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?

Front-loaded with purpose and then state handling, all in a compact block. The trailing bracketed clause restates the billing/re-query rule already stated earlier, a minor redundancy that keeps it just short of a 5.

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

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

With no output schema, the description carries the full burden and does so: it names the status states, the billing conditions, the response fields, the payload location, and the expiry behavior. Nothing an agent needs to poll and interpret this tool correctly is missing.

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

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

Schema description coverage is 100% and the schema already states that transactionId comes from the req_driving_license response. The description repeats that linkage but adds no format or syntax detail beyond it, so the baseline 3 applies.

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

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

States a specific verb and resource (retrieve approval status and driver's license result) and explicitly anchors it to the sibling req_driving_license as the source of the transactionId. An agent can tell this is the polling/result-retrieval counterpart to the request tool without opening either schema.

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

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

Gives explicit state-dependent instructions: wait for mobile approval on AUTH_WAITING, re-query with the same ID shortly on COLLECTING, and start a new authentication request after RESULT_EXPIRED. The entry condition (obtain transactionId from req_driving_license) and the free re-query window are both named, leaving little to inference.

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 behavior that annotations cannot convey: first result return triggers billing, re-query within the validity window is free, RESULT_EXPIRED is returned after resultExpiresAt, and which fields (resultAvailable, status, errorCode) should be inspected. This explains the otherwise puzzling readOnlyHint=false annotation for what looks like a read operation.

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

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

Dense and front-loaded: purpose, state machine, billing, and return fields in a tight sequence. The only waste is the bracketed billing sentence at the end, which restates the billing/refund rule already stated earlier in the description.

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

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

With no output schema, the description carries the full burden and does so: it names the result container (result.employment), the status fields, the error codes, and the expiry behavior. An agent has everything needed to poll correctly and interpret the response.

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

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

Schema description coverage is 100% and the single parameter is fully documented in the schema, including its origin and the 32-hex-character format. The description restates that the transactionId comes from req_employment but adds no format or usage detail beyond the schema, so the baseline of 3 is appropriate.

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

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

States a specific verb+resource: it queries approval status and employment/insurance verification results using a transactionId. It also implicitly distinguishes itself from the sibling req_employment by naming that tool as the source of the required transactionId, so an agent knows this is the poll/result side rather than the initiation side.

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 concrete state-dependent guidance: on AUTH_WAITING wait for phone approval, on COLLECTING retry shortly with the same ID, and after resultExpiresAt a new authentication is required. It does not explicitly state that req_employment must be called first as a prerequisite step, but the dependency is clear from the parameter origin.

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?

Adds behavioral facts well beyond the annotations: billing is triggered by the first successful result return, re-query within the validity window is free, and expiry is signaled with RESULT_EXPIRED. This is exactly the kind of cost/side-effect context the readOnlyHint=false annotation alone cannot convey, and nothing contradicts the 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?

Front-loads the purpose, then state handling, then billing and field guidance; every sentence carries actionable information. It is dense but not padded, though the bracketed billing restatement at the end is mildly redundant.

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 compensates by naming the fields to inspect (resultAvailable, status, errorCode) and where the payload lives (result.healthCheckup), plus the expiry field resultExpiresAt. An agent needs nothing more to call and interpret this tool.

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

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

Schema coverage is 100% and the single transactionId parameter already documents its source and 32-char hex format, so the description adds little parameter-level meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

Names a specific verb (조회) and resource (국가 건강검진 결과 조회 결과 / approval status) and scopes it by the req_health_checkup transactionId, which cleanly separates it from the sibling requisition tool req_health_checkup. An agent can tell exactly what this returns without opening the schema.

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

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

Gives explicit state-driven guidance: AUTH_WAITING means a phone approval is pending, COLLECTING means re-query with the same ID shortly, and RESULT_EXPIRED means a new authentication submission (req_health_checkup) is required. The polling/retry behavior is spelled out rather than left to inference.

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 only declare readOnlyHint=false, idempotentHint=true, destructiveHint=false; the description adds the crucial non-obvious traits — billing occurs on the first result return, re-queries within the validity window are free, and results expire at resultExpiresAt. It does not explain why the call is flagged non-read-only beyond pricing, but that is a minor gap given how much cost/expiry behavior is disclosed.

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

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

Front-loaded with the action and state handling, then cost and expiry, which is the right priority order. The 14-item enumeration of result.* sections is long but substitutes for a missing output schema, so it mostly earns its 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?

With no output schema and a single param, the description fully carries the burden: it names the returned result sections (conditional on the products chosen at request time), the status/error codes to check, expiry behavior, and cost model. An agent has everything needed to call and interpret it.

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

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

The schema already documents the single transactionId parameter at 100% coverage, but the description reinforces the provenance constraint (it must come from a req_hometax_biz_bundle response) and the reuse rule for polling, which matters for correct invocation.

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

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

States a specific verb (조회) plus the exact resource (사업자 국세 통합조회 결과) and pins the lookup key to the transactionId issued by req_hometax_biz_bundle, which cleanly separates it from the sibling request tool and from get_hometax_bundle (personal income tax).

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 an explicit state machine: AUTH_WAITING means wait for phone approval, COLLECTING means re-poll shortly with the same ID, RESULT_EXPIRED means a new authentication request is required. It also tells the agent which fields (resultAvailable, status, errorCode) to inspect before acting, leaving no ambiguity about when to poll vs. restart.

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 well beyond the annotations by disclosing the billing model (charged on first result, free re-queries within the validity window), the full status state machine, and the need to inspect resultAvailable/status/errorCode. The charge-on-first-call behavior actually explains why readOnlyHint is false despite this being a lookup, and nothing contradicts idempotentHint=true.

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?

Front-loads the core action, then status handling, then cost, then return contents, then expiry. Every sentence carries operational information; even the enumeration of result sections serves the point that only the products chosen at request time are returned.

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 exists, so the description carries the full burden of explaining return values, and it does: it names the status/error fields to check, the possible result.* sections, and the expiry error. An agent has everything needed to poll correctly and to know when to re-request.

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?

Only one parameter and schema coverage is 100%, so the schema already documents the lowercase 32-hex transactionId and its origin in the same-product req_hometax_bundle response. The description restates that provenance but adds no new syntax or format detail beyond the schema, 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?

States a specific verb+resource: retrieving approval status and personal national-tax integrated lookup results by transactionId. It explicitly ties itself to the sibling req_hometax_bundle as the source of the ID, making the request/result pair unambiguous against the many other req_* 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?

Gives concrete branch-by-branch guidance: AUTH_WAITING means wait for phone approval, COLLECTING means re-query with the same ID after a pause, and after resultExpiresAt the agent gets RESULT_EXPIRED and must file a new authentication request. It names the exact condition that routes the agent to the sibling req_hometax_bundle.

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 declare readOnlyHint=false and idempotentHint=true; the description explains why by disclosing billing rules (84P on first result, free re-query within validity), PARTIAL_SUCCESS unit pricing, and expiry-to-RESULT_EXPIRED behavior. That is real behavioral context (cost, idempotent retry, temporal limits) beyond the annotation flags, and nothing contradicts 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 purpose is front-loaded in the first clause, followed by status-handling, billing, and result-path details; every sentence carries operational information. It is dense and the bracketed pricing footnote slightly duplicates the billing sentence, keeping it from a 5.

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

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

With no output schema, the description carries the return contract: check resultAvailable, status, errorCode, and read per-certificate values at result.incomeAmountCert and result.pensionCreditCert. Combined with status enumeration, billing, and expiry handling, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100% and the schema already specifies the 32-char lowercase hex pattern, so the baseline is 3. The description adds retry semantics — reuse the transactionId from the req_income_cert_bundle response, and the same ID for polling — which is meaningful 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?

States a specific verb (조회) and resource (소득 증빙서류 통합발급 결과) tied to a specific key (req_income_cert_bundle의 transactionId). This clearly distinguishes it from the request-side sibling req_income_cert_bundle, so an agent can pick the right one without reading either schema.

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

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

Explicitly gives when-to-use branches: AUTH_WAITING means wait for phone approval, COLLECTING means retry shortly with the same ID, RESULT_EXPIRED means a new application is required. These state the condition and the required next action, including the alternative flow when the result is expired.

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 substantial behavior beyond the annotations: first-result billing, free re-query within validity, status checks including PARTIAL_SUCCESS, per-result paths, expiration behavior, and the need for a new authentication after expiry. These details are consistent with idempotentHint=true, destructiveHint=false, and readOnlyHint=false, since the tool can incur billing despite being a retrieval operation.

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

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

The definition is dense but front-loaded: the first sentence establishes the action and source ID, then status handling, billing, result paths, and expiry follow in a logical sequence. Every sentence carries operational meaning for invoking and interpreting the tool.

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

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

Although there is no output schema, the description explains the key result fields, status states, partial-success behavior, billing implications, and expiration handling. For a one-parameter retrieval tool with annotations covering safety and idempotence, this is complete enough for an agent to call and interpret it correctly.

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

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

Schema description coverage is 100%, so the single transactionId parameter is already fully documented. The description reinforces that the ID comes from req_nps_bundle and should be reused for polling, but it does not add format or syntax details beyond the schema.

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

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

The description states a specific verb and resource: retrieve approval status and the integrated National Pension lookup result using a transactionId from req_nps_bundle. It clearly distinguishes this integrated bundle lookup from the individual get_nps_* sibling tools by naming the bundle result fields and the parent request 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?

It gives explicit state-based guidance: wait for phone approval when AUTH_WAITING, poll again with the same ID when COLLECTING, and submit a new request after RESULT_EXPIRED. It does not explicitly route the agent between this tool and the individual get_nps_join_history/get_nps_deduction_cert/get_nps_career_history siblings, but the transactionId context makes the intended workflow 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?

Discloses billing on first result return, free re-queries within validity, the RESULT_EXPIRED terminal state, and the key status fields to check — well beyond the annotations. The annotations (idempotentHint=true, readOnlyHint=false) are consistent with a re-runnable but billed call, and the description explains why.

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?

Front-loads the retrieve action, then polling behavior, then billing and expiry. The billing point is repeated in the trailing bracketed sentence, which is mild redundancy but the content is otherwise dense and useful.

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 fully carries the return contract: resultAvailable, status, errorCode, result.npsCareerHistory, and resultExpiresAt/RESULT_EXPIRED. Nothing an agent needs to interpret a response is missing.

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

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

Schema coverage is 100% and the schema itself already documents that transactionId comes from the req_nps_career_history response (with format). The description only restates this source relationship, adding little beyond the structured field.

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 (retrieves approval status and NPS career-history result) and explicitly ties itself to the sibling prerequisite req_nps_career_history via its transactionId. An agent can distinguish this result-fetch tool from the request tool without opening either schema.

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

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

Gives explicit polling rules: wait on AUTH_WAITING (phone approval), retry with the same ID on COLLECTING, and re-authorize after physical expiry. It also states the prerequisite relationship with req_nps_career_history and the free/billed conditions, leaving little to inference.

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?

Without the description the agent would have no idea this read-like call is metered. It discloses the billing model (first result 60P × (1 + 0.5 × (years-1)), free re-queries within the validity period), the async approval states, and the expiry behavior (RESULT_EXPIRED forces re-authentication). This adds substantial value beyond the annotations, which only cover the generic safety/idempotency 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?

Purpose is front-loaded in the first clause, followed by state handling, billing, and result location. The bracket at the end compactly restates the cost rule. It is dense but every sentence carries actionable information; mildly packed rather than wasteful.

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 carries the return-value burden and does so: it names resultAvailable, status, errorCode, result.npsDeductionCert, and resultExpiresAt, and explains the expiry error. For a polling-plus-billing tool this covers everything an agent needs to call and interpret it correctly.

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

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

There is only one parameter and schema description coverage is 100%, so the schema already documents the transactionId format (32 lowercase hex chars) and its source. The description restates the same origin (req_nps_deduction_cert) without adding format or usage detail, so the baseline of 3 applies.

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

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

States a specific verb (조회/retrieve) and a precise resource (국민연금 소득공제용 납부확인서 결과), and explicitly ties itself to the sibling it depends on, req_nps_deduction_cert, whose transactionId it consumes. An agent can distinguish this from the request-side sibling without opening either schema.

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

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

Gives concrete when-to-use guidance tied to the req_nps_deduction_cert call that produces the transactionId, and tells the agent how to act in each state: wait on AUTH_WAITING, re-query the same ID on COLLECTING, and resubmit a new auth after RESULT_EXPIRED. It does not frame the paired request tool as an explicit alternative or spell out a when-not-to-use case, so it stops short of a 5.

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

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

Annotations already declare openWorldHint=true, idempotentHint=true, destructiveHint=false and readOnlyHint=false, and the description reinforces the read-but-billed nature with the 'billed on first result, free re-queries within validity' note. It also discloses polling states, error codes, and expiry behavior. However, the billing/readOnly nuance is the only place it goes clearly beyond the annotation layer, so this is a solid but not exceptional 3-4.

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?

Front-loaded with the purpose, then walks through status handling, billing, result location, and expiry in a logical order. Slightly redundant: the billing point is restated in the bracketed closing note, which repeats the earlier sentence rather than adding 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?

With no output schema, the description must carry the return contract, and it does: it names resultAvailable, status, errorCode, the result.npsJoinHistory path, and resultExpiresAt with the RESULT_EXPIRED terminal state. An agent has everything needed to call and interpret this polling 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% and documents the transactionId format (16-byte lowercase hex, 32 chars). The description adds useful provenance — that the id comes from the req_nps_join_history response for the same product — which the schema does not state.

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 approval status and NPS join history result) via the transactionId issued by req_nps_join_history. It explicitly distinguishes itself from the sibling req_nps_join_history by naming it as the source of the id, so an agent can separate the request step from the result-retrieval step.

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 explicit conditional guidance: AUTH_WAITING means wait for mobile approval, COLLECTING means re-query shortly with the same ID, and RESULT_EXPIRED after resultExpiresAt means a fresh authentication request is needed. When-to-call and what-to-do-next are both spelled out.

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 well beyond the annotations: it discloses the billing model (20 points per call, charged only on successful retrieval, not on pending or empty results), the exact status/message values for each outcome, and the 24-hour re-query window with per-lookup charging. This explains why readOnlyHint=false and idempotentHint=false 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 core purpose and cost are front-loaded, and each subsequent sentence covers a distinct outcome (pending / approved / empty). Slight redundancy in restating '과금되지 않습니다' for two cases keeps it from a 5, but nothing is wasted.

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

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

With no output schema, the description carries the full burden and does so: it enumerates returned fields (PCCC, address, checked_at), status values, and message strings for each branch. An agent can call this and interpret the response without further information.

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

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

Schema coverage is 100% and the schema already says tx_id is the req_pccc transaction ID, so the description largely repeats it. It does add the behavioral meaning of the parameter — that supplying it returns processing status and that results stay queryable for 24 hours — which is useful framing 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?

States a specific verb and resource ('Retrieve a Korean Personal Customs Clearance Code') and identifies the exact input that scopes it (the tx_id from req_pccc). The pairing with req_pccc makes the division of labor between the two siblings 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?

Clearly establishes the precondition that tx_id comes from a prior req_pccc call, and explains that this tool polls processing status. It stops short of an explicit 'call this only after req_pccc returns a tx_id' directive or stating what to do if the tx_id is unknown/expired beyond the 24h note.

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 billing behavior (charged on first result return, free re-queries within validity), the expiry behavior (RESULT_EXPIRED after resultExpiresAt), the polling states, and where the payload lives (result.personalIncome). It also notes re-auth is required after expiry. This goes well beyond the annotations. The readOnlyHint=false vs. a pure read query is slightly at odds but explainable by billing side effects, so no contradiction.

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?

Four dense Korean sentences, front-loaded with the core action, then state handling, then billing, then result location. The bracketed repetition of the billing rule is redundant with the earlier sentence but otherwise contains 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?

Covers everything an agent needs for a single-param polling/result tool: the producing sibling, the polling states and re-query cadence, the billing trigger, the expiry failure mode, and the result field location. No output schema exists, yet the description still points to the key result fields (resultAvailable, status, errorCode, result.personalIncome).

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; the description adds real value by tying transactionId's provenance to req_personal_income's response and by clarifying that the same ID can be reused within the validity window, which the schema does not state.

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?

Specifies a clear verb (조회) and resource (금융소득 조회 결과), and explicitly distinguishes itself from its sibling req_personal_income by positioning itself as the result-retrieval tool that consumes the transactionId produced by req_personal_income. An agent can tell the pair apart without inspecting schemas.

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 explicit when-to-use routing: on AUTH_WAITING wait for mobile approval; on COLLECTING re-query later with the same ID; on RESULT_EXPIRED submit a new authentication (req_personal_income). This is a full state-machine guide, not just a hint.

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?

Adds substantial behavior beyond the annotations: a billing model (charged on first result, free re-queries inside the validity window), the set of fields to inspect (resultAvailable, status, errorCode), where the payload lives (result.taxReturnHistory), and the expiry/error behavior. The non-readOnlyHint is consistent with the described charging, so there is no contradiction.

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?

Front-loads the core action and keeps every sentence functional, but the appended bracketed pricing formula is dense and slightly crammed onto the end rather than integrated. No true filler, though.

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 carries the full burden and does so: it names the returned fields, the expiry field, the expiration error code, and the billing consequence. An agent has everything needed to poll, interpret, and re-drive the workflow.

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

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

Schema coverage is 100% and the pattern is documented, so the baseline is 3; the description still adds value by explaining provenance (the ID returned by the same-product req_tax_return_history call) and the retry-with-same-ID rule that the schema cannot express.

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 (retrieves the approval status and national-tax-filing lookup result for a transactionId) and explicitly ties it to the sibling req_tax_return_history that produces the ID. An agent can distinguish this polling/result tool from the request tool without opening either schema.

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

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

Gives explicit when-to-use and state-machine routing: AUTH_WAITING means waiting on phone approval, COLLECTING means retry later with the same ID, and after resultExpiresAt a RESULT_EXPIRED forces a new auth request. It also states the alternative (re-request via req_tax_return_history) for the expired case.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds real cost information ([호출당 60포인트]) plus a key output caveat that amounts and toll details are not provided. That is meaningful behavioral context beyond structured fields, though it omits latency or data-freshness characteristics.

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?

Front-loads the core purpose and keeps the cost and exclusion notes brief. The English/Korean duplication slightly inflates length, but each line still carries distinct operational 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?

No output schema exists, and the description compensates by explaining the returned unpaid_target flag and unpaid count, plus what is not returned. Per-call cost is disclosed; only edge-case behavior for invalid plate formats is left unstated.

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

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

With 100% schema coverage on the single car_no parameter, the schema already carries the plate-number semantics and examples. The description only restates 'by plate number', so baseline 3 is appropriate.

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

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

States a specific verb+resource: checking unpaid Hi-pass expressway tolls for a Korean vehicle by plate number. The resource is distinct from vehicle siblings like vehicle_recall or vehicle_tax_calc, although the description never names those alternatives to sharpen the boundary.

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

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

Gives clear scope and an explicit exclusion: it will not return unpaid amounts or toll usage history, and if unpaid_target=false no charge applies. Missing is any direct routing statement comparing it against the other vehicle_* siblings.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description's 'Look up/조회' aligns with that read-only behavior. The description adds a per-call cost note ('[호출당 3포인트]') and downstream use cases, which is useful context. It does not disclose output shape or edge-case behavior, but for a safe read-only lookup the annotations carry most of the burden.

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

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

The description is three short sentences, with the primary lookup action and scope front-loaded. The Korean sentence repeats the English statement, which is mildly redundant, but the overall size is compact and the extra cost/use-case information is earned.

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

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

For a simple two-parameter read-only holiday lookup, the description plus schema covers what an agent needs to call it correctly. There is no output schema, so the description could have described the returned holiday information, but this is a minor gap for a straightforward query tool. The cost note and read-only annotations round out the 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 100%: both year and month are documented with type, range, and example values. The description only restates 'given year and month' and does not need to add further parameter detail. The baseline of 3 applies because the schema fully handles 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 uses a specific verb ('Look up') with a clearly bounded resource: Korean public holidays for a given year and month. The bilingual text and the stated use cases ('영업일 계산, 일정 관리') make the tool's role unambiguous. It is easily distinguished from the sibling tools, none of which target holiday data.

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 usage context by stating the tool is for business-day calculations and schedule management. It does not explicitly name alternatives or when-not-to-use conditions, but the sibling list contains no competing holiday tool, so the guidance is sufficient.

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 the description complements this by adding that the operation is free ('무료입니다') and scoped to the currently authenticated API key. It does not detail rate limits or exact response structure, but for a zero-parameter read-only tool this is reasonable.

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

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

The description is short and front-loaded, but it repeats the same content in English and Korean and redundantly states '무료입니다' and '[무료]'. The core message is clear, but the duplicate free-note is unnecessary and slightly bloats the definition.

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

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

For a zero-parameter, read-only account info tool, the description covers what the tool returns (remaining points and account status), the auth scope, and the cost. No output schema exists, so the description's explicit mention of return semantics is sufficient.

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

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

The tool has zero parameters, and schema description coverage is trivially 100%. The description does not need to document parameters; the baseline for zero-parameter tools is a 4, and there are no gaps here.

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

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

The description uses a specific verb ('Check'/'조회') and a specific resource ('APICK account balance and status'/'잔여 포인트와 계정 상태 정보'). It clearly identifies what the tool does and is easily distinguished from the broad sibling list, none of which target account info.

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

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

The description clearly implies when to use the tool: whenever the agent needs the current APICK account balance or status. It does not explicitly mention alternatives or exclusion criteria, but with zero similar siblings and a simple purpose, the context is sufficient.

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 only declare that this is a read-only, open-world call; the description adds two things the annotations do not: an explicit per-call cost ('[호출당 50포인트]', a rate/quota constraint) and the fact that change-rate and trend values are delivered in a dedicated analysis block. That cost disclosure is high-value for agent planning, but response shape and failure behavior remain undisclosed.

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 output capabilities are front-loaded, which is good, but the body is essentially the same content stated twice in English and Korean. The Korean sentence is not a clarifying expansion — it restates the same field list — so roughly half the text is duplicated rather than additive.

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 5-parameter, annotation-covered, output-schema-less tool, the description covers purpose, input precondition, analysis scope, and cost — enough for an agent to decide and invoke. Gaps are minor: no note on error handling when neither locator is provided, and no sense of response size or latency for a multi-source aggregation call.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description adds meaning the schema does not encode: an either/or requirement between pnu and address (the schema marks no fields required), and that the priceYears window feeds the change-rate/trend block. It still does not explain how year vs priceYears interact or what happens when both pnu and address are supplied.

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

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

A specific verb ('Analyze') plus resource ('Korean parcel') with an enumeration of what is returned: characteristics, land-use plan, official land price history with change rates/CAGR, and regulation conflicts. That is far more than a restatement of the name. It stops short of 5 because it never distinguishes the tool from price-oriented siblings such as land_rt_price, which overlap on the official land price portion.

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 a hard input precondition ('pnu(19자리) 또는 address 중 하나가 필요'), which is genuine usage guidance since the schema declares zero required parameters. However, it offers no when-to-use/when-not guidance and no routing to alternatives; an agent cannot tell from this text whether to call land_info or land_rt_price for a price-only 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description does not need to re-establish safety. It does add two genuinely useful behaviors beyond the annotations: a per-call cost of 50 points and the fact that an invalid addr1 returns an 'options' field listing selectable regions. It stops short of describing result volume or pagination for a potentially large transaction history.

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 English sentence and the Korean sentence say the same thing, so roughly half the text is redundant restatement. The distinctive details (options fallback, 50-point cost) are present but appended rather than 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 four-required-parameter read lookup with full schema coverage and no output schema, the definition covers purpose, cost, and error recovery. The remaining gap is the shape of a successful response (transaction fields, volume, sorting), which an agent must discover at runtime.

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

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

Schema description coverage is 100%, with each parameter (type code A~H, year range, addr1, addr2) fully documented in the schema, so the baseline is 3. The description only restates the three lookup axes and adds the addr1-failure fallback, which is useful but does not deepen the meaning of individual 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 states a specific verb and resource ('Look up real estate transaction price records in Korea') and scopes it by region, property type, and year. An agent can tell it is a read lookup of transaction prices, but it never distinguishes itself from close siblings such as rtms_trade, rtms_rent, or registry_realestate_search, which likely overlap.

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 rtms_trade/rtms_rent/land_info, and no preconditions or exclusions are given. The only guidance is reactive error recovery for a bad addr1, which tells the agent nothing about tool selection.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful operational context beyond annotations: cost per call (5 points), free carrier-list endpoint, real-time tracking behavior, and fallback to the auto tool. It does not cover auth, rate limits, or error 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 purpose and required inputs are front-loaded in the first sentence, followed by carrier examples, list endpoint, alternative tool, and cost. It is dense but every element aids invocation. Minor repetition of carrier examples already present in the schema keeps it from a 5.

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

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

The description covers invocation essentials: purpose, required parameters, carrier examples, fallback tool, cost, and carrier list source. Because no output schema exists, it would ideally describe returned fields or error cases; that gap keeps it from 5 for this two-parameter tool.

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

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

Schema description coverage is 100%, setting a baseline of 3. The description adds meaning by listing several carrier code examples and pointing to a free endpoint for the full carrier list, which helps correct carrier selection. trackingNumber remains generic, so it does not reach 5.

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?

Uses a specific verb ('Track') and resource ('Korean parcel in real time') and identifies required inputs. It distinguishes itself from the sibling parcel_tracking_auto by noting the automatic lookup is for when the carrier is unknown. Carrier examples and the list endpoint further sharpen 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?

Explicitly names the alternative ('parcel_tracking_auto') and the condition that selects it: when the carrier is unknown. It also directs the agent to /rest/parcel_tracking_carriers for the full carrier list, giving clear when-to-use guidance.

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

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

Annotations already cover readOnlyHint and openWorldHint, so the safety profile is established. The description adds non-obvious behavioral details: automatic carrier detection from the tracking number format, real-time status lookup, and a per-call point cost. There is no contradiction with the 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 compact: an English sentence, a Korean mirror sentence, and a third sentence naming the alternative and cost. The bilingual duplication is a minor redundancy, but the purpose is front-loaded and every sentence carries useful information.

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

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

For a one-parameter, read-only tool with full schema coverage and openWorldHint, the description covers the core decision factors: function, usage condition, alternative, and cost. Return format is not specified, but no output schema exists and openWorldHint signals variable results, so nothing essential is missing.

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

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

The schema already describes trackingNumber with 100% coverage ('운송장번호 (택배사 지정 없이 형식만으로 자동 판별)'). The description reinforces the same idea with 'from the tracking number alone' but adds little parameter-specific meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description opens with a specific verb and resource: 'Track a Korean parcel in real time with automatic carrier detection from the tracking number alone.' It clearly distinguishes itself from the sibling parcel_tracking by emphasizing auto-detection versus a known carrier, so an agent can tell them apart without opening the sibling 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?

It explicitly states when to use this tool: when no carrier is specified and only the waybill number is available. It also names the alternative: '택배사를 이미 아는 경우에는 parcel_tracking Tool이 더 정확합니다' (if you already know the carrier, parcel_tracking is more accurate), providing direct when-to-use/when-not-to-use guidance.

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

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

The description goes well beyond the annotations: it warns the call can take up to 180 seconds, that each job costs 850P including PDF delivery, that no charge is applied if the call fails before payment, and that a previously issued PDF can be re-fetched at 30P via the X-Apick-Job-Id header against the download endpoint. These are exactly the cost, latency and retry facts an agent needs before spending money on a purchase-like operation.

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

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

The purpose is front-loaded in the first sentence and the operational facts follow in a compact sequence. The trailing bracketed '[호출당 850포인트]' repeats the 850P already stated earlier, and the mixed English/Korean phrasing adds minor noise, but nothing else is wasted.

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

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

For a paid, potentially 180-second operation with no output schema, the description supplies the pricing, failure-charge policy, latency ceiling and the recovery path for retrieving an already-paid PDF. Combined with the fully documented schema, an agent has everything needed to call it correctly and to decide whether the cost is justified.

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 already 100%, so the baseline is 3, but the description adds real meaning: it frames the tool as keyed on 법인등록번호 and states that reusing the same call returns the existing job's PDF, which explains the idempotency semantics of idempotency_key more concretely than the schema does. `usage` (view vs issue) and `index` are left to 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 first sentence names a concrete verb pair (view/issue) and the resource (corporate registry certificate), and explains that everything is done in one call with a PDF returned. It never names or distinguishes the obvious sibling, registry_corporate_search, which is the workflow step that probably produces the `index` input, so an agent gets no explicit guidance on how it relates to that 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?

Usage is implied rather than stated: corp_reg_no is the primary identifier and biz_no is the fallback, and `index` picks a row from a prior search. There is no explicit statement of when to use this instead of registry_corporate_search or registry_realestate_jobs_create, and no exclusions or prerequisites, so an agent must infer the search-then-issue 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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely new behavioral context: a per-call cost of 40 points, and the fact that unregistered/sole-proprietor queries return zero results and still cost 0P. That pricing and empty-result behavior is not derivable from structured fields.

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?

Bilingual purpose statement is front-loaded, followed by the empty-result caveat and the cost tag. Reasonably tight, though mirroring the English sentence in Korean adds redundant length rather than new 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?

No output schema exists, and the description does not describe the shape of results or pagination. It also does not resolve the fact that 0 parameters are required while the workflow clearly needs at least one identifier. Coverage of cost and empty-result behavior is good, but return-side information is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters and their digit-count patterns. The description restates the identifier formats but adds no new syntax or format detail beyond what the schema 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?

States a specific verb ('Find') and resource ('corporate registry targets in Korea'), plus the two identifier forms (13-digit corp reg number, 10-digit business number). This distinguishes it from registry_realestate_search, though it does not explicitly differentiate itself from the sibling registry_corporate_jobs_create flow.

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 useful precondition ('개인사업자·미등록이면 결과가 없고 0P입니다'), clarifying that sole proprietors/unregistered entities return nothing. However, it never states when to use this direct search versus the batch job-based siblings (registry_corporate_jobs_create, registry_jobs_status), leaving the workflow choice to inference.

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 readOnly/openWorld annotations, the description discloses a concrete return limitation ('증명서 원문은 돌려주지 않습니다' — the original certificate is not returned) and the cost ('[호출당 60포인트]' — 60 points per call). These add real operational context the annotations don't carry.

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?

Front-loaded with the purpose in English, followed by supporting detail and the parameter enumeration. Bilingual repetition costs a little density but every sentence contributes (purpose, parameter meaning, return scope, cost).

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 compensates by stating what is confirmed (issuance fact, certificate type, date, registry office) and explicitly that the original certificate is not returned. It also covers read-only nature and cost, leaving little an agent needs 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 100%, so the baseline is 3, but the description adds semantic meaning by mapping each enum value to its domain in Korean (realestate=부동산 default, corporate=법인, movable=동산·채권담보), which the bare enum list does not provide.

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: 'Verify an issued Korean registration certificate by the verification number printed on it,' and enumerates what it confirms (issuance fact, type, issuance date, registry office). This is clearly distinct from the sibling search/jobs tools, but it doesn't explicitly name any sibling to reinforce the distinction.

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

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

The description implies the usage context (you must have the 12-digit verification number printed on the certificate), which naturally frames when to use it. However, it offers no explicit when/when-not guidance or comparison to alternatives like registry_realestate_search or registry_corporate_search.

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 well beyond the annotations: 850P per call, no charge on failure, up to 180s latency, PDF returned plus an X-Apick-Job-Id response header, and the dual idempotency semantics (idempotency_key prevents double payment; the download endpoint is unlimited at 30P). The annotations only say readOnly=false and idempotent=true; the description supplies the cost, timing, and failure-charge behavior an agent needs before spending points.

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?

Purpose and cost are front-loaded and most sentences carry real information (timeout, failure refund, re-download). However, the pricing is stated twice — "건당 850P(PDF 전송 포함)" and the bracketed "[호출당 850포인트]" — which is redundant, and the mixed Korean/English makes scanning slower than necessary.

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 does the necessary work by stating that a PDF is returned and that the job id arrives in a response header. Cost, latency ceiling, refund-on-failure, and the re-download path cover the main risks of a paid, slow, external call. Minor gap: it doesn't say what a caller should do if the 180s window is exceeded or how partial/failed jobs surface.

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 all 8 parameters (pin, index, query, usage, record_scope, include_cancelled, publish_resident_no, idempotency_key) are already documented. The description only indirectly gestures at the target selector ("검색 결과의 대상을 지정하면") and adds nothing about the usage/record_scope enums or how index relates to query. Baseline 3 is correct when the schema carries the 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?

Opens with a specific verb+resource pair ("View and issue a real estate registry certificate") and makes the scope explicit with "in one call" — payment plus PDF retrieval completed in a single invocation. The phrase "검색 결과의 대상을 지정하면" ties it to the search sibling's output, so an agent can tell this apart from registry_realestate_search without opening either schema.

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

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

Clearly states the prerequisite context (pick a target from search results) and gives a concrete alternative path for re-retrieval: POST /rest/registry_jobs/:job_id/download at 30P rather than re-calling this tool. It stops short of an explicit "do not use this when…" or naming the sibling tools outright, so it lands at 4 rather than 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds meaningful context beyond that: a 40-point cost per call, a 0-point outcome when no results are returned, and the downstream handoff — all of which help an agent reason about cost and follow-up.

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?

Purpose is front-loaded in the first sentence, followed by workflow and cost notes. The Korean text largely mirrors the English rather than adding new information, which is mildly redundant but still efficient and audience-appropriate.

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

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

With no output schema, the description carries the return-value burden and does so partially by naming the 'index' field of result targets that feeds the jobs_create tool. Cost behavior is also disclosed, leaving only result shape details (e.g., other fields) unspecified.

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 single 'query' parameter is already fully documented as address or 14-digit property number. The description restates the same format without adding syntax, normalization, or validation detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Find) and resource (real estate registry targets) with scope (Korea) and accepted inputs (road/lot address or 14-digit property number). This distinguishes it from the registry_corporate_search sibling, which targets corporate registries instead.

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 routes the agent forward: 'pass the index of the resulting targets to registry_realestate_jobs_create', establishing this as the search step in a two-tool pipeline. It does not, however, state when to prefer this over the corporate variant or what inputs would be rejected.

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 only tell us it is a non-read-only, non-idempotent, open-world, non-destructive mutation. The description adds the costly side effects the agent cannot infer: a 20P charge on successful auth send, a mobile push notification to the user, and the fact that it returns transactionId/status but does not itself produce the documents. This is substantive behavioral disclosure beyond the 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?

Front-loaded with the purpose, then the side effects, then the workflow, then the caution. Every sentence carries information, though the trailing bracketed fee note is slightly tacked on and could be folded into the billing sentence.

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

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

For a high-complexity, 18-parameter, 9-required tool with no output schema, the description supplies the missing pieces: what it returns (transactionId, status), the required follow-up call, the user-confirmation prerequisite, and the billing side effect. Nothing essential for correct invocation 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 100% across all 18 parameters, so the schema already documents every field including enums, formats, and conditional requirements (e.g., fax_no for delivery=04). The description adds no parameter-level syntax or constraints, so the baseline 3 is appropriate.

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

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

States a specific verb (request simple identity authentication) and resource (business evidence document integrated issuance), and implicitly distinguishes itself from the sibling get_business_cert_bundle, which is the retrieval step rather than the auth request. An agent can tell the two apart without opening either schema.

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

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

Explicitly instructs to call only after user confirmation, forbids repeating requests while approval is pending and forbids auto-approval, and names the exact next step (pass transactionId to get_business_cert_bundle). Both when-to-use and when-not-to-use are covered.

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 only declare the safety profile (not read-only, not idempotent, open-world). The description adds high-value behavior beyond that: an approval-flow (returns transactionId/status, requires mobile approval), a non-idempotency warning (don't repeat the request), and a cost/notification disclosure (휴대폰 알림 발송, 20P billed on successful send regardless of lookup range).

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?

Front-loads the purpose, then the cost/risk warning, then the async flow and its warnings. Every sentence carries distinct operational value 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?

Even without an output schema, the description discloses the returned artifacts (transactionId and status), the required follow-up call, and the billing caveat, which is everything an agent needs to invoke and sequence this asynchronous authentication 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% and every parameter carries its own description, so the schema does the heavy lifting. The description adds no field-level syntax or constraints, making the baseline 3 correct.

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 the exact resource (현금영수증 소득공제 내역), and is clearly the authentication-request step of a two-stage flow. It is distinguishable from the sibling get_cash_receipt_deduction, which it explicitly names as the subsequent step.

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 explicit when-to-use (call after user confirmation), when-not (do not repeat requests while approval is pending, do not auto-approve), and the alternative/next step (pass transactionId to get_cash_receipt_deduction after approval). Nothing is left to inference.

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 declare readOnlyHint=false, idempotentHint=false, and openWorldHint=true; the description adds mobile notification dispatch, 20-point per-call billing, async phone approval flow, and prohibition on auto-approval, providing rich side-effect context beyond structured fields.

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?

Compact structure front-loads purpose, then billing warning, approval flow, prohibition, and cost; every sentence earns its place.

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

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

No output schema exists, but the description explains return values (transactionId and status), the required handoff to get_driving_license, and operational constraints; complete for an async billable authentication tool.

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

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

Schema description coverage is 100% with all four required parameters documented, so the schema carries parameter meaning; the description adds no syntax or format detail for name, birthDate, phone, or authProvider.

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 (request identity verification) and resource (driver's license lookup), and explicitly names get_driving_license as the downstream tool, distinguishing it from siblings.

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

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

Explicitly says to call after user confirmation, not to repeat while approval is pending, not to auto-approve, and to pass transactionId to get_driving_license after approval.

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