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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description usefully reinforces this by listing every endpoint as GET, but adds nothing about authentication, rate limits, or whether api_type='describe' returns a fixed shape. With annotations carrying the burden, this is adequate but not rich.

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

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

The intro is compact and the 12-row table is front-loaded, structured, and earns its space because the schema supplies no enum for api_type—the values must live somewhere. Slightly verbose in the header line, but no sentence is genuinely wasted.

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

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

Given an output schema exists, return values need no explanation, and the description covers dispatch selection and the parameter-discovery mechanism well. The only real gap is the unexplained account parameter, which the api_type='describe' escape hatch partially mitigates.

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 explain api_type (by enumerating valid values, necessary since the schema declares no enum) and the params container plus the 'describe' discovery pattern for params. However the third parameter, account, is never mentioned, leaving its semantics 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?

The description names a specific resource domain (Meritz Open API — account/계좌) and enumerates all 12 account operations with their HTTP method and a concrete Korean purpose for each, so an agent knows exactly what api_type values are available. It does not, however, explain how this account dispatcher differs from siblings such as meritz_trading or meritz_info, which could also touch account 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?

It gives clear invocation mechanics (pick api_type, put arguments in params, call api_type='describe' to fetch parameter docs), which is implicit guidance on how to use the tool. But it offers no when-to-use/when-not guidance and never routes the agent to a sibling tool for adjacent tasks, leaving alternative selection 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 blanket the whole tool as destructiveHint=true and idempotentHint=false, but the description narrows that by flagging only fx_exchanges (POST) with '⚠ 상태변경', telling the agent that the other three are read-style GETs. That is genuine added context beyond the annotations, though it omits auth requirements and rate limits.

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

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

Front-loaded with the resource and dispatch mechanism, then a compact table of the four sub-APIs with method and a one-word purpose plus the '⚠ 상태변경' marker. Every line earns its place and nothing is 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?

An output schema exists, so return values need no prose, and annotations cover the safety profile. The description supplies the dispatch contract, the valid api_type set, and a self-documentation path via 'describe'; only the account parameter and auth prerequisites are left unaddressed.

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

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

Schema coverage is 0%, so the description must carry the load, and it does for api_type: it lists the valid values (the four sub-APIs plus 'describe') and explains params as the container for sub-API arguments. The account parameter is left unexplained, and per-sub-API params are deferred to the describe call, so it is strong but not complete.

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 domain (메리츠 Open API — 환전) and enumerates the four sub-operations it dispatches (fx_exchanges, fx_exchanges_history, fx_rates, fx_rates_applied) with their HTTP methods and intent. This lets an agent separate it from siblings like meritz_trading or meritz_market, though the sibling differentiation is by domain naming rather than an explicit contrast.

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

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

It explicitly explains the invocation pattern (choose the API via api_type, pass arguments via params) and gives a concrete self-service path: api_type='describe' returns parameter descriptions. It stops short of stating when to prefer this tool over sibling tools, so it sits at clear-context without exclusions.

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

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

Annotations already declare readOnlyHint=true, so the description does not need to restate safety. It adds useful content categories (server settings, API catalog summary, known issues), but does not disclose any further behavior such as freshness of known issues, authentication expectations, or output limitations.

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

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

The description is a single front-loaded sentence with no filler. Every part contributes meaning: what data is returned and for which general purpose.

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

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

Given the zero-parameter schema, read-only annotation, and existing output schema, the description is largely sufficient. The only minor gap is the lack of sibling differentiation or usage context, but for a simple informational endpoint the provided content list is reasonably complete.

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

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

The tool has zero parameters and the schema has 100% coverage, so there is nothing for the description to explain about parameters. The baseline of 4 for a parameterless tool applies, and the description does not omit any parameter-related information.

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

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

The description states a clear verb ('returns') and specific resources: server settings, API catalog summary, and known issues. It distinguishes itself from the sibling domain tools (account, market, trading, etc.) by describing a meta/informational scope rather than a business operation.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as meritz_reference or the domain-specific tools. The purpose is clear, but the agent is left to infer usage context from the tool name and siblings.

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

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

Annotations already declare a safe read-only, idempotent, open-world operation, so the safety profile is covered. The description adds useful behavioral context (it is a multi-endpoint dispatcher and 'describe' performs parameter discovery) but omits auth/account requirements, rate limits, and whether 'describe' or an unknown api_type has side effects.

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

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

The purpose and dispatch convention are front-loaded, followed by a functional endpoint table where each line maps an api_type to a Korean label. It is long, but nearly every line is a distinct callable identifier rather than filler, so the length is justified.

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 an output schema present, return values need not be described, and the description supplies the essential dispatch model plus the api_type value set. The undocumented `account` parameter and the opaque params object are the only meaningful holes for a 3-parameter meta-tool, mitigated by the built-in 'describe' mechanism.

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 description carries the load by enumerating the 13 valid api_type values (not present as an enum anywhere in the schema) and defining the params/'describe' convention. It does not explain the `account` parameter, so a gap remains, but the compensation is substantial.

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 title/description states a specific resource ('국내 시세(주식·지수)' – domestic quotes for stocks and indices) and that it is a dispatcher over 13 sub-APIs. The enumerated endpoint list lets an agent distinguish it from meritz_overseas_market (overseas) and meritz_forex without opening any schema.

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

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

It clearly explains the invocation model: pick the API via api_type, put parameters in params, and use api_type='describe' to retrieve parameter docs. It gives strong in-tool routing but never states when to prefer this tool over siblings like meritz_overseas_market, so it lacks explicit when-not guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered structurally. The description adds the useful dispatcher behaviors (api_type routing, the 'describe' discovery mode) but says nothing about authentication requirements, rate limits, or the fact that the account parameter may be needed for certain calls. With annotations carrying the safety burden, this is an adequate but not rich 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?

Front-loaded with the domain and the two-sentence calling convention before the operation list, and the list itself is necessary given that the schema provides no enum. Each entry is terse (name, method, one-line purpose), though the method column (GET for every entry) is redundant.

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

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

An output schema exists so return values need no explanation, and the 'describe' mode mitigates the 0% schema coverage for per-API parameters. Still, for a dispatcher fronting 11 sub-APIs the agent is left without any guidance on the account parameter's necessity or on how this tool relates to the sibling meritz_market.

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 schema itself documents none of api_type, params, or account. The description compensates by explaining what api_type does and by providing a 'describe' escape hatch for per-API parameters, which is more than nothing — but it still does not enumerate the valid api_type values as an enum nor list any actual parameter names, leaving the agent to parse 11 names out of 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?

The description names a specific resource domain (해외 시세 — overseas quotes for stocks and indices) and enumerates all 11 sub-API operations it dispatches to, so the agent knows exactly what this tool covers. It does not explicitly differentiate itself from the sibling meritz_market (presumably domestic quotes), which is the only missing routing cue.

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 states the invocation pattern clearly — pick an api_type, put arguments in params, and call api_type='describe' to retrieve parameter documentation — which is genuinely actionable usage guidance. However, it never says when to prefer this tool over meritz_market or meritz_forex, nor does it give prerequisites such as whether the account parameter is required for certain sub-APIs.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds real behavioral context beyond that: all operations are GET, api_type='describe' returns parameter documentation instead of data, and the tool is a multiplexer over five fixed endpoints. Return format and auth requirements are not stated, but the output schema covers 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 preamble followed by a tight aligned list of the five operations; the 'describe' hint comes early where it is most useful. Every line earns its place with no filler.

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

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

For a dispatcher over five read-only endpoints with an output schema present, the description supplies the dispatch protocol, the operation menu, and a way to discover per-operation parameters. The unexplained account parameter and the absence of sibling-routing context are the only omissions.

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 api_type has no enum, so the description must carry the semantics — and it does, enumerating the five valid api_type values plus 'describe'. It also explains that params holds the per-call arguments, deferring detail to the describe mode. The account parameter is never explained, which is the only real 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 the resource (메리츠 Open API 기준정보) and enumerates all five concrete operations with their HTTP verbs and Korean glosses, so an agent knows exactly what the tool can do. It does not, however, distinguish itself from siblings like meritz_market or meritz_overseas_market, which cover overlapping market-days/hours concepts; that routing ambiguity keeps it below 5.

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

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

It explains the calling convention well — pick the operation via api_type and pass parameters in params — and offers a self-documentation escape hatch (api_type='describe'). But it gives no guidance on when to choose this tool over meritz_market/meritz_overseas_market, nor any exclusions, so usage is implied rather than routed.

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 destructiveHint=true and readOnlyHint=false for the whole tool, but the description adds granular value by flagging which of the 24 sub-operations actually change state (⚠) versus pure GET lookups. It also discloses the self-describing 'describe' escape hatch for parameter details. It stops short of covering auth, account selection behavior, or rate limits.

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

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

Purpose and usage rules are front-loaded in three short lines, followed by a dense 24-line catalogue where each line carries an id, verb, operation name, and risk marker. The list is long but every line is load-bearing since it enumerates valid api_type values; structure is clean and scannable.

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

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

With an output schema present, the description need not document return values, and annotations already carry the safety profile. For a dispatcher over 24 endpoints it is largely complete, with the notable remaining gap being the opaque params object and undocumented account parameter, only partially mitigated by the 'describe' mechanism.

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 properties carry descriptions, so the description must compensate. It effectively serves as the enum for api_type by listing the 24 valid values with their meanings, but leaves params (an arbitrary object) and account entirely unexplained except through the separate describe 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?

The description names the resource (주문/orders) and then enumerates all 24 concrete sub-operations with Korean labels and HTTP verbs, so an agent can see exactly what the tool covers. This is clearly distinguishable from the sibling groups (meritz_forex, meritz_account, meritz_market, etc.), which cover other API families. Purpose is unambiguous even before opening the schema.

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

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

It explicitly states the invocation pattern: pick an operation with api_type and pass arguments in params, and use api_type='describe' to fetch parameter documentation first. The per-endpoint ⚠ 상태변경 (state change) markers also guide the agent on which calls mutate state. What is missing is when-not-to-use guidance or any routing rule relative to the sibling category tools.

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