POKT Agent Korea data (x402 paid)

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

Annotations cover readOnlyHint and openWorldHint, and the description adds genuinely useful context beyond them: the exact set of metrics recomputed, the MATCH/MISMATCH return shape, and a payment requirement ($0.01 USDC via x402 on Base) which is important invocation context. It omits behavioral details like how tolerance_pct affects MATCH decisions, holding it back from 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 tight sentences, front-loaded with the core action and metrics, then the return format, then cost. No filler; the only minor question is whether the pricing sentence belongs in the description, but it is legitimately 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?

The readOnly annotation covers safety and the description usefully describes the return values in lieu of an output schema. However, with 7 undocumented parameters (including nested trades/claimed objects and behavioral knobs like tolerance_pct and initial_capital), an agent cannot confidently invoke this correctly from the definition alone.

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

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

Schema coverage is 0% across 7 parameters, so the description carries the full burden. It only touches the trade input ('trade list (CSV or JSON)') and the claimed numbers, leaving commission, tolerance_pct, initial_capital, single_position, and the trades/claimed structure completely undefined. The compensation is far short of what 0% coverage demands.

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 (recompute, compare) and the exact resource (net profit, win rate, profit factor, max drawdown, trade count from a trade list). An agent immediately understands it is a reconciliation/verification tool rather than a backtest runner. Siblings are unrelated, so no differentiation is needed.

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 (checking a claimed backtest against a trade list) but never states when to use it versus alternatives or any prerequisites. There are no exclusions or competing tools named, leaving usage 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 already declare readOnlyHint and openWorldHint, so safety is covered; the description goes beyond them by disclosing cost and payment mechanics ($0.005 USDC per call via x402 on Base), which materially affects whether an agent should invoke it. It still omits quota/error behavior and what happens when no corrections exist since the date.

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

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

Two tight sentences with the purpose front-loaded and the pricing clause second. No filler, no repetition of the name or title, and the differentiating 'before and after' detail is placed inside the core 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 read-only, two-parameter retrieval tool the purpose and cost are adequately covered, but with no output schema the agent gets no sense of the return shape, pagination, or volume, and the 0%-documented parameters are left underspecified. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description carries the full parameter burden, but it only gestures at the parameters ('by one Korean company', 'since a date'). It gives no corp_code format (e.g., DART 8-digit code vs. name) or the expected 'since' date format, leaving both parameters ambiguous at call time.

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: corrections and withdrawals filed on OpenDART for one Korean company since a date, with the distinctive 'before and after' changed-terms framing. It is clear what the tool returns, but it never names or contrasts itself with the very close sibling dart_correction_impact, so the differentiation is left to inference.

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 scenario (one company, since a date) implies when the tool is relevant, but there is no explicit when-to-use, when-not-to-use, or alternative routing despite a near-identical sibling (dart_correction_impact) in the toolset. An agent must guess which of the two correction tools to call.

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 readOnly=true and openWorld=true, so the safety profile is covered. The description adds genuine context beyond that: it is a paid call at $0.02 USDC via x402 on Base, and it describes what the response contains (corrections since filing, changed terms with before/after values, affected figures). The pricing/payment disclosure is materially useful and 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?

Three sentences front-loaded with the core question and the outcome, followed by the input hint and a compact pricing note. No filler, though the sentence packing multiple input and output clauses is dense.

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 well to describe the return payload and to disclose the paid-call model. However, for a five-parameter, zero-required-signature tool at 0% schema coverage, the unexplained 'since' and the 'corp' vs 'corp_code' ambiguity leave the agent guessing on required inputs.

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

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

Schema description coverage is 0% across five parameters, so the description must compensate. It maps roughly three params (company, cited receipt numbers, report text) to natural-language concepts, but leaves the 'since' parameter entirely unexplained and does not disambiguate 'corp' from 'corp_code'. It adds partial meaning but does not fully close the coverage gap.

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 purpose via a leading question ('Which parts of a report did a later DART correction change?') and then specifies the deliverable: corrections filed since, changed terms with before/after values, and affected cited figures. It is clearly a DART-correction-impact tool, but it never names or contrasts itself with close siblings like dart_changes or kr_figure_check, so an agent cannot disambiguate by 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?

Usage is implied through the input scenario ('Send a Korean listed company, the DART receipt numbers your report cites and/or the report text') and the output purpose (finding which cited figures are affected). There is no explicit when-to-use/when-not-to-use statement and no routing to alternatives among the sibling tools, leaving the agent to infer fit.

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, so the description carries real added value: it discloses the paid model ($0.005 USDC per call via x402 on Base) and that corrections are linked to originals with before/after values plus a point-in-time view. It stops short of covering rate limits or auth beyond payment, so it is not 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 sentences with the domain front-loaded, the content scope second, and the pricing detail last; each sentence carries information. The second sentence is somewhat information-dense but nothing is padding.

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 six-parameter tool with 0% schema coverage and no output schema, the description leaves too much unspecified: no parameter semantics, no return-shape explanation, and no differentiation from the closely related dart siblings. It describes the underlying data source well but not enough for an agent to invoke it correctly against alternatives.

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 six parameters at 0% schema description coverage, the description is the only place parameter meaning could come from, and it explains none of them (date, name, since, corp_code, stock_code, question). The single hint is that a company name can be given in Korean or English, which is marginal against a complete coverage gap.

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 (Korean listed-company OpenDART disclosures) and what it returns (filings, corrections linked to originals with before/after values, point-in-time view). It is clear on domain and content, but it does not differentiate itself from the near-identical siblings dart_changes and dart_correction_impact, and there is no explicit verb for the action it performs.

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

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

There is no when-to-use guidance, no exclusions, and no mention of the obvious alternatives dart_changes or dart_correction_impact. The only usage-adjacent hint is that a company can be asked about in Korean or English, which speaks to input language rather than 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 and openWorldHint, so safety is covered; the description goes further by disclosing the paid nature of the call ('$0.005 USDC per call, paid with x402 on Base') and the upstream data source, which are material facts an agent needs before invoking. It stops short of describing rate limits, latency, or failure modes.

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 and outputs, then input acceptance, then price. Dense and largely waste-free, though piling the API provenance and cost into the same long sentence slightly dilutes 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?

No output schema exists, and the description compensates by listing the returned fields (official forms, postal code, English address, building codes). Input shape and cost are covered; the only real gap is the undocumented 'limit' parameter and any pagination/truncation behavior.

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

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

Schema description coverage is 0%, so the description must carry the load. It explains what 'q' accepts (partial road+number or district+building, in Korean), which is genuinely additive, but it says nothing about the 'limit' string parameter or its format/default. Compensation is therefore only partial.

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 (normalise) and resource (Korean address) and enumerates the exact outputs: road-name and lot-number forms, 5-digit postal code, English address, building name/codes. It also names the upstream source (Ministry of the Interior road-name address API), which cleanly separates it from siblings like kr_name_romanize or kr_entity_resolve.

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 useful input guidance ('Accepts partial Korean addresses (road plus number, or district plus building)'), which hints at when the tool applies. However, it never states when to prefer it over kr_name_romanize, kr_entity_resolve, or kr_apartment_query, and provides no exclusions or limits on input scope.

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 supply readOnlyHint=true and openWorldHint=true, so the bar is lower. The description adds a genuine behavioral constraint not in the structured fields — 'Observed registered trades only' scopes the data — plus pricing and payment mechanics ($0.005 USDC per call via x402 on Base), which the agent needs to know before invoking.

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 dense sentences with the purpose front-loaded ahead of the scope caveat and the pricing. No filler, and the ordering puts the most decision-relevant content first.

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 names the returned aggregations (trades, median price, price per m2, grouped by district/month/complex) plus the scope and cost caveats. It is largely complete for a read-only query tool; the residual gap is the undocumented parameter semantics, which is scored separately.

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

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

Schema description coverage is 0% across 5 parameters, so the description must carry the load. It loosely maps 'by district, month and complex' onto region/month/apt, but leaves the difference between month (string) and months (integer) and the role of the required 'question' parameter unexplained, so the ambiguity between the two month parameters is unresolved.

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: Korean apartment sale prices from the MOLIT real-transaction register, and enumerates the outputs (trades, median price, price per m2). It does not, however, distinguish itself from the sibling kr_apartment_trend, which is the obvious near-neighbor an agent must choose between.

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 domain (you call it when you need apartment sale-price data from a Korean or English question), and the cost line hints at a decision factor. But there is no explicit when-to-use/when-not and no mention of the alternative kr_apartment_trend for trend-style requests.

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 the safety profile (readOnlyHint, openWorldHint), and the description adds genuinely non-derived context: the data source (MOLIT real-transaction register) and the per-call price of $0.005 USDC via x402 on Base. Cost and payment mechanism are exactly the kind of behavioral detail annotations cannot express, though rate limits and pagination are unaddressed.

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

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

Two sentences, front-loaded with the data resource and scope before the pricing note. No wasted words; the payment sentence is justified by the tool's paid nature.

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 usefully enumerates the returned metrics and the data source, which partially compensates for the missing output schema, and it discloses cost. But with 0% schema description coverage an agent still lacks the region/apt identifier formats needed to call it correctly.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It does map the params conceptually — region as a district, apt as a complex, months as a lookback window — but gives no format or identifier conventions for region/apt and does not explain why months is typed as a string.

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 resource and metric set: monthly trade count, median price, and median price per m2 for one Korean district or complex, sourced from the MOLIT register. An agent can tell what data it returns, though it never explicitly distinguishes itself from the sibling kr_apartment_query.

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

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

There is no when-to-use guidance. With a close sibling (kr_apartment_query) in the tool list, the description should say when this trend tool is preferable to the point-query tool, but it offers nothing.

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 safety (readOnlyHint) and open-world scope; the description adds real value beyond them — the cost ($0.005 USDC per call), the payment mechanism (x402 on Base), and the fact that it returns the list of skipped holidays. This is meaningful operational context for a paid tool, though pagination/response format is not described.

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 compact sentences, front-loaded with the core operation, then holiday semantics, then cost. No filler and every clause carries 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 two-param date arithmetic tool with no output schema, the description covers the operation, the calendar source, the skipped-holiday return, and the payment requirement. Only the exact response shape remains unspecified, a minor gap given the tool's simplicity.

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

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

Schema coverage is 100%, so the schema already documents both params including format (YYYY-MM-DD) and negative n. The description's 'after (or before)' restates the schema's 'negative for earlier' rather than adding new meaning. 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: computes 'the date N business days after (or before) a date'. It also names the holiday calendar it uses (KASI list, incl. substitute/temporary holidays), which distinguishes it from siblings like kr_business_day_check and kr_business_days_count.

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

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

Usage is implied by the operation (shift a date by N business days) but the description never states when to prefer this over kr_business_day_check or kr_business_days_count. No prerequisites or exclusions are given.

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

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

Annotations cover the safety profile (readOnlyHint=true, openWorldHint=true), so the bar is lower, and the description adds real operational context beyond them: the data source (KASI special-day list) and the per-call cost/payment mechanism ($0.005 USDC via x402 on Base). No disclosure of latency, caching, or rate limits, but pricing is a notable, non-obvious trait.

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 question, then adds returned fields and the payment note in two short sentences with no filler. Slightly more than minimal but each clause carries 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, so the description usefully enumerates what is returned, and the payment model is disclosed. The remaining gap is the undocumented date format, which an agent must guess at call time.

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 a single required 'date' parameter with 0% schema description coverage, and the description says nothing about its expected format (ISO 8601? YYYY-MM-DD?) or timezone handling. With structured data providing no semantics, the description should compensate and does not.

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

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

States a specific verb+resource ('Is a date a Korean business day?') and further specifies the returned content (weekday, weekend flag, official Korean public holiday names including substitute/temporary holidays). This clearly separates it from siblings like kr_business_day_add and kr_business_days_count, which manipulate rather than test a single date.

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 phrasing implies a single-date lookup, and the sibling set (kr_business_day_add, kr_business_days_count, kr_business_status) makes the distinction inferable, but the description never states when to prefer this over those alternatives or any prerequisites. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds genuinely useful behavior beyond that: the weekend-plus-official-holiday exclusion rule, the returned holiday list, and the payment/authentication model ($0.005 USDC per call via x402 on Base), which an agent must know before invoking.

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 dense sentences, front-loaded with the operation and its boundary rule; the pricing detail is tucked at the end where it belongs. No filler.

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

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

For a two-param read-only tool with no output schema, the description covers scope, holiday handling, result contents ('with the holidays in range'), and cost. The only meaningful omission is the expected date input format.

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

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

Schema description coverage is 0%, so the description must compensate. It does add the critical inclusivity semantics for 'from' and 'to', but gives no date format (e.g., ISO 8601), leaving a real ambiguity that an agent will hit on the first call.

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 ('Count Korean business days between two dates') and pins down the exact boundary semantics: exclusive of 'from', inclusive of 'to'. An agent can distinguish this from siblings kr_business_day_add and kr_business_day_check purely from the description.

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 boundary rule and holiday exclusion imply when this tool applies, but the description never routes the agent explicitly to or away from the close siblings (kr_business_day_check for single dates, kr_business_day_add for shifting). Usage is inferable but not 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 already cover readOnlyHint and openWorldHint, yet the description adds meaningful context beyond them: check-digit rejection of malformed numbers with no upstream call, the fact that results are not stored, and the per-call price/payment rail. It stops short of describing latency, rate limits, or error responses, but this is a substantive addition.

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 tight sentences, front-loaded with the core purpose and followed by the validation and pricing caveats; no filler. The pricing sentence is operationally relevant for an x402-paid tool rather than waste.

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

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

For a single-parameter tool with no output schema, the description names the returned semantics (status plus VAT taxpayer type) and discloses validation and billing behavior, which is close to complete. It could go further by noting the response shape or failure modes, but nothing critical 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 single b_no parameter is already fully documented as a 10-digit number, so the schema does the heavy lifting. The description reinforces the format constraint via the check-digit rejection note but adds no syntax or formatting detail beyond it — 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+resource (check a Korean business registration number) and enumerates the exact outputs: active/suspended/closed status and VAT taxpayer type. It does not, however, differentiate from the sibling kr_business_status_batch, which an agent selecting between single and batch modes would need.

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 KYB framing implies the use case (verifying a company before onboarding/transacting), but there is no explicit when-to-use versus when-not guidance and no mention of the batch sibling as the alternative for multiple numbers. Usage is inferable rather than stated.

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

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

Annotations already cover read-only and open-world semantics, and the description adds genuinely new behavioral context: a per-call price ($0.01 USDC), the payment rail (x402 on Base), and the upstream data source. It stops at 4 because nothing is said about how partial or invalid entries inside a batch of 100 are handled, which is the main failure mode for a batch tool.

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

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

A single front-loaded sentence: capability and batch limit first, then the enumerated return values, then source and cost. No filler or restated name/title.

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 one parameter, the description does the heavy lifting by enumerating the possible status values and the VAT-type output, plus live-source and pricing context. Missing are the input number format and batch error semantics, which an agent would need to call it confidently at scale.

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

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

Schema description coverage is 0%, so the description carries the burden; it tells the agent these are Korean business numbers and reinforces the 100-item ceiling (already in maxItems). It adds no format guidance (hyphenation, digit count) or array-of-strings example, so it only partially compensates for the coverage gap.

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+resource ('business registration check'), enumerates the returned statuses (active, suspended, closed, not registered) and VAT type, and its batch scope of up to 100 numbers cleanly distinguishes it from the singular kr_business_status sibling.

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

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

'up to 100 ... in one call' establishes the context in which this tool is preferred over a single-lookup tool, and being 'live from the National Tax Service' signals freshness. It never explicitly names kr_business_status as the single-number alternative or states any exclusion, 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 establish readOnlyHint=true and openWorldHint=true, so safety is covered; the description adds genuinely non-structured context: cost ($0.25 USDC per call), the x402/Base payment mechanism, and the 'facts only, not a rating' framing plus source-and-date provenance. It stops short of describing latency, failure modes, or what happens when an identifier matches multiple companies.

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 dense sentences, front-loaded with the resource and its output contents, then the provenance, scope disclaimer and price. Nothing is redundant and every clause carries information an agent needs.

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 heavy lifting by enumerating the returned sections and noting that each fact carries an official source and date, which is exactly what is needed. The remaining gap is the input side: five undocumented, non-required parameters leave the agent unsure which identifier to supply.

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?

Five parameters at 0% schema description coverage with no required fields, and the description explains none of them. It hints at lang via 'in English' but never maps b_no, query, corp_code or stock_code to their meanings, nor does it indicate whether any single identifier suffices or which takes precedence.

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 concrete verb+resource (Korea company due diligence / KYB report) and enumerates exactly what it returns: identity and IDs, NTS status, address, 3 years of financials, DART filings/corrections, auditor opinion, risk flags. This cleanly separates it from siblings like kr_company_resolve (identity lookup only), kr_business_status (status only) and dart_changes (filings only).

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

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

Usage is implied by the composite nature of the report, but there is no explicit when-to-use guidance, no mention that it is the aggregate alternative to the narrower sibling tools, and no note that an agent may need kr_company_resolve first to obtain the identifiers it accepts. No exclusions or prerequisites are stated.

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

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

Annotations already cover the safety profile (readOnlyHint=true, openWorldHint=true). The description goes beyond them by disclosing the paid-call behavior ($0.005 USDC per call via x402 on Base) and the ambiguity-handling behavior of returning candidates, which is genuine behavioral context an agent needs before invoking.

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, purpose front-loaded, followed by output and pricing. Dense but no filler; the only mild waste is the somewhat compressed list of return fields that could be phrased more cleanly.

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 steps in and names the returned identifiers (DART corp_code, Korean/English names, stock code, ambiguity candidates), which is exactly what an agent needs to chain calls. Pricing is also covered; only the sibling-routing guidance is missing for a perfect score.

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

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

Schema coverage is 0% and the single parameter 'q' is undocumented in the schema, so the description carries the burden. It does so well by enumerating the accepted input forms: Korean name, English name, or stock code, which fully explains the parameter's expected values.

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

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

States a specific verb (resolve/find) and resource (listed Korean company) with the accepted lookup keys. It is clear on its own, but it never distinguishes itself from the closely related sibling kr_entity_resolve or kr_company_due_diligence, leaving the agent to guess at boundaries.

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: the tool is evidently a first-step resolver whose corp_code feeds downstream DART tools, but the description never says when to choose it over kr_entity_resolve or other resolution siblings, and lists no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely non-obvious behavioral context: the data is normalized to structured English, sourced specifically from Upbit and Bithumb, and requires payment of $0.005 USDC via x402 on Base. It omits return size/pagination behavior despite the 'limit' parameter.

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

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

Two sentences, front-loaded with what the tool returns before the filtering and pricing details. Every clause carries information, though the enumeration of event types is somewhat list-heavy.

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 describing the returned event shapes (warning/release, delisting with effective time, suspension/resumption per network). What remains missing is pagination/limit semantics and date formats for 'since', which matters for correct invocation.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It names four of the five filters (ticker, exchange, type, and 'time' for since) but never explains the 'limit' parameter, nor the accepted formats for since or the string type of limit. Partial compensation for a fully undocumented 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 resource (Korean crypto exchange risk events from Upbit/Bithumb) and enumerates the event types returned (warnings, delistings, suspensions, upgrades, listings). This clearly distinguishes it from the adjacent kr_crypto_ticker_status sibling without needing to open 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?

The description says 'Filter by ticker, exchange, type and time,' which implies how to narrow results, but gives no explicit when-to-use guidance, no prerequisites, and never names or rules out the obvious alternative kr_crypto_ticker_status. Usage is inferable from the stated filters but left to the agent.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered; the description adds genuinely non-derivable behavior in the metered pricing model ($0.005 USDC per call, x402 on Base), which materially affects invocation. It does not state data freshness/latency or whether an unknown symbol errors or returns empty.

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 plus a pricing clause, with the core resource scoping front-loaded and the prerequisite usage condition second. No filler, and each clause carries distinct information (what, when, 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 enumerating the result fields (flags, delisting date, suspended networks), and it adds the cost and usage trigger. An agent has everything needed to decide to call it and to send a plausible symbol.

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

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

Schema description coverage is 0% for the single required parameter, and the description only implies it is a coin ("for one coin"), adding no format guidance such as whether to pass "BTC" or "KRW-BTC". It gives marginal meaning beyond the bare schema but leaves the identifier convention unresolved.

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 resource (Korean exchange risk status for one coin), scopes it to two named venues (Upbit and Bithumb), and enumerates the returned data classes (warning/caution flags, pending delisting with date, suspended networks). This is clearly distinguishable from nearby siblings like kr_crypto_events 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?

"Check before trading or routing a transfer to a Korean exchange" gives an explicit triggering condition and the decision it informs. No alternative sibling (e.g. kr_crypto_events) is named or excluded, so it stops short of a full when/when-not routing statement.

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. The description adds material behavior the annotations do not: a hard 100-item batch cap and, importantly, the paid model ($0.01 USDC per call, x402 on Base), which an agent must know before invoking. It does not mention rate limits or what a failed/low-confidence match returns.

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, then inputs, then price. Two sentences with no filler. Slightly dense in the enumeration but every clause conveys usable 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 correctly specifies the return shape (one canonical entity, all associated IDs, a confidence score). The main gap is the undocumented `limit_candidates` parameter; otherwise it is complete enough to call 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 0% (2 params), so the description must carry the parameter burden. It adequately explains `items` (quantity, accepted name/ID forms) but says nothing about `limit_candidates`, leaving the second parameter undocumented in both schema and prose.

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: 'match up to 100 company names ... or IDs ... to one canonical entity with all IDs and a confidence score.' It enumerates the accepted name forms (Korean/English, (주), Co., Ltd., typos, former names) and the ID schemes (BRN, corporate reg no., DART corp_code, stock code, LEI), which is unusually informative. It does not, however, differentiate itself from the sibling kr_company_resolve, which sounds highly overlapping.

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

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

There is no when-to-use guidance and no explicit alternative named. Given a near-identical sibling (kr_company_resolve), the description should say when to pick this crosswalk/batch resolver versus that one, but it leaves the relationship entirely 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 and openWorldHint, so the safety profile is already covered. The description adds genuinely useful non-schema context: the data provenance (Korea Customs Service) and, importantly, the paid-access requirement ($0.005 USDC per call via x402 on Base), which an agent must know before invoking. It still omits anything about latency, rate limits, or freshness beyond 'latest'.

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

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

Two sentences, front-loaded with what the tool returns and followed by the payment terms. Nothing is padded or redundant. Slightly dense in the first sentence, but every clause carries 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 does sketch the return shape (period-over-period comparisons plus item contributions), and it discloses read-only status implicitly via annotations and the payment model. However, the undocumented 'months' parameter and the absence of any tie-breaker against kr_exports_query leave real gaps for an agent deciding whether and how to call it.

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

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

The single parameter 'months' has 0% schema description coverage, so the description carries the full burden and fails to explain it at all — no format, no allowed range, no default behavior when omitted (required count is 0). A one-param tool with an undocumented parameter leaves the agent guessing how to scope the query.

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 the specific resource and comparison basis: latest Korean export period vs prior month and prior year at the same stage, with item-level contribution, from Korea Customs Service. That is far more specific than a tautology. It does not, however, distinguish itself from the sibling kr_exports_query, which an agent would reasonably assume covers the same 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?

There is no statement of when to use this tool versus kr_exports_query or any other export-related sibling. The description only implies usage through the data it returns. No exclusions, prerequisites, or alternative routing are given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely non-structured context: a concrete cost model ($0.005 USDC per call via x402 on Base), revision tracking behavior, provisional (10-day) data freshness, and an 'observed values only' constraint. It does not discuss rate limits or return shape, keeping it 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 front-loaded sentences: resource and data scope first, then input constraints, then pricing. No filler or repetition, though the pricing sentence competes with the substantive content for prominence.

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 data (provisional totals, changes, major items, HS codes, countries, revisions), so return content is reasonably conveyed. However, for a six-parameter tool with 0% schema coverage and no output schema, the filtering semantics of the four optional parameters remain 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 coverage is 0%, so the description must carry the burden. It loosely maps hs (HS codes), country (countries), and question (Korean/English question), and hints at time via 'change vs prior month and year', but gives no format, range, or interaction guidance for from, to, or months, leaving three of six parameters effectively undefined.

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 resource (South Korea exports from Korea Customs Service statistics) and enumerates the data content it serves: 10-day provisional totals, month/year changes, major items, HS codes, countries, revisions. Clear enough to place, but it never distinguishes itself from the very similar sibling kr_exports_pulse, leaving the agent to guess which export tool to pick.

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 states input constraints ('Korean or English question; observed values only') and pricing but gives no when-to-use, when-not, or alternative-tool guidance. An agent facing kr_exports_pulse alongside this tool has no stated rule for choosing between them.

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 the read-only/open-world profile, and the description adds genuinely new operational facts beyond them: cost ($0.01 USDC per call via x402 on Base) and the incomplete-verification behavior for unsourced numbers. It omits auth requirements or rate limits, keeping it from 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?

Core capability is front-loaded in the first clause, with verification semantics before the pricing tail. It is a single dense run-on sentence, but each clause (number classes, output markers, sources, unverified rule, price) carries information rather than 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?

With no output schema, the description usefully covers the return shape (MATCH/MISMATCH plus date and source). However, for a 4-parameter tool with zero schema documentation, the unexplained corp/year/as_of inputs are a real gap an agent cannot resolve from this text alone.

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

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

Schema description coverage is 0% and the description never explains the non-obvious parameters corp, year, or as_of, nor how they interact with text. Only the implicit notion of a date is hinted at via 'with date and source,' which is not enough to guide an agent supplying these inputs.

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 ('Fact-check numbers in Korean finance text') and enumerates exactly which number classes are checked (rates, KTB yields, FX, listed-company revenue/profit, % vs %p, 조/억/만 units). This clearly separates it from sibling lookup tools like kr_rates_query or kr_fx_rate, which fetch values rather than verify prose.

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 context for use: Korean finance text containing checkable numbers, and states the terminal behavior for unsourced numbers ('stay unverified'). It does not name an alternative sibling (e.g., kr_rates_query) or state a when-not-to-use condition, 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 cover read-only and open-world behavior, and the description adds genuinely useful context beyond them: the paid nature of the call ($0.005 USDC via x402 on Base) and the exact rate components returned. It stops short of stating cost/rate-limit failure behavior, but the payment disclosure is material.

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

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

One front-loaded sentence covering the core purpose and return content, with a short payment clause appended. No filler, though the payment sentence sits slightly apart from the main 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?

For a read-only tool with no output schema, the description usefully states what comes back (rates plus official date and source). Remaining gaps are input-syntax details (date/currency format, date default) rather than missing behavioral essentials.

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

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

Schema coverage is 0%, so the description carries the burden; 'for one currency on a date' does map ccy and date to their meaning. However it gives no format for either (ISO 4217? ISO date?), and does not explain what happens when the optional date is omitted, so the compensation is only partial.

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 resource and scope ('Won exchange rate for one currency on a date') and enumerates the returned rate types (KEXIM deal basis, TTB, TTS) plus the official date and source. Clear enough to distinguish from most siblings, but it never acknowledges kr_rates_query, which is the obvious overlapping 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?

The single-currency, single-date framing implies when the tool applies, but there is no explicit when-to-use, when-not-to-use, or routing to the near-neighbor kr_rates_query. An 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?

Goes well beyond the readOnly/openWorld annotations: it discloses exactly which features survive conversion (merged cells as HTML, text boxes, footnotes), which documents are supported (distributable 배포용), what happens to encrypted/DRM files (reported, not converted), and even the payment model ($0.01 USDC via x402 on Base).

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 verb+resource+output, then layers features, source examples, an edge-case boundary, and pricing. Every sentence earns its place; nothing is redundant or padded.

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 conversion tool with no output schema, the description covers what is converted, the supported input variants, the failure mode, and the cost. An agent has everything needed to decide and call correctly.

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

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

With a single url parameter and 0% schema description coverage, the description does at least establish that the input is a URL pointing at the document, but adds no syntax or format detail (e.g., direct-download requirement, content-type handling). Modest value over the bare 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?

Specific verb (Convert), specific resource (Korean Hancom HWP 5.x or HWPX documents at a URL), and specific output (Markdown with tables preserved). This clearly distinguishes it from generic readers like kr_web_read and from the other kr_* data tools.

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

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

The 'Typical sources' clause and the 'Encrypted or DRM files are reported, not converted' boundary give real usage context, but there is no explicit guidance on when to prefer this over siblings like kr_web_read, nor any statement of prerequisites beyond the URL.

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 the read-only and open-world profile. The description adds genuinely new behavioral context: the data provenance (National Law Information Center) and, critically, the paid-call model ($0.005 USDC per call via x402 on Base). Knowing a call costs money is material to invocation decisions and is not captured by any structured field.

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 compact sentences, front-loaded with purpose and followed by provenance and pricing. No filler, no repetition of the tool name, and each clause contributes an actionable fact.

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 states that the return is the official article text, and it covers cost and source. It does not address failure modes (unknown law name, out-of-range article number) or response shaping, which would be the remaining pieces for a paid lookup 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 0%, so the description must carry the load. It does clarify the 'law' parameter by enumerating accepted forms (Korean, common abbreviation, or English), which is real added meaning. However, the 'no' parameter is only described as 'article number' with no format guidance (e.g., '3' vs. '제3조'), leaving a real gap at 0% coverage.

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

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

The description gives a specific verb+resource: retrieving the official text of ONE article of a Korean statute, with named inputs (law name, article number) and an authoritative source (National Law Information Center). This makes the single-article scope clear enough to distinguish it from the sibling kr_law_query (search-style) without opening a schema, though it never names that sibling explicitly.

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

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

Usage is implied by 'one article of a Korean statute by law name and article number' – an agent can infer this is for precise single-article citation rather than searching. However, there is no explicit when-to-use statement, no mention of the kr_law_query alternative, and no guidance on what to do if the article is not found.

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 readOnlyHint=true and openWorldHint=true, so the safety profile is already declared. The description adds genuinely non-structured behavioral context: the upstream source, the returned fields (article number, effective date, source link), and critically the paid-call model ($0.005 USDC via x402 on Base), which an agent must know before invoking.

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

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

Two sentences, front-loaded with the core capability and return shape, ending with the cost/mechanism. No filler; every clause carries 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 pre-announces the return contents and the payment requirement, which is enough for an agent to call it. But the parameters — especially the two undocumented optional ones — leave a real gap for a 3-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 0% and none of the three parameters are documented anywhere. The description never explains the optional `no` and `law` parameters, leaving the agent to guess whether they pre-scope the search or are required for certain queries; only the implicit 'ask' maps to `question`.

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: natural-language lookup of a Korean statute returning the matching law and article text, with the source named (National Law Information Center). It does not, however, distinguish itself from the sibling kr_law_article, so an agent cannot tell from the description alone whether to query by question or by article reference.

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 — 'ask about a Korean statute in Korean or English' tells the agent the input style but gives no when-to-use/when-not guidance and never names kr_law_article as the alternative for direct article retrieval. With a near-identical sibling present, explicit routing would have been 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: this is a paid call at $0.005 USDC per invocation settled via x402 on Base, which an agent must know before calling. It stops short of describing latency, rate limits, or failure modes.

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 and the payment model is a short, distinct trailing sentence. The middle enumeration of romanization systems is long but each named variant adds real disambiguation value, so it earns its space despite the density.

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 returns. It hints at a candidate list for the reverse direction but never says what the forward romanization call returns (single string vs. all variants), and it omits the 'kind' parameter's effect. Adequate but with clear gaps for a two-parameter, no-output-schema 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 0% for both parameters. The description partially compensates by implying the 'name' input may be either Hangul or romanized text, but it never explains the 'kind' enum (person vs company) or how it affects output, leaving one of two parameters undocumented in both schema and description.

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

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

The description names a specific verb (romanise/map back) and resource (Korean names), and enumerates the concrete output systems: Revised Romanization, McCune-Reischauer, Yale, North Korean forms, passport spellings. It is bidirectional (Hangul→roman and roman→Hangul candidates), which clearly separates it from siblings like kr_name_sanctions_screen or kr_entity_resolve.

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 two directions described ('or map a romanised name back to Hangul candidates'), so an agent can infer the input shape. However, there is no explicit when-to-use guidance, no exclusions, and no routing to or away from related siblings such as kr_name_sanctions_screen or kr_entity_resolve.

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/openWorldHint annotations, the description discloses significant behavior: daily list refresh, ranked-candidate output that is not a determination, and the paid x402/USDC pricing model on Base. Cost and payment mechanics are exactly the kind of operational context an agent needs and cannot get from annotations alone.

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

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

Two tight, front-loaded sentences pack purpose, mechanism, output semantics, and price without redundancy. The pricing clause is slightly grafted on but still earns its place for an x402-paid 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?

No output schema exists, and the description usefully characterizes the return value as ranked candidates for review. However, with 6 parameters at 0% schema coverage, the definition is incomplete on input semantics, which an agent needs before calling.

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

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

Schema description coverage is 0% across 6 parameters, so the description carries the full explanatory burden. It only indirectly implies the 'kind' (person/company) and 'lists' parameters; dob, limit, and nationality are not addressed at all, leaving half the parameters undocumented in both schema and description.

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

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

States a specific verb and resource ('Sanctions screening candidates for Korean and North Korean names') and details the mechanism (romanisation expansion plus matching against OFAC/UN/EU/UK lists). This clearly distinguishes it from siblings like kr_name_romanize, which only transliterates, and kr_entity_resolve.

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 context is implied — screening Korean/NK names against official sanctions lists — but there is no explicit when-to-use/when-not guidance and no named alternative such as kr_name_romanize or kr_entity_resolve. The note that it returns candidates for human review rather than a determination is a useful usage qualifier.

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, but the description adds material behavior they do not cover: a per-call price ($0.005 USDC via x402 on Base) and the fact that results are official values tagged with series id, date and source. Payment terms are exactly the kind of context annotations cannot express. No rate limits, retry or failure behavior, hence not 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?

Two dense sentences, each clause load-bearing: coverage and sources first, then input-language flexibility, then return shape, then price. No filler and the most important scoping information is front-loaded.

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

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

With no output schema, the description correctly states what comes back (official values with series id, date, source), which is normally the missing piece. Coverage, sources, input modality and payment are all present; only edge cases such as unavailable series, date defaults or partial-day data are 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 0%, so the description carries the burden for both parameters. It gives real semantics — 'question' is a natural-language query in English or Korean, and 'date' scopes the result to a reference date — but omits date format, whether date is optional or defaults to today, and how the question is parsed. Partial compensation for a total coverage gap.

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 resource (Korean rates and FX) and enumerates exactly what is covered: BOK base rate, KOFR, CD, CP, KTB yields 1y-50y, and won FX from named sources (ECOS, KEXIM, customs). This cleanly distinguishes it from the narrower sibling kr_fx_rate, which covers FX only.

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

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

Usage is implied rather than stated: the agent can infer this is the tool for Korean rates/FX questions and that kr_fx_rate is the narrower alternative, but the description never explicitly sets a when-to-use or when-not boundary, nor gives prerequisites. Adequate but leaves routing 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 readOnly and openWorld; the description adds substantial behavior beyond them: deterministic extraction with no LLM, the exact field set returned, a known unsupported domain, and the payment model ($0.005 USDC per call via x402 on Base). Cost and auth mechanics are exactly the kind of context an agent needs before invoking.

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 purpose, then return fields, then constraints and price. No filler; each clause (supported sites, no-LLM, unsupported domain, cost) carries information the agent cannot get from schema or annotations.

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 return fields (title, author, published date, paragraphs, images, links), which is the main thing an agent needs. It is nearly complete; the only material gap is the unexplained max_chars behavior, which could lead to unintentional truncation.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. 'url' is self-evident, but max_chars is never mentioned — no hint that it truncates output, what the default is, or how it interacts with the 'clean paragraphs' return. This leaves one of two parameters entirely undocumented.

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 ('Read') and resource ('Korean web page as clean text') and enumerates the exact supported shapes: Naver Blog iframe posts, Naver/Daum News articles, generic pages. This is clearly distinguishable from every sibling tool, which are structured-data APIs rather than page readers.

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 scope (which site types work) and an explicit exclusion ('Naver Cafe is reported as unsupported'), which is real when-not guidance. It stops short of naming alternative tools or stating prerequisites for using it versus other fetchers, so it is clear context rather than a full routing rule.

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=false, so safety is covered; the description adds the non-obvious fact that this call is free while the listed tools are paid, and it discloses the shape of the returned payload. It omits response format/pagination details, but for a zero-param read that is a minor gap.

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

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

A single sentence with the cost qualifier front-loaded and the return contents listed compactly. No filler, nothing redundant with the schema or annotations.

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 returns and does so by enumerating price, input schema, example, and endpoint. It does not specify the serialization format or ordering of the list, which is the only remaining gap for an otherwise complete free discovery tool.

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

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

The tool takes zero parameters, so the baseline is 4; there is no parameter semantics for the description to clarify or for the schema to omit.

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

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

The description opens with a specific verb+resource ("Lists every paid tool on this server") and enumerates exactly what each entry contains: USDC price, input schema, example input, and the equivalent x402 HTTP endpoint. That is enough to distinguish it from every kr_* sibling, which are domain-data tools rather than a service catalog.

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 leading "Free." signals the cost distinction against the paid tools it lists, which is genuine usage context, but the description never states when to call it (e.g. before invoking a paid tool to discover prices) or any exclusion. Usage is only implied by the tool's nature as a discovery endpoint.

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