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

With no annotations provided, the description carries the full burden. It discloses the single-record ('단건') nature and the code-to-names mapping, which is useful. However, it does not mention behavior for unknown/invalid codes, return format details, or any error conditions.

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 concise sentence with no filler. The core semantic (input → output) is front-loaded and every word contributes value.

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

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

For a simple single-parameter lookup, the description covers the basic input/output relationship. But without an output schema, it would benefit from stating the expected response shape or behavior for missing codes. It is adequate but not thorough.

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

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

The schema only specifies a 'code' parameter with a generic title. The description adds meaning by clarifying that the code is a domestic freight classification code, which is important context. However, it does not specify the expected format or provide examples, leaving some ambiguity.

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

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

The description clearly identifies the verb (decode), the resource (domestic freight classification code), and the output (Korean/English names). It is distinct from sibling tools like decode_station_code and search_freight_code because it targets freight classification codes specifically, though it does not explicitly name those alternatives.

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

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

There is no guidance about when to use this tool versus alternatives. The description implies it is for decoding a single domestic freight code into names, but it does not state conditions for choosing it over search_freight_code or decode_station_code.

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

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

No annotations are provided, so the description carries full burden. It discloses important behaviors: simultaneous search of two systems and partial matching capability. However, it does not mention output formatting or error behavior (e.g., what happens if code not found). Given the output schema exists, some return details are covered, but not all edge cases.

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?

Description is compact, front-loaded with main purpose, then adds usage context, scope (two systems), and examples. No wasted words. Each sentence contributes essential 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 simple one-parameter lookup with an output schema, the description covers the essential usage context, systems searched, and matching behavior. It could mention what happens on invalid codes or whether results are singular/multiple, but the output schema likely handles return value definition. Overall, a very complete description for its complexity.

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

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

Schema has zero description coverage (0%), so the description must fully clarify the parameter. It does so: defines 'code' as a station code (numeric), gives concrete examples with full and partial codes, and explains partial matching. This adds significant meaning beyond the raw 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?

Description clearly states the tool's purpose: lookup station name by reverse numeric code. It also specifies the use case (when a code appears from another MCP response) and distinguishes from the freight-code sibling by naming station codes specifically. Example formats reinforce the purpose.

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

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

Provides clear when-to-use guidance: 'use when a code appears from another MCP response'. It also notes both systems are searched and that partial matching is supported. However, it does not explicitly mention alternatives (e.g., search_station) or when not to use it, but the context is strong enough.

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

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

No annotations are provided, so the description carries the full burden. It discloses the real-time nature and notes that on-site changes may not be immediately reflected. However, it doesn't mention authentication needs, rate limits, read-only nature (though implied by '조회'), or behavior on empty results. It adds some transparency but leaves gaps.

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

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

The description is compact and front-loaded with the core purpose. It then provides parameter details and a note about data recency. The multilingual translations (KR/EN/JA) add length but are useful for diverse agents. The structure is logical, though the translations could be trimmed without losing critical content.

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

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

Given the tool's simplicity (single parameter) and the existence of an output schema, the description covers the main purpose, parameter semantics, and a data-lag caveat. It does not address how to handle ambiguous station names or when to prefer this over closely related siblings. Given the richness of nearby tools, this is a significant gap, though not fatal.

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

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

The input schema has no description for the parameter (coverage 0%). The description compensates by explaining that station_name supports partial match and provides examples ('서울', '부산'). This adds meaning beyond the schema, but it doesn't clarify case sensitivity, multiple matches, or expected formats. It's helpful but not exhaustive.

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

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

The description clearly states the verb '조회' (lookup) and the resource, accessible facilities by station name, listing the specific facility types (wheelchair lift, accessible ramp, accessible restroom). It is specific enough to distinguish from many siblings, though it doesn't explicitly name an alternative. The mention of '실시간 API' and partial match adds clarity.

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

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

No guidance is given on when to choose this tool over alternatives such as get_urban_amenity or get_station_facilities, which likely overlap. It doesn't mention exclusions or conditions. The only usage hint is the partial-match parameter explanation, which is not about tool selection. This leaves the agent without clear selection criteria.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that it returns specific fields and that keyword performs a partial match on disclosure target. However, it does not mention any mutations, error conditions, pagination, or limitations, which is acceptable for a read-only list tool but leaves some gaps.

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

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

The description is concise and well-structured: it states the purpose, outputs, usage context, and parameter meaning in just three sentences. It avoids unnecessary detail and front-loads the core purpose.

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

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

Given the tool's low complexity (one optional parameter) and the presence of an output schema, the description covers the essential aspects. It explains what the tool does and the parameter meaning. It could mention the return shape or how this relates to detail/files siblings, but the output schema presumably covers return values, making this sufficient.

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

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

Schema coverage is 0% and the single parameter has no description. The tool description explicitly explains keyword as a partial match filter on 공표대상, adding meaningful semantics beyond the schema. This adequately compensates for the missing schema description.

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

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

The description clearly states it is a list inquiry for advance disclosures on the homepage and enumerates the provided fields (공표대상, 공표시기, 담당부서 코드). It also indicates use cases for transparency checks or searching items. While it doesn't explicitly differentiate from sibling detail/files tools, the purpose is unambiguous.

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

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

The description provides context on when to use it (management transparency check, searching specific disclosure items) but does not mention exclusions or alternatives. Sibling tools like get_advance_disclosure_detail and get_advance_disclosure_files exist but are not referenced, so the agent must infer when to choose this over others.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It does add useful behavior: keyword does partial-match filtering on title, dept_code does exact-match filtering, and the result includes title, department code, and view count. However, it does not disclose what happens when both filters are omitted, whether there is pagination, or any response-size/error behavior.

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

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

The description is compact and front-loaded: the purpose appears first, then the returned fields, then the parameter semantics. Every line earns its place and there is no 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 simple two-parameter lookup with an output schema, this is mostly complete: it explains what the tool returns and what each parameter does. The main missing context is a clear statement of how this detail tool differs from its advance-disclosure siblings, which is relevant given the large sibling list.

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 add meaning to the two parameters. It does: keyword is explained as a title partial-match filter and dept_code as a department-code exact-match filter. This goes well beyond the bare schema, though it does not specify the expected dept_code format or whether filters combine with AND logic.

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 resource (홈페이지 사전정보공표 세부 내역) and a query action (조회), and lists the returned fields. It is clear enough on its own, though it does not explicitly distinguish itself from the closely related siblings get_advance_disclosure and get_advance_disclosure_files beyond the word 'detail'.

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 guidance about when to choose this tool over get_advance_disclosure or get_advance_disclosure_files. It describes the available filters but not the intended scenario or how this detail-level query relates to the sibling list/file disclosure tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states what fields are returned, but does not mention whether the operation is read-only, pagination, authentication, error behavior, or any side effects. This is a minimal description that adds little beyond the obvious 'list' function.

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

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

The description is three short lines: purpose first, then output fields, then parameter hint. It is appropriately sized for a simple tool with one optional parameter, no filler, and front-loads the main 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 tool's simplicity (one optional param) and an output schema (which describes return shape), the description covers the core function and the parameter. However, it lacks usage context (when to use siblings) and behavioral notes (e.g., read-only nature). For a basic lookup tool this is acceptable but incomplete.

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

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

The schema has zero description coverage, so the description must explain parameters. It does clarify that 'keyword' is a partial-match filter on file name ('파일명 부분일치 필터'), which adds meaning beyond the bare 'string' type. However, it does not mention case sensitivity, encoding, or edge cases, so it is adequate but not rich.

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 specifies the action ('조회' – retrieve) and the resource ('첨부파일 목록' – attachment file list for advance disclosures), and lists the provided fields (file name, extension, linked disclosure number). This distinguishes it from sibling tools like get_advance_disclosure and get_advance_disclosure_detail, though it does not explicitly name these alternatives.

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 guidance on when to use this tool versus alternatives. It does not state conditions, exclusions, or prerequisites. The only usage-related hint is 'keyword: 파일명 부분일치 필터', which is a parameter explanation, not a usage guideline.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds critical nuance: '메뉴 건수' is line count not dish count, clarifying what the numbers represent. It also states the geographic scope. While it does not mention output format or pagination, an output schema exists, and the read-only nature is implied by '조회' (inquiry). The key behavioral nuance is effectively disclosed.

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

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

The description is laid out in a clear, front-loaded structure: a one-line summary, followed by scope, a crucial note, and parameter guidance. It is somewhat verbose but each sentence earns its place—the note about line counts vs dish counts is essential to prevent misinterpretation. The parameter explanation is directly actionable.

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

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

Given the tool is a simple stats query with one optional filter parameter, the description covers the essential aspects: what is returned (counts by meal and location), the semantic nuance, the filter behavior, and the coverage. It does not explicitly state that an empty location returns all locations, but that is reasonably implied. Since an output schema exists, return structure is handled separately. The description is sufficiently complete for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must fully explain the parameter. It does: location is described as a partial-match filter on cafeteria region name with concrete examples ('서울역', '부산', '대전', '본사'). This goes well beyond the schema, which only specifies a string type and default. The agent can correctly construct filter values based on this guidance.

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

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

The description uses a specific verb ('조회' = inquiry) and names the resource (구내식당 메뉴 건수 - cafeteria menu counts). It clearly distinguishes the metric: menu line counts per meal (조식·중식·석식), not actual dish variety, and specifies the nationwide scope with example locations. No sibling tool appears related, so differentiation is inherently clear.

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

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

The description explains the tool's purpose and provides usage context via the location filter examples ('서울역', '부산'). It does not explicitly mention when not to use it or alternative tools, but given the unique nature of the tool among siblings (no other cafeteria-related tool exists), the context is sufficient. The filter semantics are clearly described, making it easy for an agent to decide when to call this tool.

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

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

No annotations exist, so the description bears the full disclosure burden. It does convey the filter behavior (partial match) and the output fields, but it does not mention the effect of an empty headquarter parameter, ordering, pagination, or any required permissions. For a simple read operation this is acceptable, but it lacks richness given zero annotation coverage.

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

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

Two sentences plus a compact parameter hint. Purpose is front-loaded, and every sentence adds value—no filler or repetition.

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 tool has an output schema, so return-type details are covered elsewhere. The description provides the primary selection criteria (headquarter) and what fields to expect. A slight gap is not stating that an empty headquarter returns all departments, but this is inferable; overall it's complete for a straightforward list 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 input schema has 0% description coverage, leaving the headquarter parameter undocumented. The description steps in by explaining it as a '본부명 부분일치 필터' (partial-match filter) with concrete examples, giving the agent the meaning and usage beyond the raw schema.

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

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

The description opens with a specific verb-object pair: '철도 고객센터 담당 부서(역) 목록 조회' (retrieve list of customer-center departments/stations). It also names the exact fields returned (headquarter, center name, display name), which clearly distinguishes it from siblings like get_consultation_types or get_support_departments.

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

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

No explicit comparison to alternatives is provided. The name and description imply it is for consultation-department data, and the filter example gives a sense of when to use it, but there is no stated exclusion (e.g., 'for other department lists use X'). It's adequate but leaves the routing decision mostly to the agent's 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 are absent, so the description carries the full burden of behavioral disclosure. It states the tool is a '조회' (lookup), implying read-only, and enumerates the output fields. However, it does not specify the return format, pagination, or any behavioral constraints. For a simple lookup, this is minimally adequate but lacks depth about potential limits or response structure.

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

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

The description is two compact paragraphs: first states purpose and outputs, second explains the keyword parameter with examples. Every sentence earns its place, information is front-loaded, and there is no redundancy.

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

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

For a simple lookup with one parameter and an output schema, the description is largely complete. It covers what, outputs, and parameter semantics. It does not mention usage context or limitations, but the output schema handles return values. Minor gap: lack of differentiation from sibling tools, but that falls under usage guidance.

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 thoroughly explains the single parameter 'keyword' as a partial match filter on group name or type name, with concrete examples (운임, 예매, 분실). This adds significant meaning beyond the bare schema definition and fully clarifies the only parameter.

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

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

The description clearly states the tool retrieves railway customer service consultation type codes and lists specific fields (major/minor classification, group name, code, type name). The verb '조회' (retrieve) and resource are specific. However, it does not explicitly differentiate from the sibling tool get_consultation_departments, which is likely related, so it misses sibling differentiation.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention any exclusionary conditions, alternatives, or prerequisites. It only explains the keyword parameter's purpose, which is parameter usage, not usage context. An agent has no hint that get_consultation_departments might be more appropriate for department codes.

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

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

No annotations are provided, so the description must cover behavioral aspects. It states that results are daily and include participation and average score, which is useful. However, it does not mention pagination, default date range handling, empty-parameter behavior, or any error conditions. For a read-only stats tool, this is adequate but not comprehensive.

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

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

The description is concise and front-loaded with the main purpose. It has a slight redundancy between the first line and the second paragraph, but overall it is efficient and structured with parameter explanations. No fluff, and it uses bullets for parameters for clarity.

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 (not shown), so return values need not be detailed. However, the description does not mention any limits, pagination, or behavior when no data matches. It gives examples for parameters but not edge cases. For a moderately simple stats tool, it is adequate but could be more complete regarding default behavior and result interpretation.

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

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

The schema has zero descriptions for parameters, so the description effectively compensates. It explains date_from/date_to as the survey date range with example format, and day_of_week as a filter with example values. This adds meaningful semantics beyond the bare schema, though it does not clarify optionality or behavior when fields are empty, but the examples are helpful.

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

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

The description explicitly states the purpose: providing daily customer satisfaction statistics from the railroad customer center, including participation count and average score. The verb '조회' (inquiry) and specific resource are clear, and the tool is unique among siblings, so no confusion with alternatives.

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 domain context (railroad customer center satisfaction survey) but does not explicitly state when to use this tool versus others. There are no direct sibling tools for customer satisfaction, but it lacks explicit guidance on usage scenarios or exclusions. The context is clear enough for an agent to infer, but not explicitly 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses that the operation is an inquiry ('조회'), that there are 15 records, and that the codes are categorized with specific fields. This is sufficient for a simple read-only lookup, though it does not state behavior when group is 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?

The description is compact, front-loaded with the core purpose within the first line, and uses a clear bullet-style parameter explanation. There is no redundant or filler content.

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-optional-parameter code lookup, the description covers the essential context: purpose, result count, output semantics, and how to apply the filter. The output schema is present, so return format need not be re-explicated. A small gap is not clarifying what happens when group is omitted, but the schema default already suggests empty means unfiltered.

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

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

The schema has only a parameter title and no description (0% coverage). The description compensates by explaining 'group' as a code group filter with concrete examples ('장기', '기타'), adding meaning beyond the raw schema. It does not exhaustively list valid values, but enough information is provided.

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

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

Description states a precise verb and resource: 조회 (retrieval) of employee dormitory long-term reservation reason codes. It goes beyond a simple label by specifying the output shape (group/value/name) and the distinction between '장기' and '기타', making the tool's function unmistakable.

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

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

The description clearly implies when to use this tool: when querying reason codes for long-term dormitory reservations. It provides a group filter with examples but does not explicitly mention alternatives or exclusions; however, the domain is specific enough that no ambiguity remains.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool returns dispatch tons and ton-km, and that it supports date/station/item filtering, but does not mention response format, pagination, or default behavior when no filters are set. Not contradictory, but incomplete.

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

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

Well-structured: a two-sentence Korean intro states purpose and capabilities, followed by a clear Args list with definitions. No redundant or filler content; front-loaded and efficient.

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

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

The description covers all parameters and indicates the returned data (ton and ton-km). It leaves ambiguity about default behavior when no date filters are provided and whether station code vs name are required, and doesn't clarify output structure, though an output schema exists. Overall slightly incomplete for a 10-optional-param tool.

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

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

Schema coverage is 0%, and the description compensates fully by explaining each of the 10 parameters, including format (YYYYMMDD), meaning (gte/lte), and concrete examples like '3900090'=약목. This adds significant value beyond the schema.

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

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

Description clearly states the tool queries freight train transport performance (화물열차 수송실적 조회), providing dispatch tons and transport ton-km for station-to-station segments, with filtering by freight classification and item categories. This distinguishes it from siblings like get_freight_items (item list) or search_freight_code (code lookup).

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 usage for retrieving freight performance statistics, but does not explicitly state when to use it versus alternatives or exclude certain cases. It provides context (segment-based performance with date/item filters) but no direct 'use this when' 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose the local CSV source and the 861-record scope, and implies a read-only operation, but never explicitly states it's non-destructive, doesn't describe the return format (a flat list vs. nested hierarchy), and doesn't mention pagination beyond the limit parameter behavior.

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

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

Three short sentences, front-loaded with the purpose. The record count (861건) and local CSV source are useful context. Not verbose, though the hierarchical code detail could arguably be moved to a usage note without losing purpose clarity, keeping it compact overall.

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 no annotations, the description should cover return format, error cases, and parameter semantics more thoroughly. It covers data fields, hierarchy, and empty-query behavior but omits what the response looks like (e.g., a single flat item table), how query matches (prefix, partial, exact), and any edge cases. Adequate for basic usage but not fully complete for a 2-param 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 compensate. It explains the query parameter's behavior (empty query returns top-level items first) and the hierarchical structure of codes, which adds meaning beyond the bare schema. It doesn't fully document the limit parameter semantics though, which is a minor gap given the description clarifies the core query behavior.

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

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

Description uses a clear verb+resource pattern (화물 품목정보 조회, freight item info lookup) and specifies the data fields (품목코드·품목명·품목약어명·최저톤수율). It distinguishes itself from sibling tools like search_freight_code and decode_freight_code by being a list/lookup tool rather than a code search/decoder, though it doesn't name those siblings explicitly.

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

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

The description explains the empty-query behavior (빈 query시 상위 항목부터 limit 반환) and the hierarchical code structure, giving an agent context on how the query parameter behaves. However, it doesn't contrast with alternative freight-related tools (search_freight_code, decode_freight_code, list_freight_work_lines), so an agent may not know when to pick this over those.

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

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

With no annotations, the description carries the full disclosure burden and does well beyond a bare statement: it reveals historical data is included, defines current_only as filtering to entries with an end date after 2100, and lists the returned fields. The term '조회' implies a read operation, though it does not spell out read-only behavior explicitly.

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 opens with a concise purpose statement and then uses clearly organized Args and Returns sections. Every sentence adds semantic value, and there is no redundant or filler content.

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

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

For a simple read tool with three optional parameters and no output schema, the description supplies the essential information: filters, defaults, and return columns. It is only slightly incomplete in not addressing when to prefer this over similar freight-rate siblings and in omitting empty/error 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 fully compensates by explaining each parameter: fare_type with an example, classification_no with example values, and current_only with precise conditional semantics. No parameter is left 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 uses a specific verb and resource ('조회합니다' for freight minimum fare standard info) and includes the notable detail that 7 records including historical history are returned. It is clear, but it does not explicitly distinguish itself from the similar sibling get_freight_rate, so it stops short of full differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. The Args section explains parameter defaults and the current_only filter, but there is no mention of when this tool should be chosen over related freight or rate tools.

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

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

No annotations exist, so the description carries the full burden — and it meets it: it discloses the filtering rule for current_only (applied-end date after 2100), the valid-versus-total record counts, and the exact return fields. This gives an agent real behavioral expectations beyond a bare 'query rates' statement.

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?

Cleanly organized with Args and Returns sections, purpose front-loaded, and every line earns its place — the record-count context and the container-rate note are genuinely useful. Minor verbosity in the parentheticals but nothing disposable.

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 no annotations, the description carries the full weight and covers return values explicitly (신청구분, 분류번호, 적용임율, etc.) plus filter semantics. Nothing an agent needs to invoke it correctly is missing for a simple query 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 fully compensate, and it does: every parameter is explained with concrete examples ('일반', '컨테이너', '10', '1001'), plus a non-obvious domain note that 1xxx classification numbers are container rates while 10~80 are general freight — knowledge not derivable from the schema.

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

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

States a specific verb (조회/query) plus a precise resource, 철도 화물 임율 (rail freight rate on ton-km basis), and scopes it clearly. Despite many freight siblings (get_freight_minimum_fare, get_freight_items, get_freight_carriage), the ton-km rate focus sets it apart without needing any schema inspection.

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?

Documents the three filter parameters thoroughly and implies they are optional filters, but never contrasts this tool with the freight siblings, nor states when to prefer it over get_freight_minimum_fare or search_freight_code. Usage is implied rather than explicitly 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?

Since no annotations are provided, the description fully carries the behavioral disclosure burden. It reveals the data source (local CSV), as-of date, the two-table integration, and the matching semantics (partial vs exact). However, it does not mention the return format, error behavior, or performance implications, which would be useful. For a read-only query tool, the provided info is adequate but leaves some gaps.

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 appropriately sized and structured. It opens with the core purpose, then lists parameters in a clear dash-bullet format, and closes with a useful grade legend. The grade legend is slightly tangential but helpful for parameter values. Overall, every part serves a purpose, though it could be tightened slightly by moving the legend into the grade parameter description.

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

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

With no output schema and a moderate complexity (joining two tables), the description explains how to query but omits what the response looks like (fields, structure). It also doesn't specify pagination or total result counts beyond the limit parameter. This is a notable gap for an agent needing to interpret results, but for a simple lookup it's not severely impaired.

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 is the sole source of parameter meaning. It explains all three parameters (query, grade, limit) with concrete examples ('가스', '아세틸렌', '1001'), grade mapping, and a default limit value. This adds substantial value beyond the bare schema, fully compensating for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: retrieving hazardous cargo information from a local CSV (as of 2025.09.15), integrating two specific tables. This is distinct from all sibling tools, none of which relate to hazardous materials, so there's no ambiguity about what it does.

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

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

The description provides detailed usage for each parameter (query, grade, limit) with examples and default values, which effectively guides the agent in invoking the tool. While it doesn't explicitly state 'use this when you need hazardous cargo data,' the unique domain among siblings makes this implicit, and the parameter-level guidance is strong.

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

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

With no annotations present, the description carries the behavioral disclosure burden. It explicitly discloses that omitting keyword returns only the first 200 records and recommends splitting calls for full retrieval, which is non-obvious and valuable. It does not mention other behavioral aspects like auth or rate limits, but for a read-only lookup this is adequate.

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

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

The description is compact and well-structured: the purpose statement comes first, followed by field details, then a clearly formatted keyword note with an important pagination warning. Every sentence earns its place with no redundancy.

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

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

For a tool with a single optional parameter and an output schema, the description covers everything an agent needs: the returned fields, how the parameter behaves, and the limitation of unfiltered queries. No critical information is missing 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?

The schema has zero description coverage for the 'keyword' parameter, so the description must compensate. It does so by explaining it as a partial-match filter on department name, providing examples, and explaining the consequence of omission. This adds substantial meaning beyond the raw schema.

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

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

The description clearly states it queries KORAIL homepage department information and lists the exact fields returned (DEPT_NM, DEPT_CODE, UPPER_DEPT_CODE). The verb and resource are specific, though it does not explicitly distinguish from sibling department-related tools like get_consultation_departments or get_info_disclosure_dept.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only covers how to use the keyword parameter (partial-match filtering and the 200-record limit), but does not address tool selection or exclusion scenarios.

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

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

No annotations are provided, so the description carries the full burden. It states the output fields and the keyword filter behavior, but does not explicitly confirm it is read-only, nor mention side effects, pagination, or handling of empty keyword. Over a '조회' (inquiry) verb implies non-mutating, but it is not explicit, and no additional behavioral context is given.

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

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

The description is three short lines with no filler. It front-loads the purpose and then explains the parameter. Every sentence adds value and there is zero redundancy.

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

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

For a simple one-parameter lookup, the description is mostly sufficient: it states the returned data and the filter meaning. However, it does not mention what happens when keyword is empty (e.g., returns all or none) or offer any alternative tools, leaving minor gaps that an agent might need to infer. The presence of an output schema covers the return structure.

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

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

The description explains the only parameter, 'keyword', as a partial match filter on job title name, which adds meaning beyond the schema's generic 'Keyword' label. It does not specify details like case sensitivity or behavior when empty, but the core semantics are clearly conveyed.

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

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

The description clearly states the tool inquires about KORAIL homepage job position codes and lists the returned fields (ID, name, code). It is specific about the resource and action, though it does not contrast with sibling code-lookup tools, leaving some potential ambiguity.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention that it is specifically for homepage positions, nor does it offer exclusions or point to sibling tools like get_job_grades. The usage context is only implied by the tool name.

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

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

With no annotations, the description carries the full burden. It discloses the returned fields and the filter behavior (empty value = all), providing basic transparency. However, it does not mention whether the operation is read-only, any access requirements, or the response shape beyond the output schema, so it 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 description is compact and efficient, with each line serving a purpose: it states the resource, the returned fields, and the parameter semantics. No wasted words.

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

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

For a simple lookup tool with an existing output schema, the description covers what it returns and how to filter. It lacks explicit mention of read-only behavior or edge cases, but is largely complete for its 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?

The single parameter code_type is explained beyond the schema: it is a filter matching CODETYPE and that an empty value means all. Since schema description coverage is 0%, this description adds meaningful semantic value that the schema lacks.

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

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

The description clearly states this tool retrieves common codes for the information disclosure system, and lists the fields provided (CODETYPE, CODENAME, usage status). While this distinguishes it from other code-lookup siblings by naming a specific system, it does not explicitly contrast itself with those siblings, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or reference other code-lookup tools, leaving the agent to infer the appropriate context from the tool name and sibling list.

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

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

No annotations are provided, so the description carries the behavioral burden. '조회' indicates a read operation and the description lists output fields, but it does not disclose any potential side effects, error behavior, or special constraints beyond the keyword filter. For a simple list retrieval this is acceptable but not thorough.

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

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

The description is concise, completing its message in three short lines. It front-loads the purpose and fields, then explains the keyword. No filler or redundant content.

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 low-complexity tool with one optional parameter and an output schema (which defines the return structure), the description covers purpose, returned fields, and parameter behavior. Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly explains the sole parameter 'keyword' as a partial-match filter on department name (부서명 부분일치 필터), adding meaning beyond the schema's bare definition. This is clear and sufficient.

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

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

The description clearly states the verb (조회/retrieve) and resource (정보공개 담당 부서 목록/list of information disclosure departments), and lists the specific fields returned (부서코드, 부서명, 상위부서명). This distinguishes it from sibling department-list tools like get_consultation_departments and get_homepage_dept by its specific scope.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or context. The description only states what it does and the keyword filter; an agent has to infer when it would be appropriate compared to other department or lookup tools.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses the data scope (109 records, what fields exist, job-category breakdown), which is useful. However, it doesn't explicitly state note whether the operation is read-only, whether it supports pagination, or what the exact output shape is beyond the field list. Since an output schema exists, some of this burden is reduced, but the description could still state that it's a safe lookup.

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 tightly structured with a summary line, a data-overview line, and clearly separated parameter documentation. The Korean formatting is compact, front-loads the purpose, and every sentence earns its place. The parameter blocks are formatted simply and readably.

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

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

For a simple lookup tool with an output schema present, the description is nearly complete. Both parameters are fully documented with default values visible in the schema, the result content is described, and the 109-item scope sets expectations. The only minor gap is that the output schema presumably covers the return shape, so nothing critical is missing. Slight deduction for not explicitly stating that the operation is non-destructive, but with an output schema and no mutation verbs in the description, this is a minor omission.

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%, but the description fully compensates. Both parameters are documented in detail with semantics and concrete examples: grade_level is exact-match (예: 3 → 3급 전체), keyword is partial-match (예: '운전', '차량', '사무영업'). The examples make filter behavior unambiguous. This is exemplary parameter documentation with zero coverage in the schema.

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

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

The description states a clear specific verb-resource pair ('직급 코드 정보 조회' - retrieve job grade code information) and lists exactly what is returned: grade level, grade name, and grade code. It also specifies the number of records (109건) and the categories covered. It doesn't explicitly differentiate from siblings, but among a list of lookup tools, its domain (job grades) is clearly its own.

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 description being a lookup/retrieval tool, but there is no explicit when/when-not guidance or mention of alternatives. For a simple reference-data lookup among many sibling get_* code and department tools, the context is clear enough that an agent can infer when to call it (when grade info is needed), but it doesn't explicitly state exclusions or preferred alternatives.

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

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

With no annotations, the description carries the behavioral burden. It discloses that data comes from a local XLSX file, explains partial matching for route, and defines the default behavior of returning all categories when category is empty. However, it does not mention performance, authentication, or error handling, leaving some transparency gaps.

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

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

The description is well-structured with a header, scope statement, and bullet-point-like list for category values, followed by concise explanations for route and years. It is front-loaded with the purpose and avoids redundancy, though it could be slightly tighter by combining the year filter explanation.

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

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

The description covers all parameters and data scope, and the output schema exists, so return format is not needed. However, it leaves a gap: the defaults for year_from/year_to are ambiguous—the schema defaults to 0, but the description does not explicitly state that an empty or zero value means 'all years' (unlike category and route where it clearly states empty means all). This is a notable missing detail for an agent to use the tool correctly.

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

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

Schema description coverage is 0%, so the description fully compensates. It explains every parameter: category with four specific values and a default of returning all, route with partial match and default of all, and year_from/year_to with an example range. This adds substantial meaning beyond the bare schema types and defaults.

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

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

The description clearly states the tool retrieves KTX long-term statistics (2004-2023) for two specific routes, with a clear verb ('조회' = query) and resource. It distinguishes from sibling tools by being KTX-specific and long-term, and lists the exact data categories and data source (local XLSX).

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 usage (for querying KTX long-term stats) but does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions. While the tool's specificity makes the choice obvious, there is no guidance on when not to use it or which sibling might be more appropriate for other statistics.

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

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

No annotations are present, so the description carries the full burden. It discloses the result count (총 102건), the return fields (고속철도명, 철도운영기관, 노선명, 순번, 역명, 주소(도로명) 목록), and the partial-match filtering behavior for both parameters. However, it does not explicitly state that the operation is read-only, nor does it mention error conditions or side effects, which is a gap given the lack of annotations.

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

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

The description is concise and well-structured: a one-line summary, an Args block with each parameter explained individually, and a Returns block. No redundant or filler content. The most important information is front-loaded in the first 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 simple lookup tool with two optional filters, the description is nearly complete. It states what is returned, how to filter, and the total record count. The only minor omission is an explicit note that results are limited to KTX stations (though that is evident from the name) and no mention of error behavior, but these are not critical 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 fully compensate. It does so excellently: line_name is explained with examples ('경부선', '호남선', '경전선') and the default behavior (없으면 전체), while station_name similarly provides examples ('서울', '부산', '광명') and default (없으면 필터 없음). This adds far more meaning than 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?

The description clearly states the tool's purpose: 'KTX 노선별 역 정보(역명, 도로명주소, 정차 순번)를 조회합니다', specifying the verb (조회), resource (KTX 노선별 역 정보), and the exact fields returned. This effectively differentiates it from generic station tools like search_station or list_stations_by_region, though it does not explicitly name alternatives.

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 guidance on when to use this tool versus the many station-related siblings. It only explains the two optional filters and their defaults, leaving the agent to infer that this is KTX-specific. No 'when-not-to-use' or alternative mentions are provided.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explains the tool provides a real-time REST API, returns code tables with fields type, code, value, and describes filter behavior per parameter. This adds behavioral context beyond the schema, though it doesn't detail response format (covered by output schema) or edge cases like empty results.

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

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

The description is compact and front-loaded: the purpose is stated first, then structure, then parameter semantics. No filler or redundancy.

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

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

Given the output schema carries return details, the description is adequate for calling this tool. It covers parameters, purpose, and basic structure. Missing are explicit examples or disambiguation from other code lookups, but these are not critical for a simple 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 fully compensates by explaining each parameter: 'code_type' exact match, 'code' exact match, 'value' partial match. This is precisely the semantic meaning an agent needs.

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 it's a 'lease system code lookup' providing 'lease-related classification code tables'. The specific verb '조회' (lookup) and resource '임대 관련 분류 코드표' (lease-related classification code table) clearly distinguishes it from sibling code tools like get_train_codes or get_transport_stat_codes.

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 doesn't explicitly mention when to use this tool versus alternatives. It provides the purpose and filter semantics but no guidance on when other code tables are more appropriate. Usage context is implied by the tool's name and description but not explicit.

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

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

With no annotations provided, the description carries the full burden. It clearly indicates a read-only query ('현황 조회') and enumerates the data returned, implying no side effects. It also notes the data volume (1,773 records) and partial-match filter behavior, providing useful behavioral context beyond mere operation. However, it doesn't explicitly mention pagination or any limits, but for a simple read-only lookup, this is acceptable.

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

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

The description is well-structured: it opens with the core purpose, lists the data fields, clarifies the distinction from a sibling, and then details each parameter with examples. Each sentence contributes value without redundancy. It is longer than two sentences but remains efficient and front-loaded with the primary directive.

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 tool is relatively simple with two optional parameters, and the description covers the data returned, parameter semantics, and a key sibling distinction. An output schema exists, which likely documents the return structure, so nothing critical is missing. The description is sufficient for an agent to invoke the tool correctly without additional context.

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

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

The input schema has 0% description coverage, so the description must compensate, and it does excellently. It explains that location is a partial-match filter on asset location with examples ('서울', '대전') and facility_name is a partial-match filter on facility name with examples ('서울역', '용산역'), giving agents precise meaning and usage patterns beyond just the schema's string type and default.

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

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

The description explicitly states the tool queries leased assets of the Korean Railroad Corporation and lists the exact fields provided (location, facility name, contract period, area, annual rent), making the purpose unambiguous. It also directly distinguishes itself from the sibling tool get_lease_stores by clarifying this is an asset/financial perspective rather than store operations, which helps an agent select correctly.

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 names the sibling get_lease_stores and draws a clear distinction, effectively telling the agent when not to use this tool (when store operational info is needed) and when to use it (for asset/financial data). It also provides filter usage examples (e.g., '서울', '대전') that clarify how to apply parameters, though it does not explicitly state broader scenario conditions.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does disclose that the API is '실시간 REST API' (real-time) and reveals in the title that it is a read operation (get), but it omits auth requirements, pagination/large-result behavior, whether the data is volatile, and any error or empty-result semantics. For an unannotated tool this is a noticeable 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?

The purpose is front-loaded in the first line and the paragraph is compact. The field list is useful, and the parameter section is well organized into a three-line block that mirrors the schema. Minor redundancy in repeating '필터' (filter) for each parameter, but overall every line earns its place.

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

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

An output schema exists, which relieves the description of documenting return-value structure. Combined with full parameter documentation (6.4) and the stated real-time nature, an agent has most of what it needs to invoke the tool correctly. Remaining gaps are pagination/result-volume behavior and known limitations on result count for broad queries with all parameters empty.

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%, putting the entire burden on the description, which fully compensates. All three parameters (store_name partial match, station_code exact match, station_name exact match) are documented with match semantics and concrete examples (e.g., '파리바게뜨', '0001', '서울역'). This is exactly the value the description should add beyond 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?

Description states a specific verb (조회/inquiry) and resource (임대매장/lease stores within stations), and lists the fields returned (store name, location, station, headquarters, dates, hours), making it distinguishable from get_lease_codes and get_leased_assets by subject matter. The field list gives concrete substance, but it doesn't explicitly contrast against its closest siblings, so it stays below a 5.

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

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

The description explains how to use each filter (partial vs exact match) with Korean examples, which is genuine usage guidance. However, it never tells the agent when to choose this tool over get_lease_codes or get_leased_assets, nor does it state exclusions or context. Filter mechanics are covered but tool-selection context is absent.

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

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

With no annotations, the description takes on full responsibility. It discloses that results combine three data sources and provides data counts, which is useful. However, it does not explicitly state read-only nature, pagination, or error behavior, leaving some behavioral aspects implicit.

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

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

The description is concise—two sentences that efficiently convey purpose, filters, and return content. It includes specific data counts that add value without redundancy, and the main purpose is front-loaded.

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

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

Given no output schema, the description provides a high-level overview of the return content (basic info, scale, photos) and the join logic, but lacks details on response structure, pagination, or limit behavior. It is adequate but not exhaustive for an agent's full understanding.

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

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

Schema coverage is 0%, so the description must compensate. It explains station_name and region as partial-match filters and mentions the join key, but it does not explain the limit parameter. This partial coverage is adequate 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 clearly states the tool performs an integrated query of logistics facility information, combining basic, scale, and photo data. It uses a specific verb (조회) and resource, and the mention of integration differentiates it from general station facility tools, though it does not explicitly name alternatives.

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

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

The description explicitly defines the filter conditions (partial match by station name or regional headquarters name) and the join behavior. It implies the appropriate context for use but does not mention exclusions or alternative tools, which is acceptable given the lack of obvious overlapping 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It does not mention read-only nature, auth requirements, rate limits, or any side effects. It also doesn't describe the return format or how filters interact. This is a notable gap for a data retrieval 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?

The description is concise: a two-sentence overview followed by a structured parameter list. It front-loads the purpose and organizes details clearly. No filler or redundancy.

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

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

For a tool with 7 optional parameters and an output schema, the description covers the main purpose and parameter meanings. However, it does not clarify interactions between run_ymd and run_ymd_gte/lte (e.g., does run_ymd override the range?), nor does it state whether any parameters are required for a meaningful query. These ambiguities could lead to incorrect calls, though the output schema likely clarifies return values.

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%, but the description's Args section fully compensates. Each parameter is explained with format examples (e.g., YYYYMMDD for dates, '01'=Gyeongbu line, '3900023'=Seoul) and semantics. This is highly valuable and goes beyond 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?

The description states a clear purpose: querying mainline passenger train transportation performance, providing station-wise boarding/alighting counts. It distinguishes this from siblings that focus on stations, routes, or ticketing, though it doesn't explicitly name alternatives. The verb and resource are specific.

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

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

The description implies usage: if you need station-wise passenger counts, this is the tool. It also lists filter dimensions (date, line, station). However, it doesn't explicitly mention when to use this versus the many sibling tools like get_mainline_station_per, nor does it state any exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It does mention the update frequency (갱신: 매월 1일, M-2), which is a useful behavioral trait. However, it does not explicitly state that the operation is read-only, does not describe any side effects, authentication needs, or response behavior. For a statistics retrieval tool, the lack of a read-only hint is a gap, though the 'get' prefix and the content type imply a safe query. The update info adds value beyond the schema, but more context would elevate it.

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

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

The description is two short sentences: the first states the core purpose and update cadence, the second maps the two parameters. It is front-loaded with the main purpose, with zero filler. Every part earns its place.

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

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

Given the presence of an output schema (so return values are documented separately), the description covers the essential elements: what the tool does, when the data is refreshed, and what the two parameters mean. It does not explicitly state that parameters are optional (though the schema shows defaults), nor does it give guidance on required vs. optional usage, but the schema handles that. The description is sufficient for an agent to call it correctly, though a brief usage example or clarification of required inputs would improve it.

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

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

Schema description coverage is 0%, so the description must explain parameters, and it does: 'run_ym=운행연월(YYYYMM)' provides the meaning and format, while 'rte_nm=노선명' gives the field meaning. This adds clear semantic value beyond the bare schema entries, enabling the agent to construct correct queries. Both parameters are covered concisely.

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

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

The description explicitly states the tool provides '간선열차 요일별 이용인원 통계' (mainline train day-of-week usage statistics), which is a specific verb+resource. It clearly distinguishes itself from sibling tools like get_mainline_station_per (station-based stats) and get_mainline_route_per (route-based stats) by focusing on the day-of-week breakdown. The update cadence is also mentioned, adding specificity.

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 does not explicitly name alternatives or state 'use when', but the tool name and description make its purpose unmistakable, and the sibling context (multiple get_mainline_* statistics tools) implies it is the right choice for day-of-week usage data. The relative clarity of the purpose is sufficient for an agent to infer usage, though it could be more explicit about not using it for station/route-level stats.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does add genuinely useful context: update timing (매월 1일, M-2) and the meaning of run_ym as the operating year-month. However, it does not disclose read-only nature explicitly (implied by the 'get' prefix), behavior when run_ym is empty (the schema marks it optional with an empty default), or any pagination or limits. The freshness disclosure partially compensates for the missing annotation layer, but other behaviors remain undocumented.

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 efficient sentence that front-loads the purpose before the parameter hint, with zero filler. The refresh-cadence parenthetical and the parameter format are both compact and relevant. It is appropriately short for a single-parameter query tool, though the terse style contributes to the under-specification noted in usage guidance.

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

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

For a one-parameter tool with an output schema present (so return values need not be explained), the description covers purpose and format reasonably well. The gaps are sibling disambiguation and empty-parameter behavior. Given the large, heavily overlapping sibling set (especially other mainline 'per' statistics), the lack of any distinguishing guidance makes the definition incomplete for confident tool selection.

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

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

Schema description coverage is 0%, so the description must compensate, and it partially does:run_ym=운행연(YYYYMM)' clarifies the expected format, which is the single most critical semantic for this parameter. However it does not explain that the parameter is optional (schema shows required: 0 with an empty default), what value to use for current data, or provide an example. The format hint is valuable but the optionality and fallback behavior unexplained.

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: '간선열차 거리별 이용인원 통계' (mainline train distance-based passenger usage statistics), naming both the resource (mainline trains) and the aggregation dimension (distance). This is clear and matches the name's 'distance_per' signal. It does not, however, name any sibling it is distinct from, which weakens differentiation given the many similar 'per' tools in the sibling list (station_per, route_per, grade_per, ticket_stat, person_distance).

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

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

There is no guidance on when to choose this tool over its many siblings, such as get_mainline_person_distance (which might appear to overlap on distance) or the other mainline 'per' statistics. The only contextual hint is the refresh cadence (updated 1st of each month, M-2 lag), which speaks to data freshness rather than selection criteria. With 72 siblings including several distance-like tools, the absence of any alternative-routing guidance is a meaningful gap.

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

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

With no annotations, the description carries the full burden. It discloses the monthly update cadence and M-2 data lag, which is valuable behavioral context. But it does not explain aggregation behavior, whether omitting carmdl returns all train models, or whether run_ym can be left blank for the latest available period.

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 compact sentence that front-loads the tool's purpose, then adds update timing and parameter definitions. There is no filler, and every clause contributes useful information.

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

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

For a two-parameter statistics tool with an output schema, the description is mostly sufficient: purpose, freshness, and parameter semantics are covered. The main gaps are optionality/default behavior and explicit guidance for choosing this tool among the numerous mainline 'per' statistics siblings, especially given the absence of annotations.

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

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

Schema description coverage is 0%, and the description fully compensates: run_ym is defined as 운행연월(YYYYMM) and carmdl as 차종명 with a concrete example (KTX). Both parameters receive format and meaning that the schema alone does not provide.

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

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

The description states the resource clearly: '간선열차 객실별 이용인원 통계' (mainline train passenger counts by cabin/class), and identifies the two relevant dimensions (run_ym, carmdl). It does not explicitly distinguish itself from sibling per-statistics tools like get_mainline_model_per, but '객실별' implies a distinct grouping.

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

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

The description provides a useful data-freshness cue ('갱신: 매월 1일, M-2'), which implies when the data is available. However, it never says when to prefer this tool over the many similar mainline statistics siblings, nor whether the parameters are required or optional.

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

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

No annotations are provided, so the description carries the full burden. It discloses the update cycle (매월 1일) and the data lag (M-2), which is valuable behavioral context for data freshness. However, it does not mention that it is a read-only query, whether any authentication is required, or how results are structured. For a stats query, this is acceptable but not exhaustive.

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 sentence that packs the core purpose, update frequency, and both parameter explanations without any filler. It is front-loaded with the subject, making it easy to scan.

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 simple two-parameter stats tool and the existence of an output schema (which handles return format), the description covers the essential semantics: what the tool returns (passenger statistics per vehicle), the data cadence, and parameter meanings. It could be improved by stating the granularity (e.g., per month per vehicle) or explicitly noting that both parameters are filters, but the description is adequate for the tool's complexity.

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

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

The schema description coverage is 0%, so the description fully compensates by explaining both parameters: run_ym = operation year-month in YYYYMM format, carmdl = vehicle type name (e.g., KTX). This is precise and includes a concrete example, exceeding the minimal requirement and providing the agent with the exact expected value formats.

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 the specific resource: mainline train per-vehicle passenger statistics, which is distinct from sibling tools for station, route, distance, etc. The verb is implied (get/query) but the action and subject are clear. It also names the two parameters that define the query scope, so an agent can tell exactly what this tool retrieves.

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

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

Provides no guidance on when to use this tool versus the many sibling statistics tools (e.g., get_mainline_station_per, get_mainline_route_per). It gives a hint via '차량별' (by vehicle) but does not explicitly state when it applies or what alternatives exist. There is no mention of scenarios that would warrant a different tool.

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

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

With no annotations, the description carries the full burden. It discloses the update schedule (monthly, M-2) which is useful for data freshness expectations. However, it does not explicitly state that the tool is read-only or describe any side effects, though '통계' (statistics) implies a query operation. The return format is covered by the output schema, so not required here. The disclosure is partial but not misleading.

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 sentence with the core purpose, followed by a compact parameter legend. It is perfectly front-loaded with the key information and contains zero fluff. Every character earns its place.

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

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

The output schema is present, so return format is covered. The description gives purpose, update frequency, and parameter meanings, which is good for a simple 2-param query. However, it does not clarify default behavior when parameters are omitted (e.g., returns all routes or all months), which is a plausible usage scenario given the optional params. This is a minor gap but leaves some ambiguity.

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 fully compensates by explaining both parameters: run_ym is the operating year-month in YYYYMM format, and rte_nm is the route name. This is exactly the needed context for an agent to construct valid calls. The default empty strings are not explained, but that's minor given the explicit format for the main usage.

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 clearly: 'Mainline train route distance statistics'. This distinguishes it from sibling tools by naming the specific metric (person distance) and the entity (mainline route). However, it does not explicitly differentiate from other mainline statistics tools (e.g., get_mainline_route_per, get_mainline_distance_per), so it's clear but not fully distinct.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or why one would choose this over sibling stats tools. The update frequency hints at data freshness but does not help with selection. This is a significant gap for an agent deciding between many similar get_mainline_* functions.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It does mention the update frequency (monthly, M-2), which is useful for interpreting data freshness. However, it does not state read-only nature, permission requirements, return format, pagination, or any side effects. Given it's a data retrieval tool, the lack of behavioral clarity is a notable 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?

The description is two short sentences, with the purpose stated first and parameter semantics following. It contains no redundant information or fluff. Every element earns its place, and the structure is front-loaded for quick comprehension.

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 simple two-parameter tool and the presence of an output schema (which handles return format), the description covers the essential context: purpose, parameter meanings, and update cadence. It doesn't explain potential constraints like required fields or typical values, but for a straightforward lookup tool this is adequate. Some details about expected response structure could be added, but the output schema mitigates that.

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

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

The schema has zero description coverage, so the description must explain the parameters. It does so explicitly: 'run_ym=운행연월(YYYYMM)' provides both meaning and format, and 'rte_nm=노선명' explains the route name parameter. This fully compensates for the schema's lack of information and leaves no ambiguity.

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

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

The description clearly states the tool provides passenger usage statistics by route for mainline trains ('간선열차 노선별 이용인원 통계'). It specifies the resource (mainline routes) and the metric (passenger counts), distinguishing it from sibling tools like get_mainline_station_per (by station) or get_wide_rail_route_per. It lacks an explicit verb like 'retrieve' but the intent is unmistakable.

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

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

No guidance is given on when to use this tool versus the many sibling statistics tools. The description only states what it provides and the update schedule; it does not mention alternative tools or conditions under which this one should be preferred. An agent would have to infer usage from the name and context, which is error-prone given the large sibling set.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The freshness note '갱신: 매일 D-2~D-1' (updated daily, 2 days delayed) does add genuinely useful latency context. However, nothing is disclosed about the return format, whether opr_ymd and opr_ymd_gte/lte conflict, or how results behave with all parameters 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?

One compact Korean sentence front-loads the purpose, appends the freshness caveat, and enumerates all four parameters with their formats. Zero wasted words; every clause earns its place.

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

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

An output schema exists, so return values need not be documented. All parameters are covered in the description. The gap is operational ambiguity: all 4 parameters are optional, and the description never clarifies that a date filter is expected or that opr_ymd excludes opr_ymd_gte/lte — leaving an agent unsure what an unconstrained call returns. Moderate incompleteness for a multi-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?

With 0% schema description coverage, the description must compensate, and it does: each parameter is mapped to meaning and format (opr_ymd=YYYYMMDD specific date, opr_ymd_gte/lte=period, stn_nm=station name). This adds real value beyond the bare schema. It stops short of clarifying that opr_ymd and the range parameters are alternatives rather than complements, holding it below 5.

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

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

Description states '간선열차 역별 승하차 통계' (mainline train station boarding/alighting statistics), identifying the resource (mainline trains) and granularity (station-level) with enough specificity to be distinguished from siblings like get_wide_rail_station_per and get_mainline_route_per. It stops short of naming these alternatives, so a 4 rather than 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?

No guidance on when to use this tool versus alternatives. The agent must infer mainline-vs-wide-rail and station-vs-route distinctions from the name alone. No exclusions, no preconditions, and no mention of when NOT to use it are provided.

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

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

No annotations provided, so description must carry behavioral disclosure. It discloses the data refresh schedule (monthly on 1st, M-1) which is a useful behavioral trait. However, it does not explicitly state read-only nature, error behavior, or limits, though the 'get' prefix implies read-only. Missing explicit side-effect disclosure.

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?

Description is a single line with no fluff. Purpose is front-loaded, then update schedule, then parameter definitions. Efficient and well-structured.

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

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

Output schema exists, so return values need not be described. Tool is a simple statistics query with two optional params; description covers param semantics and refresh info. However, it lacks usage context and differentiation from sibling stats tools, which is a gap. Overall adequate for a simple tool but incomplete in guidance.

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

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

Schema has 0% description coverage, so description fully compensates. It defines ntsl_ym as 판매연월(YYYYMM) with format, and ise_type as 발권유형명 (ticketing type name). Both parameters are explained with meaning and format, which is essential given no schema descriptions.

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

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

Description states '간선열차 발권유형 통계' (mainline train ticketing type statistics), a specific resource and purpose. It distinguishes from siblings like get_mainline_station_per by focusing on ticketing types rather than stations or routes. The update schedule is an extra detail, not obfuscating the purpose.

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

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

No guidance on when to use this tool versus alternatives. The description only provides param meanings and update cadence, with no mention of scenarios or exclusions. Among many sibling stats tools, no discriminating use case is given.

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

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

No annotations are provided, so the description carries the full burden. It discloses the data as-of date (2024.12.31), the 16-region scope, and the default behavior (returns all regions if region is empty). It also hints at the granularity of data by listing the machine categories. It does not explicitly state read-only behavior, but the verb '조회' (inquiry) strongly implies a non-mutating operation, and there is no mention of side effects. The lack of explicit mutability note is minor given the query nature.

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

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

The description is well-structured: it opens with the main purpose, then details the parameter semantics, and ends with the default behavior. The list of machine categories is lengthy but provides useful detail about the data scope. It is somewhat verbose for a simple tool, but every part contributes informational value, and the structure facilitates quick scanning.

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

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

Given the tool's simplicity (one optional parameter) and that an output schema exists, the description covers the essential points: what the tool returns, how to filter, and the default behavior. It does not explain output structure, but that is provided by the output schema. Any missing edge cases (e.g., no matches) are not addressed, but for a query tool of this nature the description is sufficiently 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 input schema provides only a string with a default; there is no schema description (0% coverage). The tool description compensates thoroughly by explaining that 'region' supports partial matching, gives concrete examples ('수도권', '부산', '대전', '강원'), clarifies that it can be filtered by '정비단' or '지역본부', and states the outcome when left empty. This goes well beyond the schema and leaves no ambiguity about the parameter's meaning.

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

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

The description clearly states the specific action (조회/inquiry), the resource (철도차량 검수용 기계 보유현황, railway vehicle inspection machine inventory), and even the as-of date and scope (16 regions). It distinguishes itself from sibling tools by focusing specifically on maintenance equipment, not on stations, routes, or customer data. An agent can immediately understand what this tool returns.

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

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

The description gives clear usage guidance for the parameter: partial matching, examples, how to filter by 정비단 or 지역본부, and the default behavior when no input is provided. It does not explicitly mention alternative tools, but among the siblings there is no obvious competitor, so the lack of an explicit alternative is not a significant omission. The guidance is practical and sufficient for correct invocation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly warns that the data has not been updated since 2024 and may differ from current operations, which is a significant behavioral caveat. It also discloses the data scope (headquarters building) and the nature of the output (list of rooms with code, capacity, specs). It does not state whether the operation is read-only, but for a list endpoint this is obvious from context. The staleness warning and scope note provide solid transparency beyond what the schema conveys.

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

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

The description is compact—four lines total—and front-loads the core purpose (room list lookup). It then provides the key data attributes, the range of rooms, and the staleness warning, ending with the parameter explanation. Every sentence contributes value; there is no redundancy or fluff. The structure flows logically from purpose to specifics to caveat to filter.

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 low complexity (one optional parameter, no nested objects, and an output schema available), the description covers all necessary context: the scope (headquarters), the number of results (11), the data fields provided, the range of room sizes, and the staleness caveat. The filter is explained with an example. Since an output schema exists, the description need not detail return formats. The description is complete for an agent to decide whether to call the tool and how to use its single parameter.

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

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

The schema has zero description coverage for the min_capacity parameter, so the description must compensate. It does so effectively, explaining that min_capacity filters rooms to those with at least the specified capacity, and even gives an example (30 means 30 or more). This adds clear semantic meaning beyond the bare integer type and default value. While it could mention edge cases (e.g., behavior with 0), the explanation is sufficient for the single parameter.

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

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

The description clearly states a specific verb and resource: it retrieves the list of meeting rooms in the headquarters building, provides 11 entries, and details the specific attributes (room code, capacity, specs). It is unambiguous and distinct from all sibling tools, which are unrelated domains like stations, freight, and trains. There is no ambiguity about what this tool does.

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

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

The description implies usage (for querying meeting room lists) and explains the one filter (min_capacity), but it does not state when to use this tool versus alternatives, or when not to use it. Since no sibling operates on meeting rooms, this is a minor gap, but the description lacks explicit context about the intended scenario (e.g., 'when a user needs meeting room capacity information'). The filter guidance is present, but broader usage context 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?

With no annotations, the description discloses key behavioral traits: initial call parsing delay, data source limitations (only stations in the specific XLSX, KTX-only), and exact-match/partial-match handling. It is transparent about side effects and edge cases, though it does not state that the operation is read-only (implied by '조회'). Slightly below a 5 due to minor omissions like error behavior.

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

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

The description is well-structured with clear sections (purpose, caveat, args, returns) and front-loads the main purpose. Every sentence adds value, including the relevant example (Seoul–Busan KTX) and the latency note. No fluff.

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

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

Given no output schema and 3 optional parameters, the description explains all return variations (no line_name, line_name only, with from_station, with both) and notes the parsing delay. It even clarifies the data source scope. For a query tool of this complexity, nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 0%, and the description fully compensates: line_name is partial match with examples, from_station and to_station are exact match, and the behavior for each parameter combination is described in the Returns section. This adds comprehensive meaning beyond 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?

The description states a specific verb and resource ('전국 철도 노선별 역간 운행거리를 조회합니다') and clarifies it is actual track distance (운행거리) distinct from fare-calculation shortest distance. This distinguishes it from the sibling get_station_distance without ambiguity.

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

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

The description explains that the tool returns operation distance, not passenger shortest distance, and warns about the KTX-dedicated-line data coverage. This implies when to use it (actual track distance), but it does not explicitly name alternative tools or give a when-not-to-use statement. Adequate but not fully explicit.

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

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

Annotations are absent, so the description carries the burden. It discloses the data scope and the SRT ownership caveat, which is useful. However, it does not state whether the operation is read-only, how invalid year values are handled, or any other behavioral traits. It is not contradictory, but leaves room for more detail.

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

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

The description is concise and front-loaded with the main purpose, followed by the vehicle types and parameter guidance. The list of vehicle types is a bit long but necessary for completeness. No wasted words; slightly verbose but acceptable.

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 output schema exists, the description does not need to explain return format. It covers the tool's purpose, data coverage, parameter behavior, and the SRT nuance. Nothing critical is missing for an agent 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 fully compensates for the year parameter. It explains the expected format, gives examples ('2024', '2020'), and specifies the default when omitted. This adds meaningful guidance beyond 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?

The description clearly states the tool queries annual rolling stock holdings (연도별 차량보유현황 조회) and lists the specific vehicle types included. It conveys the resource and scope, but does not explicitly contrast it with any sibling tools, so it earns a 4 rather than a 5.

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

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

The description provides clear context: the available years (2016-2024), the year parameter with examples, and the default behavior when year is omitted (returns all 9 years). It does not mention when not to use this tool or suggest alternatives, so the lack of exclusions keeps it at a 4.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It specifies partial-match behavior for region and station, defines the segment concept, and enumerates the return structure. It does not cover edge cases like empty filters or exact match semantics for segment_code, but provides solid behavioral context.

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

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

The description is well-structured, front-loaded with the core purpose, followed by a brief definition, parameter documentation, and return breakdown. Every line adds value with no unnecessary repetition.

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 is sufficient for a simple lookup tool with three optional parameters and no output schema. It explains the domain concept, all filters, and the returned fields. It does not mention behavior when no filters are provided or how filters combine, but these are minor 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%, and the description fully compensates by documenting all three parameters with concrete examples and matching rules. It clearly explains what segment_code, region, and station mean in the context of this tool.

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

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

The description clearly states it retrieves railway electric train segment information and defines what a segment is. This distinguishes it from sibling tools like station info or route search tools. The verb '조회합니다' is specific and the resource is well-defined.

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 usage through its definition of a segment and its filter parameters, but it does not explicitly state when to prefer this tool over alternatives. There is no mention of when not to use it or how it relates to sibling tools.

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

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

No annotations exist, so the description carries the behavioral disclosure burden. It states the tool provides specific fields and gives usage examples, which implies a read-only inquiry (조회). However, it does not mention pagination/limits or any authorization requirements, and the count (1,053건) is ambiguous as whether it's a total or returned set, leaving some transparency gaps.

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

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

The description is compact and well-structured: a short purpose line, a line on returned fields, an example list, and then parameter definitions. It front-loads the main action and stays free of fluff, making each sentence earn its place.

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

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

The description covers all three parameters with semantic detail and provides field names and examples of the returned data. An output schema exists, so return types are already defined. The only omission is pagination/limits and sorting behavior, which are minor given the simplicity of a filtered query tool.

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

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

Schema has zero description coverage, but the description provides a dedicated parameter block that explains each field's meaning and gives concrete examples (e.g., date format '2025-01-01', keyword '온누리'). This fully compensates for the schema's lack of documentation and adds practical usage guidance.

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?

Purpose is explicit: queries donation spending details ('사랑의 성금' 사용 내역 조회). Verbs and resource are specific, and the tool is clearly distinguished from sibling tools like get_social_funds (funds) and get_social_org (organization) by its focus on expenditure records. The examples (온누리상품권, 해피트레인) make the scope concrete.

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

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

The description gives clear context on what data is returned and includes filter examples, making the use case obvious. However, it does not explicitly compare with alternatives or state when not to use it, though sibling overlap is minimal, so a near-top score is warranted.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the returned content (fund type names, default flag, classification order) and the fixed result count of 6, plus example values. The verb '조회' makes the read-only nature evident. It does not claim to mutate state, so no contradiction. Minor gap: it never explicitly states the operation is safe/stateless, but for a 0-parameter lookup that is low risk.

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, each earning its place: the count and resource in the first line, the returned fields in the second, and concrete examples in the third. No filler or redundancy.

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

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

An output schema exists, so return formatting is handled elsewhere. For a 0-parameter lookup tool the description conveys the result count, field set, and example values — effectively everything an agent needs to interpret the result. The only omission is explicit usage context, which is minor for this simple tool.

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

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

The tool takes zero parameters, which per rubric earns a baseline of 4. Schema coverage is 100% (empty properties object), so there are no undocumented arguments requiring compensation from the description. The description appropriately adds nothing about parameters since none exist.

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 '조회' (inquiry) plus a bounded resource: '사회공헌 펀드 종류' (social contribution fund types). It further specifies the payload ( items, fields: name/default flag/classification order) and concrete example values ('사랑의 성금', '매칭그랜트', etc.). This clearly separates it from sibling lookup tools like get_social_donations and get_social_volunteer_fields.

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

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

No when-to-use or when-not-to-use guidance is given. There is no mention of alternative tools or the conditions that would favor get_social_donations or get_social_org instead. The intended context must be fully inferred from the tool name and purpose.

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

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

With no annotations provided, the description carries full burden. It discloses the 200-item limit, the hierarchical path format, and that memo fields contain affiliation info. It doesn't explicitly state read-only behavior, but '조회' (query) implies it. It lacks details on pagination or authentication, but for a lookup tool this is adequate.

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

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

The description is concise and well-structured, with a main statement, a note on format, and a warning about limits, followed by parameter explanations. Slightly more detail than necessary but each sentence adds value; the warning is front-loaded before usage.

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 simplicity of the tool (2 optional parameters) and presence of an output schema, the description is nearly complete. It covers filters, the limit, and data format. It doesn't explain how to retrieve all 6,306 items or pagination, but the warning implies the need for filtering. Sufficient for a 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 has 0% description coverage, so the description is the only source of parameter meaning. It thoroughly explains each parameter with examples and partial-match semantics, far exceeding the minimal schema of just type and default.

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

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

The description clearly states the tool's purpose: querying organization information from the social contribution portal, specifically for Korean Railroad Corporation's full organizational hierarchy. It provides the exact hierarchical path format and distinguishes itself from sibling tools like get_social_funds or get_social_donations by focusing on org details.

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

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

The description gives clear usage context by explaining the 200-item cap and recommending filters. It also specifies parameter usage with partial-match examples. However, it does not explicitly compare itself to alternatives or state when not to use it, though the purpose is distinct enough.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses that exactly 7 records are returned, what fields are included, and how keyword filtering behaves. It does not mention auth, empty-keyword behavior, or side effects, but for a simple code lookup these are minor gaps.

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

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

The description is compact and well-structured: purpose/count, output fields with examples, then parameter behavior. Every line adds value, and the main purpose is front-loaded.

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

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

For a simple optional-keyword code list with an output schema and a default value in the input schema, the description covers both invocation and result content adequately. Nothing material is missing for an agent 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 fully compensate. It clearly defines keyword as a 분야명 partial-match filter and provides concrete examples (헌혈, 환경, 해피), which is sufficient for the single optional parameter.

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 clear statement that this tool retrieves social contribution volunteer field codes and lists the exact returned fields (구분코드, 분야명, 분야설명). It also gives domain examples, making it easy to distinguish from sibling tools like get_social_volunteer_matching.

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

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

The description provides concrete usage guidance for the keyword parameter, explaining that it performs a partial match on 필드명 with examples. However, it does not explicitly name sibling alternatives or state when not to use this tool, so the routing guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the full burden. It discloses the output fields and filter behavior (partial keyword match), and notes an approximate result count (877건). However, it does not state read-only behavior, pagination, sorting, or any prerequisites—gaps that annotations might otherwise cover.

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

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

The description is concise and well-structured: a purpose sentence, a field list, example categories, and parameter explanations. It avoids fluff, though the inline count '877건' is minor extra context. Slightly more detail than strictly necessary but each line serves a purpose.

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

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

Given an output schema exists and parameters are optional with clear semantics, the description is sufficient for correct invocation. The only minor gaps are lack of explicit mention of sorting, pagination, or whether date range is inclusive—common but not critical for a simple filter 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 and does compensate fully. Each parameter (date_from, date_to, keyword) is explained with explicit meanings and examples (e.g., keyword '매칭그랜트'), making the call semantics unambiguous and highly actionable.

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

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

The description clearly states the tool retrieves social contribution volunteer matching expense details, listing the exact fields returned (management number, sequence, expense date, amount, usage details) and example categories. This is specific and distinguishable from sibling tools like get_social_funds or get_social_donations.

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 usage for volunteer matching expense queries but does not explicitly contrast with any sibling tools or state when not to use it. No alternative tools are mentioned, leaving the agent to infer based on the domain name and examples.

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

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

With no annotations provided, the description fully carries the burden of behavioral disclosure. It discloses performance (initial load takes seconds, max 200 records), indexing limitation (only departure-based lookup, no reverse query), and semantic distinction (fare-basis vs actual distance) with a concrete example. This is exceptionally transparent about constraints and data characteristics.

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

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

The description is well-structured with clear sections (Args, Returns, notes). Every sentence adds value: parameter explanations, return field list, performance caveat, and distance semantics. It is informative without redundancy, and the most critical purpose is stated 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?

For a tool with 3 parameters and no output schema, the description is comprehensive. It lists return fields, total record count, maximum result limit, initial load time, indexing limitation, and defines the semantic of '여객최단운행거리' vs actual track distance. This covers all necessary context for an agent to call the tool correctly and interpret results.

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

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

The schema has no descriptions, so the description compensates fully. Each parameter is explained: from_station (exact recommended, partial matches), to_station (partial match, absence returns all segments), current_only (default true, filters to current data). This exceeds what the schema provides and enables correct usage.

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

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

The description clearly states the tool queries the shortest operating distance between two stations, distinguishing passenger and freight distances and including via-station information. It uses a specific verb ('조회') and resource ('두 역 간 최단 운행거리'). Among the large sibling list, this tool is uniquely about station-to-station distance, and the description clarifies its scope, making it easy to differentiate.

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

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

The description explains when to use the tool (for distance between stations) and includes behavior for optional parameters (e.g., if to_station is omitted, returns all segments from departure). It also warns that the distance is fare-basis, not actual track distance, implicitly distinguishing it from get_operation_distance. However, it does not explicitly state 'use X for actual distance' or 'when not to use this tool', though context implies alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral. It does add a valuable caveat: '데이터기준일: 실시간 API (날짜 미포함). 현장 변경이 즉시 반영되지 않을 수 있음' (data is real-time without a date, and field changes may not be immediately reflected). This informs the agent about potential staleness. However, it does not disclose other behavioral aspects such as authentication requirements, rate limits, or response shape (though the output schema exists). The behavior is partially transparent, deserving a middle score.

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

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

The description is well-structured and front-loaded with the primary purpose, followed by the facility list, the parameter explanation, and a caveat. It is not long, though the inclusion of full English and Japanese translations adds some verbosity. Each section adds valuepurpose, parameter, caveat), and the format is easy to parse. It earns a 4 for being appropriately concise without sacrificing necessary detail.

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

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

Given the tool has a single parameter, an output schema (signal indicates has output schema: true and the description explains the parameter semantics and a data-freshness caveat, it is reasonably complete for an agent to call it correctly. The lack of usage guidance is a minor gap, but the core invocation are covered. The description is adequate for a simple lookup tool, though it could improve by mentioning the response structure or typical use cases, but these are partially covered by the output schema.

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

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

The input schema has 0% description coverage for the only parameter 'station_name', but the description compensates by explicitly stating 'station_name: 역 이름 부분일치 (예: ‘서울’, ‘부산’)' — explaining that the station name is matched as a partial string and providing concrete examples. This adds meaning beyond the type definition and helps the agent understand acceptable input. It is not exhaustive (e.g., case sensitivity or language nuances are missing but it significantly understanding, warranting a 4.

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

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

The description clearly states the tool's purpose: '역 이름으로 편의시설 정보 조회' (look up facility information by station name) and explicitly lists the facility categories (elevator, escalator, restroom, nursing room, information center). It is specific about the verb and resource, and mentions it is a real-time API. However, it does not explicitly distinguish itself from sibling tools like get_accessible_facilities or get_station_facilities_detail, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, conditions, or exclusions. There is no reference to sibling tools or differing use cases. An agent cannot discern from the description whether to choose this over get_accessible_facilities or list_stations_with_elevator for a particular query.

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

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

With no annotations provided, the description carries the full burden, and it does well: it discloses the data source, data vintage, station count, partial-match behavior, default full-return behavior, and the specific quantities covered. It does not discuss response size or potential performance implications, but the output schema covers return shape.

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

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

The core content is well front-loaded: purpose, data date, station count, and query semantics appear early. However, the Korean description is followed by redundant EN and JA translations that restate the same information, adding length without new useful detail for an AI agent.

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

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

For a tool with one optional parameter and an output schema, this description is complete: it covers data source, snapshot date, scope, filtering semantics, default behavior, and the facility types included. The only minor gap is not naming a sibling tool explicitly, but the trade-off note gives enough directional guidance.

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

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

Schema description coverage is 0%, so the description must compensate—and it does fully. It explains that station_name is a partial match with examples ('서울', '광명') and that omitting it returns all stations, adding essential meaning the empty schema description lacks.

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

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

The description clearly identifies the operation ('역사 내외부 시설현황 조회') and the resource (detailed station facilities for 288 stations), with a specific list of included facility types and quantities. It also distinguishes itself from the convenience-facility API by noting richer quantity information but a fixed data date, helping an agent tell it apart from nearby siblings.

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

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

The description gives clear context: station_name is a partial-match filter, no input returns all stations, and the data is fixed as of 2024.12.31. It implies a trade-off versus the B551457 convenience-facility API—richer quantity data but less current—though it does not name the sibling tool explicitly or give a direct 'when not to use' 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?

With no annotations, the description carries the behavioral disclosure burden. It reveals key behaviors: partial matching, default 'return all', data source date, and the inclusion of exit count. It does not mention auth, rate limits, or error handling, but for a simple read-only query these are not critical and the given details are transparent.

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 informative without being overly redundant. It front-loads the purpose, then details parameters and defaults, and includes translations at the end which add length but not clutter. The structure is clear and each sentence serves a purpose, though the EN/JA translations are optional extras.

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

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

The output schema exists, so return structures are handled outside the description. The description covers input semantics, default behavior, dataset scope (202 stations, date), and provided fields—sufficient for a straightforward lookup tool. It omits edge-case handling, but these are not essential 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 coverage is 0%, so the description must fully document parameters. It does: station_name is a partial match with examples, region is a partial match with examples, and empty inputs return all. This adds complete meaning beyond the bare schema, fully compensating for the lack of schema descriptions.

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

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

The description clearly states the tool retrieves station location information, listing specific fields (regional HQ, coordinates, exit count) and the data source (202 mainline stations as of 2024.04.01). This is a specific verb+resource and is distinct from sibling tools like get_station_facilities or search_station, which focus on other aspects.

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