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

Annotations only declare readOnlyHint=false / destructiveHint=false, so the safety profile is thin. The description compensates by disclosing that cookies go only to the portal (privacy behavior), that it uses a saved session, that 'manual' means login is required, and what is returned. Missing failure/duplicate-submission behavior keeps it from a 5.

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

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

Content is front-loaded and each element is useful, but the full Korean/English duplication roughly doubles the length without adding new information. Efficient in substance, wasteful in presentation.

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 mutation tool with a login prerequisite, the description covers auth, cookie scope, and outcome status semantics, and an output schema exists for return values. It lacks edge-case behavior (duplicate applications, rate limits, error handling), but is otherwise complete enough to invoke 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 carries the burden. It adds the key constraint that 'ids' accepts 1~50 dataset IDs and clarifies 'purpose' as intended use, which meaningfully supplements the bare schema. It still omits ID format/source details, so it only partly compensates.

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

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

Names a specific verb+resource: submitting access applications (활용신청) using a saved portal session. Distinguishes itself from siblings like login/download/search, though it never explicitly contrasts with them. Clear and 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?

States the prerequisite that a saved login is needed and points to the login tool ('로그인: login 도구 또는 datagokr login'), and the 'manual' status signals when re-authentication is required. However, there is no explicit when-to-use vs when-not guidance relative 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?

The description discloses important behaviors beyond the destructiveHint annotation: it explicitly states that files are overwritten ('overwriting the same path') and that probe=True performs a dry-run without saving ('probe checks without saving'). It also describes the return format (files with path, version, etc.). These details add value beyond the annotations, though it doesn't cover authentication or error 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?

The description is a single dense paragraph mixing Korean and English, which is a bit cluttered but front-loaded with the core purpose. It contains some redundancy (both languages for the same idea) and could be tightened, but it's not excessively long. The structure is acceptable but not exemplary.

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 an output schema, the description still covers the main behavior, parameter semantics, and return details. It explains the overwriting behavior and probe mode, which are crucial for safe usage. It lacks guidance on when to use this tool vs siblings, which prevents a perfect score, but overall it's reasonably complete for a download operation.

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 for most: version/all_versions (mutually exclusive choice), out (destination directory, with default), utf8 (CSV UTF-8 conversion), and probe (dry-run). It doesn't explicitly explain dataset_id, but that's the required identifier and is fairly obvious from context. It also mentions the special case of STD_FILE being saved as a full CSV, adding nuance.

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 primary action: saving originals locally ('Save originals locally'). It also notes overwriting behavior, which is a specific detail. However, it doesn't differentiate this tool from sibling tools like 'fetch' or 'get', which might also retrieve files, so it loses a point for lacking 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?

The description gives parameter-level guidance (e.g., 'choose version or all_versions') but provides no guidance on when to use this tool versus alternatives. It doesn't mention any exclusion criteria or conditions that would route an agent to a sibling tool. This is a significant gap for a tool with many siblings.

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

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

Annotations already declare readOnlyHint=true, and the description adds valuable context: it returns API data or request_templates, status_code=401 signals access must be requested, and it doesn't save files or apply for access. This goes beyond the annotation and clarifies error semantics.

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

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

The description is front-loaded with the core purpose, followed by defaults, returns, and special cases. It is slightly redundant due to bilingual repetition, but each sentence adds value and the structure is logical.

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 an output schema and low parameter complexity, the description covers the essential behaviors: fetch semantics, default version, return types, error code, and exclusions. It is adequate for an agent to call 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 coverage is 0%, so the description must compensate. It explains version defaults to latest and implies n is the number of rows via '첫 n행', but it doesn't explicitly describe dataset_id or provide detailed syntax for any parameter. It adds some meaning but not complete compensation.

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 'fetch' and resource 'odcloud first n rows', and specifies it queries locally with an API key. It hints at differentiation by noting that STD_FILE should use get/download, which distinguishes it from those siblings, though it doesn't explicitly name all 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 provides partial guidance: it says it does not apply for access or save files, and that STD_FILE should use get/download. However, it doesn't explicitly state when to use this tool versus search, show, or preview, leaving some ambiguity for an agent.

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

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

With readOnlyHint=true, the safety profile is already declared, so the description only needs to add context. It contributes the n range (1~20), dtype values (FILE/API/STD), and that results are ranked metadata, but omits ranking basis, pagination, or matching/case 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?

Front-loads the core purpose, then parameter hints, then the return note. The bilingual duplication doubles length but each line carries unique, useful content rather than 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?

An output schema exists, so return values need not be detailed, and the description still adds the 'ranked metadata as in search' note. Combined with readOnlyHint and full parameter hints, it is nearly sufficient despite the terse tool name.

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 and largely does: it gives a names example (['위도','경도']), the n range (1~20), dtype enum values (FILE/API/STD), and explains org as an institution name. Only a precise meaning of dtype tokens is left implicit.

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

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

States a specific verb and resource: finding datasets that contain ALL named columns, which separates it from the generic 'search' sibling by its column-matching semantics. The reference to 'search' for return format also positions it relative to a sibling, though it does not fully spell out the distinction.

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

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

The description implies a column-based lookup but never states when to choose 'fields' over 'search' or the other retrieval siblings. No prerequisites, exclusions, or alternative-routing guidance are given.

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

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

Annotations already mark the tool as potentially destructive, but the description adds crucial specifics: it may save files locally (original file fallback) and can submit an application on the user's behalf when no_apply=False. It also explains probe as a safe check. This exceeds the annotation signal and fully discloses behavioral traits.

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

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

The description is front-loaded with the core purpose and structured logically (main purpose, side-effect warning, probe explanation, return summary). It is slightly verbose due to bilingual repetition, but every sentence adds value. Good organization.

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

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

The output schema exists, so return values don't need detailed explanation, and the description still gives a concise return summary. It covers side effects, probe behavior, and fallback logic. The only gap is the meaning of n, which the schema may already describe. Overall, it's complete 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?

With 0% schema description coverage, the description must explain parameters. It explains no_apply and probe clearly, but gives no meaning for n (likely row count) or dataset_id beyond being required. It partially compensates but leaves key parameters 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 clearly states it returns rows, links, or API templates depending on access method, which is a specific verb-resource combination. It also distinguishes itself from siblings by the mention of access_kind and the fallback behavior, making its purpose 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?

It explains when to use probe and no_apply, but does not explicitly contrast with sibling tools like search, preview, or fetch. The guidance is present for specific scenarios (401 fallback, avoiding side effects) but not for general selection between tools.

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

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

Annotations only supply readOnlyHint=false and destructiveHint=false; the description goes well beyond that, disclosing the two-call challenge flow, the 5-minute answer window, that credentials must never be passed as arguments, and that success persists a session. These are exactly the behavioral traits an agent needs and annotations cannot convey.

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

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

Front-loaded with the core purpose and the step order is clear. The bilingual Korean/English pairing restates each point twice, which is defensible for reach but costs some economy; no sentence is otherwise wasted.

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

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

For a two-parameter stateful auth tool with no output schema, the description covers invocation order, argument rules, credential handling, timeout, retry behavior, and the resulting session — everything needed to call it correctly. Nothing material 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 carries the full burden, and it does: it explains that the first call takes no arguments, that challenge_id is echoed back on the second call, and that captcha_answer must contain only the characters the user read. Both parameters' roles and constraints are fully specified despite the empty 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+resource ('log in to the portal' / 'Log in locally with a user-read CAPTCHA') and the outcome ('Saves a session'). It also explicitly distinguishes itself from the sibling 'apply' by declaring '활용신청은 별도입니다 / does not apply for access,' so an agent can tell it apart without opening schemas.

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

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

Gives an explicit procedure: call first without arguments to obtain the image, show it to the user, then resubmit their transcribed characters with the same challenge_id, and retry/refresh without arguments. It also states the when-not condition ('Never pass credentials as arguments') and a time bound ('within 5 minutes').

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

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

Annotations only declare readOnlyHint=true; the description goes further by disclosing what is NOT returned ('Keys and cookies are never returned') and what the call yields (authenticated, message), which matters for a credential-adjacent tool. It stops short of describing caching or expiry semantics, so not a 5.

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

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

Content is front-loaded: purpose first, then return shape, then the routing hint. The Korean/English duplication adds length but each language block carries the same compact payload and no sentence is filler.

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

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

For a zero-parameter read tool with an output schema already covering the return fields and annotations covering the safety profile, the description supplies the two things an agent actually needs: what validity means here and which sibling to call when the session is dead.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing for the description to disambiguate.

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 ('저장된 포털 세션의 유효성을 확인합니다' / check whether the saved portal login is valid), which is clearly separable from the sibling 'login' and the other data tools in the set.

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

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

It explicitly names the alternative tool and the condition that selects it: '세션이 없거나 만료되면 login 도구로 로그인하세요 / Use login for missing or expired sessions.' Clear routing, though it does not state the situations in which checking status (rather than going straight to login) is the right first step.

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 readOnlyHint already declaring a safe read, the description still adds real behavior: no credentials are transmitted, the 20-row cap, and the return payload shape (access_kind, columns/rows, total or access instructions). The row cap is stated loosely versus the schema's unconstrained n/default 5, but it is not contradictory.

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

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

Front-loads the action and return shape, which is good, but the same content is duplicated verbatim in Korean and English, roughly doubling length without adding information. Still scannable and free of tangential 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?

An output schema exists, so return-value documentation is a bonus rather than a requirement, and annotations cover the safety profile. What remains missing is guidance on dataset_id semantics and how preview relates to show/search, leaving a modest gap for a two-parameter read tool.

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

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

Schema description coverage is 0% for two parameters, so the description must compensate. It hints at the row limit ("up to 20 rows") for n, but gives no meaning, format, or expectations for the required dataset_id, leaving the most important parameter undocumented.

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

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

States a specific verb and resource (preview the first rows and access instructions from a remote server) and names the scope cap (up to 20 rows). It also distinguishes itself from fetch/get, which sibling-aware agents can use to separate preview-only reads from authenticated retrieval.

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

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

Explicitly says credentialed/authenticated queries should go to fetch/get, and that nothing is applied or saved (routing away from the apply sibling). It does not address when to pick preview over show/search/fields, so it stops short of full when/when-not coverage.

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?

readOnlyHint=true already covers the safety profile. The description adds real behavioral context beyond it: the summary counts candidate groups/datasets before the n limit, group_count includes the representative, group_ids is capped at 60 ranked ids, and server-side intent inference occurs. Missing only error/empty-result 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?

Front-loaded and organized, but the bilingual duplication roughly doubles the length and some return-field detail overlaps with the output schema. Efficient in content, less so in size.

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?

Despite an output schema existing, the description documents the notable return fields and grouping semantics that matter for calling it correctly, plus the dtype/org inference behavior. Complete enough for a search tool; only error handling is absent.

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

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

Schema description coverage is 0%, so the description carries the full burden and does so: it defines query as natural language/topic, n as 1-20, dtype as FILE/API/STD, org as provider name, and fields as required columns. This fully compensates for the undocumented schema.

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

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

States a specific verb and resource in both Korean and English ('원격 검색 / Search the remote catalog by topic'), and explicitly routes the follow-up inspection to the sibling 'show'. An agent can distinguish this from show/get/fetch without opening any schema.

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

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

Gives concrete when-to-use guidance: inspect group members via 'show', and supply dtype/org explicitly for more precise results since the server otherwise infers region and API/file intent. Lacks explicit when-not-to-use framing, but the alternative routing is clear.

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

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

The readOnlyHint annotation is consistent with the description, which describes an inspection operation. The description adds value by enumerating the returned metadata fields and clarifying that it does not return row data (implied by 'use get for actual rows'). This goes beyond the annotation by specifying what the tool returns and what it deliberately omits.

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, with three sentences that lead with the purpose, then the return list, then the parameter guidance. There is no redundant wording, and the bilingual format does not obscure clarity. It is appropriately front-loaded and every sentence adds 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 metadata-inspection tool with one parameter and an output schema, the description covers the essential usage context: what it does, what it returns, where the id comes from, and how it relates to 'get'. There are no gaps that would prevent an agent from calling 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?

With 0% schema description coverage, the description fully compensates by explaining that dataset_id is the id from search results. This gives the agent both the source and the meaning of the parameter, which the schema alone does not provide. For a single-parameter tool, this is 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 inspects dataset metadata and lists the exact return fields (title, org_nm, access_kind, etc.). It explicitly contrasts with 'get' for actual rows, distinguishing it from a key sibling. The verb 'inspect' and resource 'dataset metadata' are specific and 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 advises to inspect metadata before use and explicitly says to use 'get' for actual rows, providing clear routing between two tools. It also instructs to use the dataset_id from search results. However, it does not mention other siblings like fields, preview, or fetch, so guidance is partial but sufficient for the primary alternative.

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