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 states the core function but reveals no behavioral traits — no read-only guarantee, no side-effect information, no indication of what the verdict looks like, and no mention of whether all factors must be supplied. It is not misleading, but it is thin for a tool with 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?

A single front-loaded sentence states the purpose and enumerates the factors with zero filler. While it is thin relative to the tool's complexity, as pure conciseness the structure is efficient and every word 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?

For an 8-parameter tool with no annotations and 0% schema coverage, one sentence under-specifies. The output schema covers return values, but the required skill_id is unexplained, usage context is absent, and the agent gets no sense of which parameters to provide in which scenario.

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 enumerate the dimension parameters (operating_system, mcp_client, installed_software, has_gpu/has_hpc, available_licenses, api_access), which adds some conceptual meaning, but it never mentions the required skill_id and gives no format or value semantics for the array parameters.

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 (判断/determine) and identifies the resource (compatibility) along with the factors considered: OS, MCP client, software, GPU/HPC, licenses, and API. It is inherently distinct from the sibling tools, which are all search/get/diff/report operations, though it never explicitly names the skill being checked — the required skill_id parameter must carry that implication.

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 such as search_skills, doctor, or get_skill_card. The only usage signal is the implied scenario of checking a skill against an environment, which an agent must infer from the single purpose sentence rather than from explicit direction.

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 usefully reveals that when no historical version exists, the tool explicitly returns 'unchanged'. But it does not disclose whether the operation is read-only, how null versions are handled, or what 'unchanged' looks like in the response.

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 main purpose and adds a relevant edge-case behavior in the second clause. There is no filler or redundant wording.

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 and has an output schema, so return-value documentation is already covered. However, given zero annotations and zero parameter documentation, the description leaves important invocation details unexplained, such as default version behavior, null handling, and how versions are identified. It is adequate but not fully 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 by explaining parameter meaning. It only hints at 'two registered versions', which loosely maps to to_version and from_version, but it does not explain skill_id, the meaning of null/default values, or how versions are selected. This is insufficient compensation for the missing 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 action ('compare') and the resource ('two registered versions of a Skill'), so the core purpose is unambiguous. It does not explicitly distinguish itself from siblings, but the diff-specific purpose is evident from the name and description.

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

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

The description implies that this tool is for comparing versions of a Skill, and it adds one conditional behavior about the no-history case. However, it does not provide explicit guidance on when to use this over alternatives like get_skill_content or check_compatibility, nor does it mention prerequisites for invoking the comparison.

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 explaining behavior. It names the areas checked but does not disclose whether the tool makes network requests, modifies state, is read-only, or how it reports failures. A vague 'diagnose' leaves important behavioral traits unspecified.

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 brief and front-loaded with the verb, but it is more under-specified than intentionally concise. The semicolon-separated list covers many topics without prioritizing or explaining them, so the brevity saves space at the cost of 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, so return-value details are not required, but the description still lacks essential context: what diagnostics are performed, side effects, and the meaning of the check_github parameter. For a tool with one optional parameter, the description is incomplete for confident 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 sole parameter check_github is completely ignored by the description, and the schema provides only its type and default with no description. With 0% schema description coverage, the description needed to explain this parameter but did not.

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

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

The description uses the verb '诊断' (diagnose) and lists specific systems (MCP, dual database, FTS, GitHub HTTPS, local objects, hash state), so it conveys a diagnostic purpose. However, it is vague about what diagnosing actually entails and does not explicitly differentiate itself from the sibling skill-related tools beyond the broad domain.

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, no conditions for calling it, and no mention of prerequisites or expected context. The sibling names suggest a different domain, so an agent could infer it is a diagnostic tool, but the description itself provides no direct routing information.

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 and does a good job: it discloses the source (GitHub), the validation step, the fallback behavior on failure (local cache), and the return form (short-term signed link). It does not mention auth, rate limits, or side effects, but these are not strongly implied by the 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 a single compact sentence with no filler. It front-loads the core fetch-and-validate behavior, then states the fallback and return value. Every clause adds meaningful 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 core behavior and return shape are covered, and the presence of an output schema reduces the need to explain return details. However, with no annotations and no parameter-level documentation, the description leaves important gaps around skill_id semantics, prefer_github's effect, and when this tool should be selected over its siblings.

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 needed to compensate for documenting skill_id and prefer_github. It does not explicitly define either parameter; prefer_github is only indirectly implied by GitHub-first behavior, and skill_id is left entirely to the schema's name. 'Fixed commit' is also not clearly mapped to any 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 names a specific verb and resource: it fetches and validates a skill bundle from GitHub by a fixed commit, falls back to local cache, and returns a short-term signed link. This clearly separates it from sibling tools like get_skill_card or get_skill_content, which target different resources or operations.

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 what the tool does but gives no explicit guidance on when to use it versus siblings such as get_skill_content, check_compatibility, or diff_skill_versions. There are no conditions, exclusions, or alternative recommendations; the intended use case is only vaguely implied by the GitHub/cache fetch behavior.

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 behavioral burden. '获取' conveys a read/retrieval operation, but the description does not disclose whether any checks or side effects occur, whether authentication is needed, or how errors are surfaced.

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 sentence with a colon-delimited list covers the full purpose without wasted words. The main verb and resource appear first, making the definition 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?

For a single-parameter getter, the description plus the provided output schema is near-sufficient, and the listed content covers what the card contains. However, it lacks usage context, behavior notes, and parameter guidance, so an agent may still need to infer when to call it.

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

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

The single required parameter skill_id is not explained in the description beyond the schema's title 'Skill Id' and the tool name. With 0% schema description coverage, the description should compensate by specifying the expected format or source of skill_id, but it does not.

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

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

The description names a specific action ('获取' / get) and a distinct resource ('统一状态卡' / unified status card), then enumerates its contents: purpose, dependencies, risks, license, source, version, and suggested actions. This clearly separates it from sibling getters like get_skill_content and get_skill_bundle.

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 sentence indicates when to use this tool instead of search_skills, get_skill_content, check_compatibility, or diff_skill_versions. The context is implied only by the resource name; there is no explicit guidance or exclusion.

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. 'Read' conveys a non-mutating operation, and the text/binary distinction sets useful expectations. However, it does not mention what happens if the file is missing, path restrictions, or encoding, leaving some behavioral 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 a single focused sentence with no filler. It front-loads the primary action and then states a key limitation, making it easy to parse quickly.

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 read tool with an output schema, the description is mostly complete: it defines scope, file type, and the binary-asset limitation. It could be slightly stronger with an explicit pointer to get_skill_bundle for binary assets, but the context signals already suggest that path.

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 should compensate. It adds that the file is inside the Skill directory and that only text files are supported, which helps interpret relative_path. It does not elaborate on skill_id, but the parameter name and the default relative_path provide reasonable context.

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 ('read') and resource ('a text file in the Skill directory'), which clearly states the tool's function. It also draws a boundary by noting binary assets are only available via content packages, distinguishing it from sibling tools like get_skill_bundle.

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 says binary assets are only provided through content packages, which implies this tool should be used for text files and not for binary assets. It does not name an alternative tool directly, but the sibling list and wording make the intended split 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It says submissions go to a 'local review queue,' which hints at persistence, but it does not explain whether the action is irreversible, whether authorization is required, whether duplicates are handled, or what side effects occur. The description is too sparse for a write/report 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 a single, focused sentence that front-loads the tool's purpose and includes concrete examples of accepted issues. It is concise and free of filler, though it is somewhat minimal and does not use the available space to add parameter or behavior details.

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 4 parameters, 2 required, no annotations, and no schema-level descriptions. The description covers the tool's general purpose but not the required inputs, the optional inputs, or the expected behavior after submission. An agent asked to call this tool would have to infer the roles of message, contact, and skill_id from names alone. The output schema may cover return values, but other context needed 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 for undocumented parameters. It does mention categories that map to the enum values (broken_link, wrong_tag, license, usage_problem), but it does not explain the meaning or usage of 'message,' 'contact,' or 'skill_id.' The category list largely duplicates what is already visible in the schema enum.

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 action ('submit'), a target resource ('local review queue'), and enumerates the issue types (broken links, wrong tags, licenses, usage problems). This clearly distinguishes it from sibling tools like get_skill_card, check_compatibility, and doctor, which perform reads or diagnostics rather than issue reporting.

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 that this tool should be used when a user wants to report skill issues such as broken links or incorrect tags. However, it gives no explicit when-not-to-use guidance, does not mention alternatives, and does not address whether certain issues should go to doctor instead. The 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?

No annotations are provided, so the description carries the behavioral transparency burden. It makes clear this is a retrieval operation and that it returns match explanations, but it does not disclose pagination behavior, ordering, how structured filters combine, or any caveats around fields like external_skill_url or github_unreachable.

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

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

A single Chinese sentence conveys the action, resource, input modes, and output behavior with no wasted words. It is front-loaded around the core purpose and efficiently scannable.

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

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

With 11 input parameters, no annotations, and no per-parameter schema descriptions, the description is too sparse for an agent to call the tool confidently. It doesn't explain filter value formats, defaults, pagination, or special flag semantics, leaving too much to infer despite the existence of an 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?

Schema description coverage is 0%, so the description must compensate, but it only gestures at 'structured conditions' without explaining any of the 11 parameters. The natural-language role of 'query' is implied, while limit, offset, stages, domains, methods, software, statuses, launch_only, external_skill_url, and github_unreachable are left entirely to their names.

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

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

The description names the specific verb '检索' (search), the resource '科学计算 Skills', the input modes (natural language + structured conditions), and the expected output (explain matching reasons). This clearly differentiates it from sibling tools like get_skill_card or get_skill_content, which retrieve specific skills.

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 search-oriented phrasing implies it should be used for discovery when you don't have a specific skill, while siblings fetch individual skill details. However, there is no explicit when-to-use / when-not-to-use guidance or mention of alternatives, leaving routing mostly to inference.

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