AI Skill Store

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

With no annotations, the description carries the full burden. It adds behavioral context by including '공개 조회' (public inquiry) and listing possible return statuses (claimed, expired, agent_verify_email_sent, agent_claimed). It does not disclose side effects, but as a read-only status check, the public nature and status summary are sufficient.

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-organized with clear sections for usage, arguments, and returns. It is not overly long, though the bilingual repetition (English and Korean) adds slight verbosity. The front-loaded purpose statement ensures immediate understanding.

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 tool with one parameter and an output schema, the description covers purpose, usage scenarios, parameter origin, and return statuses. It is complete enough for an agent to invoke it correctly, and the output schema removes the need to detail return formats.

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, but the description compensates by explaining that 'claim_token' comes from the 'upload_skill_draft' response. This adds essential meaning beyond the bare schema, clarifying the token's origin and 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 opens with a clear, specific statement: 'Check the status of a draft skill upload using a claim_token.' It names the exact resource (draft skill upload) and action (check status), and the Korean 'Draft 스킬 상태 공개 조회' reinforces this. It distinguishes itself from siblings like check_vetting_status by focusing on draft upload status, not vetting.

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 '사용 시점' section lists three concrete scenarios: checking if a human clicked the claim_url, verifying agent-level verify email processing, and confirming claim/expiry within 30 days. This clearly describes when to use the tool, though it does not explicitly mention alternatives or exclusions.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It discloses that the tool requires an API key and that only the skill owner can perform the query, conveying an ownership restriction. It also implies a read-only operation (checking status). Beyond this, it does not elaborate on return states or side effects, but the output schema likely covers return 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 well-organized with an Args/Returns structure and is not overly long. However, it duplicates content in English and Korean, which adds some redundancy. Each sentence serves a purpose (localization), so it remains acceptable, but not maximally concise.

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 and the presence of an output schema, the description covers the essential context: prerequisites (version_id from upload_skill), authentication (api_key), and permission (owner only). It does not discuss alternative tools or edge cases, but for a status-checking tool with two well-described parameters, this 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 description gives detailed, meaningful explanations for both parameters beyond the schema: 'version_id' is identified as the one from upload_skill results or a vetting_job_id, and 'api_key' is described as the developer API key with an owner-only access restriction. This fully compensates for the 0% schema description coverage.

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

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

The description clearly states the tool's function: 'Check the security vetting status of an uploaded skill version.' This is a specific verb+resource pairing. However, it does not explicitly differentiate from the sibling tool 'get_vetting_result,' which may serve a similar or overlapping purpose. Thus, it is clear but not fully distinguishing.

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 on when to use this tool: it requires a version_id from a previous upload_skill call and an API key, with the note that only the skill owner can query. This establishes a prerequisite and auth requirement, but it does not mention alternatives or when not to use 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 are provided, so the description carries the burden. It discloses key behaviors: platform-based conversion, default save to a temp directory, and return of a file path or error message. This gives the agent a clear mental model of what happens. Some details like authentication or whether files are overwritten are omitted, but for a download tool, the disclosure is strong.

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 structured with a summary sentence, bilingual text, and an Args/Returns block. It is front-loaded with the main purpose. However, it is slightly verbose because it lists the platform names twice (in the prose and in the Args section). Still, the redundancy is minor and each sentence carries 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 tool with 3 parameters and an output schema, the description provides the necessary context: the action, platform conversion options, default save location, and return format. It does not explain potential error scenarios beyond 'error message', but with an output schema available, this is a minor gap. Overall, the description is complete enough for correct selection and 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 input schema has 0% description coverage, but the description explicitly documents all three parameters: skill_id, platform, and save_dir. It explains the meaning and default behavior for each (e.g., '비워두면 원본(.skill) 다운로드' for platform). This fully compensates for the schema's lack of 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 starts with a specific verb and resource: 'Download a skill package.' It then distinguishes from siblings by explaining platform-specific auto-conversion (e.g., ClaudeCode, Cursor). The bilingual text clarifies the exact function, so there is no ambiguity about what the 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?

It clearly states when to use the tool (to download a skill package) and provides the conditional: 'Specify platform to get an auto-converted package for that platform.' It also explains the default behavior when platform is empty. However, it does not explicitly exclude alternatives or mention when not to use it, which would make it a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses what the tool returns (skills_count, total_downloads, etc.) which is somewhat behavioral, but it does not explicitly state that this is a read-only operation, nor does it mention permissions, rate limits, or side effects. For a simple getter, this is adequate but not rich.

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

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

The description is extremely concise and well-structured: a one-sentence purpose, an Args section, and a Returns section. Every part serves a clear function, with no unnecessary filler. The bilingual repetition is minor and does not detract.

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-only tool with one parameter and an output schema, the description covers purpose, parameter semantics, and return values. It lacks usage guidance and safety notes, but given the tool's simplicity and existing schema, this is reasonably complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does: the 'Args' section explains agent_name in Korean and provides an example ('claude-sonnet-4-6'), adding meaningful semantics beyond the schema's bare parameter definition.

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 'Get contribution stats for an agent author' and specifies what these stats include (uploads, claims, attribution history). This is a specific verb+resource combination that distinguishes it from sibling get_agent_identity_stats, though it doesn't explicitly name the alternative.

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 like get_agent_identity_stats. The description provides no context for selection or exclusions, leaving the agent to infer usage solely from the name and description.

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 burden of behavioral disclosure. It mentions '공개 조회' (public query) which indicates a read-only, accessible operation, and lists the returned fields. However, the ambiguity between 'calling agent' and 'specific agent_author' leaves access control and intended audience unclear.

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 has a clear structure with an overview, Args, and Returns sections. It includes both English and Korean, which adds redundancy but not excessive length. The format is efficient and easy to parse, though the bilingual repetition is slightly wasteful.

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

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

An output schema exists, so return values are documented elsewhere, but the description still lists them for clarity. The single parameter is well explained. The main gap is the lack of differentiation from the sibling tool and some ambiguity about access scope (calling agent vs. any specific agent). Overall, it is adequate for a simple stats lookup.

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

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

The schema only defines 'agent_name' with no description (0% coverage), so the description must compensate. It does so by explaining that agent_name is the agent's name and corresponds to the X-Agent-Author header, providing meaningful context beyond the schema.

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

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

The description clearly states the tool retrieves identity stats for a specific agent, including claim success rate and claimed/expired counts. The verb 'Get' and resource 'identity stats' are explicit, but it does not differentiate from the sibling tool 'get_agent_author_stats', which likely overlaps in 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?

The description implies usage for querying the calling agent's stats (or any agent via agent_name), but it does not explicitly state when to use this over the sibling 'get_agent_author_stats' or provide exclusion criteria. The context is implied rather than fully guided.

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

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

No annotations are provided, so the description carries the full burden. It discloses the arguments (skill_id, platform) and the return value (a step-by-step installation guide string), which is helpful. However, it does not mention behavior with invalid skill IDs, unsupported platforms, or potential errors, leaving some gaps about the tool's runtime behavior. For a simple guide retrieval, this is acceptable 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 concise and well-structured: a one-sentence purpose statement, followed by a tidy argument list and a clear return description. It is bilingual without redundancy, and every sentence adds necessary information. The list of platform values is compactly included within the argument description, avoiding extra bulk.

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 (two parameters, one required), the description covers the essential aspects: purpose, parameters, and return value. An output schema exists, so the return format is documented elsewhere, and the description's return note is extra. It does not mention the default platform value (OpenClaw) or error handling, but for a straightforward guide retrieval, 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 schema has zero descriptions for parameters (0% coverage), so the description must compensate. It provides meaningful clarification for the platform parameter by explicitly listing the allowed values ('OpenClaw', 'ClaudeCode', 'ClaudeCodeAgentSkill', etc.), which adds significant value beyond the schema's bare string type. Skill_id is only described as '스킬 ID' (skill ID), which is minimal but still helps. Overall, the description compensates well for the schema gap.

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

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

The description clearly states the tool's function: 'Get step-by-step installation instructions for a skill on a specific platform.' It uses a specific verb ('Get') and resource ('installation instructions'), which distinguishes it from siblings like get_skill (getting skill details), get_skill_schema (schema retrieval), and download_skill (file download). This is a precise and unambiguous purpose statement.

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 for when to use this tool: when you need installation instructions for a skill on a specific platform. It implicitly differentiates from alternatives by listing platform-specific guide retrieval as the focus. However, it does not explicitly name alternative tools or state when not to use it, so it falls short of full explicit 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 must carry the burden. It discloses the data source (aggregated zero-result search queries), the return format (a summary string with fields), and the practical implication (building these skills yields demand). It doesn't explicitly state side effects, but 'get' implies read-only, and the disclosure is strong.

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 bilingual, which adds some redundancy but remains well-organized with purpose, arguments, and return sections. Every piece contributes useful information, though the English-Korean repetition could be trimmed without losing meaning.

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 list retrieval tool with 3 optional parameters and a string return, the description provides sufficient detail about inputs, output fields, and purpose. It does not mention error handling or ordering, but these are minor given the context.

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

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

Schema description coverage is 0%, but the description fully compensates by listing each parameter with defaults and constraints: 'days: 최근 N일 (기본 30, 최대 365)', 'limit: 최대 반환 개수 (기본 20, 최대 100)', and 'type: 'keyword' | 'capability' | 'all''. This adds meaning beyond the schema's 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 'Get the list of most-wanted skills that haven't been built yet (Supply Loop)' with a specific verb and resource. It differentiates itself from siblings like get_skill or search_skills by focusing on demand and zero-result queries.

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

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

The context of when to use this tool is clear: agents should use it to discover skills to build and fill community demand. However, it does not explicitly name alternatives or exclusion conditions, but the unique purpose is evident.

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 return format ('스킬 상세 정보 JSON 문자열') and the meaning of the parameter, but it does not disclose error handling, authentication needs, or whether the operation is read-only. Since 'get' implies non-mutating, some transparency is inherent, but the description adds limited behavioral context beyond the obvious.

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 organized with clear Args/Returns sections. The bilingual Korean/English content adds minimal redundancy but is not bloated. It front-loads the purpose and provides structural clarity without extraneous detail. Slight redundancy between the two languages prevents a 5.

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

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

For a simple one-parameter getter with an output schema present, the description is fairly complete. It lists the key return fields and explains the parameter source. It does not mention potential errors or edge cases, but given the low complexity and existing output schema, this is acceptable. The description adequately covers what an agent needs to invoke it correctly.

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

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

The input schema has 0% description coverage, so the description must compensate. The Args section explicitly explains skill_id as '스킬 ID (search_skills 결과의 skill_id)'—informing the agent that the ID originates from search_skills output. This adds meaningful provenance beyond the schema's bare 'Skill Id' title, making the parameter semantics clear.

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 function: 'Get detailed info for a specific skill including description, supported platforms, version history, author, and security vetting status.' This uses a specific verb ('get') and resource ('skill'), and the listed fields distinguish it from sibling tools like search_skills (search) or get_skill_schema (schema 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?

The Args section notes that skill_id should come from 'search_skills 결과의 skill_id' (skill_id from search_skills results), indicating a typical workflow: first search, then get details. This provides clear context on when to use the tool, though it does not explicitly mention alternatives or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return content (interface, schemas, permissions, tags) which is useful. However, it does not mention whether this is a safe read-only operation or any prerequisites, though it is implied by the nature of a schema getter.

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 clear sections for Args and Returns, and it is front-loaded with the English summary. No unnecessary words 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 is simple with one parameter and an output schema, so the description is mostly sufficient. It covers purpose and parameters, but lacks explicit usage context or alternatives. Overall, it is complete enough for a straightforward schema retrieval 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 only provides a translated label for skill_id ('스킬 ID') with no additional detail beyond what the parameter name already implies. This is minimal 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 tool gets the full schema for invoking a skill, listing specific components (interface spec, input/output schemas, permissions, capability tags). This is a specific verb+resource and distinguishes it from sibling tools like get_skill.

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 a skill's invocation schema but does not explicitly state when to use it over alternatives like get_skill. It provides clear context but no exclusions or alternative references.

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 fully discloses behavioral traits: authentication options (api_key or claim_token), polling behavior with is_done flag and retry guidance, and the expected return fields (vetting_status, findings[]). This gives a complete behavioral contract beyond what annotations would provide.

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-organized with clear sections for purpose, authentication, return behavior, and arguments. Despite being bilingual, every sentence contributes value, and the core purpose is front-loaded. The structure makes it easy for an agent to extract relevant 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?

The tool is complex with polling and two auth modes, but the description covers all essential aspects: what it does, when to use it, how to authenticate, what to expect in the response, and how to handle incomplete results. The output schema exists, yet the description still summarizes the key return fields, making it self-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%, but the description explains all three parameters: job_id as the vetting_job_id from upload responses, api_key as developer key limited to the uploader, and claim_token as an alternative from draft uploads. This adds significant meaning beyond the raw schema definitions.

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 'Get the detailed security vetting report for a skill (poll by job_id, claim_token supported)', which clearly specifies the verb, resource, and the polling mechanism. This distinguishes it from sibling tools like check_vetting_status by emphasizing 'detailed report' and the official path.

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: it is the official recommended path for agents to receive final results over HTTP without email, and explains when to poll (if is_done=false) and typical durations. However, it does not explicitly name alternative tools or state when not to use this tool, so it lacks full exclusions.

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

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

The description includes the return type ('category list string'), which adds some behavioral context. However, with no annotations provided, the description carries the full burden and does not disclose potential errors, side effects, or authentication needs. For a simple read-only list, this is minimally acceptable 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 short and front-loaded, stating the purpose first. However, it includes a redundant Korean translation of the same English text, which adds no new information. Still, it is efficient 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?

For a simple 0-parameter list tool with an output schema present, the description provides the essential purpose and return type. It lacks usage guidance, but that is a separate dimension. Overall, it is complete enough for the tool's low 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 tool has zero parameters, so the schema is fully complete. The description does not need to add parameter semantics, and the baseline for 0-param tools is 4, which is appropriate here.

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

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

The description clearly states the tool's function: 'List all available skill categories on AI Skill Store.' It uses a specific verb ('List') and resource ('skill categories'), and is distinct from sibling tool list_platforms by focusing on categories.

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 provided on when to use this tool versus alternatives like search_skills or get_skill. There is no mention of prerequisites, context, or exclusions, leaving the agent without direction for tool selection.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. The verb 'list' and the return statement ('Returns: 플랫폼 목록 문자열') imply a safe, read-only operation, but there is no explicit mention of side effects, auth requirements, or other behavioral details. The description gives basic transparency but leaves room for more.

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 extremely concise with a clear structure: a one-sentence purpose plus a return note. The English and Korean phrases are somewhat redundant, but overall there is minimal waste and the key information is front-loaded.

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

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

For a zero-parameter, simple listing tool with an output schema, the description is complete: it names the tool's action, lists examples of the returned platforms, and explicitly states the return type (a string). No additional context is needed for an agent to use this 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?

The tool has zero parameters, so the description need not add parameter-level detail. The baseline for 0 params is 4, and the description appropriately omits any param explanation, which is 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 tool's purpose: 'List all supported platforms' with concrete examples (ClaudeCode, Cursor, etc.). This is a specific verb+resource combination that uniquely identifies the tool and distinguishes it from siblings like list_categories.

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 declarative 'List all supported platforms' — if an agent needs to know what platforms are available, this tool is the obvious choice. However, there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites, so it stops short of providing full context.

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 the one-review limit, update-on-recall behavior, self-review prohibition, and a rate limit (10/hour/IP). These go beyond what a typical schema would reveal, though error-handling details are omitted.

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 headers for policy and arguments. It is bilingual but not verbose; every sentence carries useful information. It is appropriately sized for the tool's complexity.

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 that the tool has an output schema (per context signals), the description doesn't need to explain return values. It covers all essential parameters, policy constraints, and rate limits. It's missing explicit error scenarios, but is complete enough for a review submission 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%, but the description compensates by adding meaning: rating is an integer 1-5, comment is optional up to 2000 chars, and api_key is described as required (though schema marks it optional with default). This adds value beyond the bare schema types. There is a slight inconsistency in api_key requiredness between description and 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 'Post a review and rating for a skill', a specific verb+resource combination. It clearly distinguishes from sibling tools such as upload_skill or validate_compatibility, as no other sibling handles reviews.

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 usage context: one review per user, re-call to update, cannot review own skill. It doesn't name explicit alternatives, but no alternative review tool exists among siblings, so the guidance is 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?

No annotations are provided, so the description carries the full burden. It discloses a critical behavioral trait: the API key is not issued immediately and requires email verification, with a security rationale. This goes beyond basic registration semantics and gives the agent important expectations about the process.

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 structured with Args and Returns sections, and is reasonably concise. The bilingual repetition (English and Korean) is somewhat redundant for an AI agent, but it doesn't harm clarity. It is not overly verbose and the main points are 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?

The tool is simple (2 required params, no enums/nested objects) and has an output schema, so the description does not need to explain return values. It covers the main workflow (registration, email verification, delayed API key) and parameter constraints. It is 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?

The schema provides no descriptions (0% coverage), so the description must compensate. The Args section adds meaningful constraints: username must be alphanumeric, at least 3 characters, and unique; email is required for verification and receives a verification link. This fully explains both parameters' purpose and rules.

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 ('Register') and resource ('developer account on AI Skill Store'), and distinguishes this from sibling tools like upload_skill or get_skill. It also mentions the key follow-up behavior (API key after email verification), making the tool's 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?

The description does not explicitly state when to use this tool versus alternatives or provide exclusions. However, the name and purpose make it clear this is for account registration, and the sibling tools are all different actions. Usage context is implied but not explicitly articulated.

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 return fields (name, description, downloads, rating, trust level) and the popularity-based sorting behavior for agent-optimized search. It doesn't cover potential errors or pagination, but it's still substantive.

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 structured with an overview, Korean translation, and an Args block. Each line earns its place, though the bilingual repetition adds slight redundancy. Still, it's front-loaded and well-organized.

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 7 parameters with 0% schema coverage and an output schema present, the description covers all parameters, return values, and special search modes. It is complete enough for an agent to invoke correctly without additional info.

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 compensates fully by explaining each parameter in detail—including behavior like 'empty query returns full list' and constraints like 'sort only applies when agent search is not used.' This adds significant value beyond the default-only 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?

Clearly states 'Search skills on AI Skill Store' with a specific verb and resource. It differentiates from siblings like get_skill by focusing on search, though it doesn't 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?

Provides clear guidance on using capability or platform for agent-optimized search and notes that sort/category only apply when not using agent search. However, it doesn't explicitly state when to use this tool over siblings like get_skill.

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 transparency burden. It discloses the API-key requirement, the two upload modes with priority behavior, and the return fields (version_id, vetting_job_id, poll_url). It does not discuss error conditions or side effects, but this is strong coverage for the described operation.

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

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

It is front-loaded and logically organized into mode sections and an Args list. Some redundancy exists because the Args list repeats information already given in the mode descriptions, and there is bilingual duplication, but this is acceptable given the tool's complexity.

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 6 parameters, conditional modes, and a required API key; the description covers all of these, explains return values, and references the relevant fallback sibling. It is complete enough for an agent to select and 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 fully compensates. Every parameter is explained—api_key is marked required, skill_md and file_path are described per mode, files/author_agent get type examples, and requirements is clearly defined.

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?

Opening sentence 'Upload a skill package to AI Skill Store' states a specific verb, resource, and scope. It also distinguishes itself from sibling 'upload_skill_draft' by explicitly noting the API-key requirement and naming the alternative.

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

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

The description gives explicit when-to-use guidance: use upload_skill_draft if you lack an API key. It also details two mutually exclusive usage modes, states that only one should be provided, and specifies that JSON content mode takes priority if both are supplied.

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 behavioral transparency burden. It discloses that non-approved drafts are immediately deleted, results are sandbox tier with claim_status='draft', agent_secret is required to avoid 401 errors, email validation uses DNS resolve checks, and verify links expire after 24 hours with up to 3 reminders. It also explicitly instructs agents not to auto-retry or complete claims. This is exceptional transparency.

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 long and detailed, but well-structured with a front-loaded summary, policy section, numbered mandatory behaviors, and Args/Returns sections. The bilingual duplication at the start adds minor redundancy, but overall every sentence carries essential information for safe and correct use. It is heavier than ideal, but the complexity of the tool justifies the length.

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

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

Given the tool's complexity, zero schema coverage, no annotations, and 7 parameters, the description covers all required context: policy, auth flow, human-action requirements, output summary, and parameter edge cases. It even includes error codes (AGENT_SECRET_REQUIRED, CONTACT_EMAIL_INVALID) and reminder cadence, making the tool self-contained for an agent 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%, but the description's Args section explains each of the 7 parameters in depth. It adds crucial semantics beyond the schema: agent_author must match the X-Agent-Author header, agent_secret is mandatory after first upload, contact_email must be a real user email or left empty (fabricated emails cause CONTACT_EMAIL_INVALID), and claim_token is only for new versions of the same draft. The description fully compensates for the schema's lack of 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 identifies the tool's function: 'Upload a skill without an API key (zero-friction). Returns a claim_token to track status.' This is a specific verb+resource combination that distinguishes it from the sibling upload_skill, and the zero-friction aspect clarifies its unique value.

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

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

The description states it is 'Perfect for agents contributing skills autonomously' and provides explicit policy constraints (AI 검수(approved)만 수락, 그 외 즉시 삭제) and mandatory agent actions (e.g., store agent_secret, surface claim_url, wait for human_action_required). This gives clear contextual usage guidance, though it does not explicitly name an alternative tool for when an API key is available.

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 full burden. It explains the validation criteria (requirements, platform compatibility) and the return summary (compatibility, missing packages, install command), giving a good sense of behavior. It does not explicitly state whether the operation is read-only or if any side effects occur, but 'check' implies a safe operation.

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

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

The description is well-structured with a short introductory sentence, a concise args list, and a returns section. It is not excessively long, though the bilingual text adds a slight redundancy without hurting 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?

The description covers the tool's purpose, all parameters, and the return format. Given the tool's moderate complexity (5 params, nested object), it provides enough context for an agent to decide when to invoke it. It does not need to explain the output schema in detail since the description already summarizes the return value.

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 descriptions are completely absent (0% coverage), so the description must compensate. It does so by listing all five parameters with brief explanations and examples, such as python_version format and installed_packages structure. However, it does not mention default values for parameters that have them 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 clearly states the tool checks compatibility of a skill with a specific platform before downloading, using a specific verb and resource. This distinguishes it from sibling tools like download_skill or get_install_guide.

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 usage context with 'before downloading', implying when to invoke the tool. However, it does not explicitly mention when not to use it or point to alternative tools.

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