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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the output shape (pass/warn/fail per pillar, plus blocking reasons) and the dependency on 'the skill's latest pipeline run', but says nothing about whether the call is read-only/non-mutating, cost, or what happens when no pipeline run exists.

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

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

Three tight sentences: purpose first, return semantics second, call condition last. No filler and nothing repeated from the schema or name.

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

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

With no output schema, the description correctly compensates by explaining the return values and the meaning of a blocking result, which is what an agent needs to act on the response. It is nearly complete for a one-parameter read tool; only edge-case behavior (skill with no pipeline run, read-only guarantee) is unstated.

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

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

The single parameter has 100% schema description coverage ('Skill UUID or slug.'), so the schema does the work and the description adds no further parameter meaning. Baseline 3 is appropriate for a fully documented parameter set.

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 gives a specific verb and resource ('Check whether a skill is cleared to run unattended') and immediately scopes the result ('pass/warn/fail across the four harness pillars'). It is clearly distinguishable from validation/lint siblings by the 'unattended run clearance' framing, though it never names a sibling to disambiguate against skills.flightCheck or skill.reliability.

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?

'Call this before using a skill for a task you will not review' states a concrete triggering condition. There is no explicit exclusion or named alternative, but the when-to-use context is clear enough that an agent knows when the tool applies.

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

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

No annotations provided. Description only mentions requires API key, but no info on side effects, permissions, or what happens on install (e.g., overwrite, conflicts). Minimal behavioral disclosure.

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

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

Single sentence, no wasted words. However, too brief to cover necessary 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?

With one required param and no output schema, description does not fully specify parameter semantics or return value. Missing key info for correct invocation.

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

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

Schema has 0% description coverage. The single parameter 'slug' is not explained in description or schema. Agent cannot know what value to provide.

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

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

The description clearly states the action (install) and resource (public marketplace skill into library). It distinguishes from sibling tools like listSkills, pullSkill, pushSkill.

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?

Implies use when you want to install a marketplace skill, but no explicit when-not or alternative guidance. Context signals show many sibling tools, but description doesn't differentiate usage scenarios.

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

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

No annotations provided, but the description discloses that it lists skills, the returned fields (ai_type, source_platform, source_path, repo), and the API key requirement. It does not mention read-only or idempotency, but for a list operation this is 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?

Three sentences, front-loaded with the main purpose, no wasted words. Each sentence 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?

Given it is a list tool with two optional parameters and no output schema, the description covers filters and output structure adequately. It does not mention pagination or error handling, but these are not critical for a simple list 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 coverage is 100%, so baseline is 3. The description adds the specific enum values for ai_type and source_platform (e.g., 'skill|hook|...'), which are missing from the schema examples, providing valuable additional 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 clearly states the action ('list skills') and the resource ('cloud library'), and distinguishes from siblings like cloud.installMarketplaceSkill by being a listing operation.

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

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

The description mentions filters and the requirement for MODELBOUND_API_KEY, but does not provide explicit guidance on when to use this tool versus alternatives like skills.listLocal or cloud.search.

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 usefully discloses the authentication requirement (MODELBOUND_API_KEY) and specifies response fields (ai_type, source_platform, source_path, repo). This adds meaningful behavioral context beyond the action itself, though side effects or mutability are not addressed.

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 only two sentences. The first sentence states the primary action, and the second adds response details and a key requirement. No redundant or irrelevant information is present, making it efficient and easy to parse.

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 one parameter and no output schema or annotations, the description provides the action, response fields, and auth requirement. However, it fails to explain the 'slug' parameter, which is essential for usage. Compared to similar tools, this omission makes it incomplete, though the provided details are useful.

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 one required parameter 'slug' with no description, and schema description coverage is 0%. The description does not explain what 'slug' represents or how to use it, failing to add meaning beyond the bare schema. This is a significant gap for the agent to properly invoke the tool.

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

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

The description clearly states the action 'Pull a skill from the ModelBound cloud library,' using a specific verb and resource. The sibling tools (e.g., cloud.pushSkill, cloud.listSkills) have distinct names that imply different actions, but the description does not explicitly differentiate from them. Thus it is clear but lacks explicit 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 context for when to use the tool (to pull a skill) but provides no guidance on when not to use it or what alternatives exist (e.g., cloud.listSkills for listing, cloud.pushSkill for uploading). No exclusions or comparisons with siblings are mentioned, leaving the agent without clear decision support.

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

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

No annotations are provided, so the description carries full burden. It discloses the upsert behavior ('Create or update') and the API key requirement, but fails to mention error states, whether updates overwrite or merge, rate limits, or idempotency. This is insufficient for a mutation tool.

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

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

The description is concise at two sentences, with the first sentence stating the purpose and the second noting an important requirement. No unnecessary words, though the parameter information is missing.

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

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

Given no output schema, no annotations, and 3 parameters with zero description coverage, the description is too sparse. It does not explain return values, error handling, or the distinction between creation and update, leaving the agent underinformed.

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 3 parameters (slug, title, body_md) with 0% schema description coverage. The description adds no information about these parameters beyond what is already in the schema 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 'Create or update a skill in the cloud library.' It uses a specific verb (create/update) and resource (skill in cloud library), and distinguishes from sibling tools like cloud.listSkills (list) and cloud.pullSkill (download).

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 mentions the requirement of MODELBOUND_API_KEY, implying authentication context. However, it does not explicitly state when to use this tool versus siblings like cloud.installMarketplaceSkill or cloud.pullSkill, nor does it provide when-not-to-use 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 provided, so the description carries full burden. It describes the return structure (grouped hierarchy) and mentions API key requirement, but does not disclose any side effects, error handling, or read-only nature. It adds some value beyond the name but lacks depth.

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

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

Two sentences, each earning its place: first sentence states purpose, second sentence provides usage guidance and prerequisite. No redundant or vague 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?

Given no required parameters and no output schema, the description provides adequate context about the resource hierarchy structure and when to use. It does not detail return format or pagination, but for a hierarchy retrieval tool, 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?

Schema coverage is 100%, so baseline is 3. The description does not add additional meaning beyond the schema; it only mentions 'Optional: restrict to a single source platform' for 'platform' and similarly for 'repo'. No further elaboration on values or format.

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 'Return' and clearly identifies the resource as 'team's full AI resource hierarchy grouped by platform → top-level directory → files'. It explicitly distinguishes from sibling tool 'listSkills' by stating when to use this tool before that one.

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 states when to use this tool ('Use this BEFORE listSkills when an orchestrator needs to map available context before loading') and provides a prerequisite ('Requires MODELBOUND_API_KEY'). This gives clear guidance on usage context and alternative.

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 present. Description only states API key requirement but doesn't clarify if read-only, destructive, rate limits, pagination, or result format.

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

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

Two sentences, front-loaded with purpose and requirement. No unnecessary text.

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?

Lacks details on scope of search, output format, error handling. With no output schema or annotations, description is insufficient for full understanding.

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

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

Schema description coverage is 0%. Description does not explain the single parameter 'q' (e.g., query syntax, format). Adds no meaning beyond 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 'Full-text search across all cloud content', a specific verb+resource, and distinguishes from sibling tools which are about skills management, resource tree, etc.

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?

Only mentions a prerequisite (requires API key) but provides no guidance on when to use this tool vs alternatives or when not to use.

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 supplied, so the description carries the full behavioral burden. It discloses the agent-scope authorization requirement, which is genuinely useful, but says nothing about persistence of the created case, side effects, or whether the write is idempotent.

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 the action front-loaded and the scope requirement trailing. Nothing is wasted, though the parenthetical field list reads as schema restatement rather than added 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 6-parameter mutation tool with no annotations and no output schema, the description is minimally viable. Two parameters receive no coverage and the return behavior is unaddressed, leaving gaps an agent would have to guess at.

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

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

Schema description coverage is 0%, so the description must compensate and only partially does: it names name, input_prompt, expected_output and rubric and marks expected_output as optional. It adds no format meaning, and agent_id and description go entirely unmentioned.

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 ('Create a new eval test case') and enumerates the core payload fields, so the agent knows exactly what is produced. It does not differentiate itself from the near-identical sibling skill.createTestCase, which is the main clarity risk here.

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 prerequisite 'Requires agent scope' is useful context for when the call is valid, but there is no guidance on when to prefer this tool over skill.createTestCase, eval.run, or eval.listCases. Usage is implied by the verb rather than stated.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose the agent-scope authorization requirement, which is genuinely valuable, but says nothing about return ordering, filtering, or how many cases come back — notable for an unpaginated list 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?

Two short sentences, zero waste, with the core action front-loaded and the constraint in the second position. Nothing here can be trimmed without losing 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 no-parameter read-only list operation with no output schema, the description is nearly sufficient: it establishes scope and the auth prerequisite. The only real gap is what the returned cases look like and whether the list is bounded, which an agent would otherwise have to discover by calling 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 tool takes zero parameters, so there is no parameter semantics to document and the baseline of 4 applies. The empty schema is consistent with a tool that lists all cases with no filtering input.

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 ('List all eval cases') plus a scope modifier ('for the team'), so an agent can immediately tell it apart from eval.createCase (write) and eval.listResults (different resource). It stops short of explicitly naming sibling alternatives, which keeps it at a 4 rather than a 5.

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

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

'Requires agent scope' communicates a prerequisite for invocation, which is useful. However, it gives no when-to-use/when-not guidance and never points to the related eval.run, eval.createCase, or eval.listResults tools, so the usage context is only implied.

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, yet it discloses almost nothing beyond the bare operation. It omits that results are paginated/limited (limit defaults to 50), the ordering of results, or whether there is a cap on returned items.

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 efficient sentence with the verb and filter front-loaded and no filler. It is tight, though brevity here comes at the cost of missing detail rather than being earned by completeness.

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 listing tool with no annotations, no output schema, and an undocumented limit parameter, the description is too thin. An agent cannot tell how many results to expect or how pagination behaves.

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 both parameters rely on the description. Only eval_case_id is implicitly covered; 'limit' and its default of 50 are never mentioned, leaving the truncation behavior unexplained.

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

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

States a specific verb (List) and resource (past eval results) with a scope qualifier. It is reasonably distinguishable from eval.listCases and eval.run, though it does not explicitly contrast itself with them.

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 phrase 'optionally filtered by eval_case_id' hints at one usage mode but never states when to call this versus eval.listCases, eval.run, or eval.createCase. No prerequisites or when-not guidance is given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It notes that omitting score/pass triggers an AI judge, but says nothing about whether re-submitting overwrites a prior result, what permissions are needed, or what the automated judge_type does. For a mutation-style submit tool this is a substantial gap.

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

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

Two tight sentences with the core action front-loaded and no filler. The judging-mode note follows the action in a sensible order. Slightly terse given the unmet parameter and behavioral needs.

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?

Five parameters with low schema coverage and no annotations or output schema, yet the description only addresses the score/pass/judge path. An agent still lacks guidance on judge_type 'automated', submission semantics on repeat calls, and what the call returns, so it is only minimally adequate.

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 only 20%, so the description must compensate and partly does: it explains that score and pass drive manual judging while omitting them delegates to the AI judge, and it names the required eval_case_id/actual_output implicitly. But judge_type's 'automated' value and the exact meaning of score vs pass are left to inference.

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: submit actual output for scoring against an eval case. This clearly separates it from siblings like eval.listCases and eval.listResults, which read rather than submit. It does not explicitly name those siblings, so it stops short of a 5.

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

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

The second sentence gives conditional guidance ('Pass score/pass for manual judging or omit for AI judge'), which is genuinely useful routing between judging modes. However, it never says when to use this tool versus eval.createCase or eval.listResults, so usage versus alternatives is only implied.

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 and does real work: it declares the operation is local-only with no network access, and it discloses the return shape ('list of matching adapters' with concrete examples). It stops short of stating it is strictly read-only/non-mutating or what happens when no layout matches.

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

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

Two tight sentences with zero filler: the purpose lands first and the execution/return constraints follow. Every sentence 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 a zero-parameter, read-only probe with no output schema, the description covers purpose, safety profile, and return contents, which is nearly all an agent needs. Minor gaps remain (no-match behavior, relationship to the sync/listing siblings) but nothing required to call it correctly is missing.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4; there is no parameter surface for the description to explain or compensate for.

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 pairs a specific verb ('Detect') with a specific resource ('IDE skill/rule layouts'), plus the scope ('in the current working directory'), so the agent knows exactly what is inspected. It does not, however, contrast itself with related siblings such as sync.fromIde or skills.listLocal, which is the only thing keeping this from a 5.

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

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

The only usage-flavored statement is 'Local-only, no network,' which is a constraint rather than a when-to-use rule. Nothing tells the agent when to prefer this over sync.fromIde or skills.listLocal, nor what precondition it satisfies.

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 zero annotations the description carries the full burden, and it discloses the important traits: non-destructive ('never writes'), return value ('projected savings'), safety for automated callers, and the required MODELBOUND_API_KEY. It omits rate limits or what state the projection is computed against, keeping 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?

Four short, front-loaded sentences with zero filler: identity, return value, safety, and a hard requirement. Every sentence 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 a five-parameter, no-annotation tool with no output schema, the safety and auth story is well covered, but the description never addresses the parameters the agent must populate, leaving a real gap before it can be called 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% across five parameters (file_id, pack_id, agent_id, skill_id, intensity), and the description adds no meaning for any of them. It does not explain which identifiers are needed or how 'intensity' changes the projection, so the agent gets no help on invocation.

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

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

The description states a clear operation (a dry-run variant of optimization.run) and explicitly distinguishes it from that sibling by 'never writes' and by returning projected savings. It loses a point only because it never says what optimization actually does (files, packs, agents, 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?

'Same as optimization.run but never writes' tells the agent to prefer this variant whenever it wants a preview, and 'Safe to call from auto-suggest hooks' gives an explicit qualifying context. No explicit exclusions are given, but the when-to-use 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?

No annotations provided. Description indicates read-only operation and auth requirement, but no details on side effects or performance.

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

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

Two sentences, front-loaded with action verb, no wasted words.

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

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

Adequate for a simple parameterless tool, but lacks output schema or return format details.

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?

No parameters, so baseline 4 applies. Description adds context about what the tool returns.

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

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

Description clearly states the verb 'Get' and the resource 'token health scores and staleness for your context library'. Siblings are unrelated, so differentiation is not needed.

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?

Implied usage: call to get health data. Mentions API key requirement but no explicit when to use or alternatives.

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

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

With no annotations, the description carries the full burden. It implies a read operation but never states it, and gives no guidance on cache-miss behavior (error vs. regenerate), permission requirements, or whether the cached variant can be stale. These are material behaviors for a 'cached' fetch 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?

Two dense sentences with zero filler, and the core purpose is front-loaded ahead of the usage hint. Efficient and readable.

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 2-param tool with no annotations, no output schema, and 0% schema description coverage, the description should at least clarify param selection and cache-miss behavior. It does neither, so an agent could invoke it with neither ID or with both and have no idea what to expect.

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

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

Schema coverage is 0% and neither file_id nor skill_id is documented. The phrase 'of a skill or file' loosely maps to the two params but does not explain the required/optional relationship (0 required), mutual exclusivity, or ID format, so it barely compensates for the coverage 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?

States a specific verb+resource ('Fetch a cached optimized variant of a skill or file') and adds the key constraint 'without re-running optimization,' which implicitly separates it from optimization.run/dryRun. It does not explicitly name those siblings, so it falls short of a 5.

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

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

The phrase 'Useful when an agent wants the lean version for inference but the raw version for editing' implies a usage scenario, and the no-re-run clause hints at the alternative (optimization.run). But there is no explicit when-to-use/when-not statement or named alternative, leaving the agent to infer.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses an auth requirement (MODELBOUND_API_KEY), states that the server automatically creates a backup version, and warns that local-file edits require a caller-side BackupEngine snapshot first. This is meaningful side-effect and safety disclosure, though reversibility and failure behavior are not addressed.

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

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

Three sentences, front-loaded with the action, then outputs, then requirements. No filler; each sentence carries distinct 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?

There are no annotations and no output schema, yet the description covers return fields, auth, backup behavior, and the local-edit prerequisite. The remaining gap is the undocumented ID selection semantics and intensity meaning, but the critical invocation context is present.

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 only 17% (only dry_run is documented), so the description should compensate. It names the four resource kinds, loosely mapping to skill_id/file_id/agent_id/pack_id, but never states that exactly one ID should be supplied nor explains intensity or the version snapshot, leaving most 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?

States a specific verb ('Run AI token optimization') and the resource types it operates on (cloud skill, file, agent, pack), and the mention of returning a version snapshot id signals it is a mutating run, not a preview. It doesn't explicitly contrast itself with siblings like optimization.dryRun or optimization.preview, so an agent must infer 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?

Provides concrete prerequisites: 'Requires MODELBOUND_API_KEY' and the MUST-snapshot requirement for local-file edits. However, it offers no explicit when-to-use/when-not guidance versus optimization.dryRun or optimization.preview, leaving the alternative selection to be inferred from the dry_run parameter.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose the meaningful trait that the tool dispatches between read and merge-update based on presence of `config`, which is more than the name conveys. However, it says nothing about permissions, whether updates are reversible, how keys are validated, or whether fields can be cleared.

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

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

Two tight clauses, front-loaded with the read/update purpose and finished with the mode-selection rule. The parenthetical field list is dense but every token carries information, and nothing is repeated.

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 nested-object mutation tool with no annotations and no output schema, the description is only partially sufficient: it explains the update trigger and lists config fields but omits what a read returns, sub-field types/defaults, and mutation side effects. Adequate to invoke, thin on guarantees.

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 50%: `config` is documented (partial merge, omit to read) while `skill_id` is bare. The description compensates somewhat by enumerating the config sub-fields (max_latency_ms, enforce_latency/enforce_tests flags, default targets), adding meaning beyond the schema, but it gives no types, defaults, or merge-edge behavior.

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

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

States a specific verb pair (read/update) and resource (a skill's pipeline_config), and enumerates the fields under management (max_latency_ms, enforce_latency/enforce_tests flags, default targets). It implicitly separates itself from pipeline.run/pipeline.status by scope, though it never names those siblings explicitly.

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

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

Gives explicit mode-selection guidance: 'Pass `config` to update; omit to read.' That tells the agent exactly which invocation shape triggers which behavior. It stops short of naming alternatives or stating when-not-to-use it (e.g., vs pipeline.run for execution).

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 and does add real value: it declares the MODELBOUND_API_KEY requirement, the side effect of streaming into skill_pipeline_runs, and the return shape. It omits failure behavior, reversibility, and the significance of override_gates and apply_optimization (dictated only by the schema), leaving meaningful 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?

Four tight sentences, front-loaded with the action and scope, each carrying distinct information (what it does, side effect, return, next step, prerequisite) with no waste.

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 7-parameter pipeline trigger with no annotations and no output schema, the description covers auth, side effect, and return values, but says nothing about parameter-driven behavior (stages, targets, gate overrides) or failure modes. Adequate but with visible gaps for a tool of this 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?

Seven parameters with only 57% schema description coverage, and the description contributes no parameter information at all. Undocumented parameters such as skill_id, changelog, and version_bump get no help from the prose, so the description fails to compensate for the coverage 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?

States a specific verb (Run), the resource (Skill Development Pipeline), and enumerates its stages (Test → Optimize → Production), which lets an agent distinguish it from optimization.run and skill.test. It also names the return shape and the streaming target (skill_pipeline_runs).

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 routes to pipeline.status for progress monitoring, which is useful sibling differentiation. However, it does not state when to prefer this full pipeline over the narrower optimization.run or skill.test alternatives, so usage is clear but incomplete.

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 does disclose a genuinely useful behavioral trait — poll every 1-2s while status is 'running' — which tells the agent this is a non-blocking read. However it omits permissions, whether the polling is safe/throttled, and what the response contains beyond the status field.

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

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

Three short sentences, zero filler, and the core purpose is front-loaded before the parameter guidance and the polling note. Every sentence adds distinct 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 read-only status tool with no output schema and no annotations, the description covers invocation mode, parameter routing, and polling behavior adequately. It does not describe the returned payload shape, but an agent can still call it correctly and interpret the 'running' vs terminal distinction.

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 it largely does: run_id is tied to 'a specific run' and skill_id + limit to 'recent runs'. The meaning of limit (how many recent runs) is only implied rather than stated, leaving a minor 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?

States a specific verb and resource ('Get pipeline run status'), clearly distinct from pipeline.run and pipeline.config by virtue of being a read of run state. It does not explicitly name a sibling or contrast itself, so it falls short of a 5.

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

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

Gives concrete selection guidance between the two access modes ('run_id for a specific run, or skill_id + limit for recent runs') and tells the agent how to behave while waiting. It lacks any when-not or alternative-tool routing (e.g. use pipeline.run to start a run), so it is clear context rather than 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?

With no annotations, the description carries the whole burden and does disclose real behavioral traits: a data-minimization constraint (never prompts or outputs) and a downstream effect ('Failed runs become outcome reports for the skill'), neither of which is in the schema. It stops short of stating auth requirements, rate limits, or what a successful call returns.

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

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

Three short sentences, front-loaded with the core action, and each adds something (purpose, content restriction, failure behavior). Slightly dense in the middle clause, but nothing is redundant 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 4-parameter write tool with no annotations and no output schema, the description covers purpose, permitted payload, and failure-path behavior well. The main gap is the absence of any statement about the return value or permission requirements, which matters more here because there is no output schema to lean on.

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 100%, so every parameter and nested step field is already documented in the schema; the description only gestures at the step fields it cares about ('name, kind, duration, tokens, status'). No additional syntax or semantics are added beyond what the schema provides, so the baseline 3 applies.

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 gives a specific verb and resource ('Report a finished agent run to ModelBound') plus the payload's purpose ('each step is tied to the skill that shaped it'), which is far more than a restatement of the name. It does not, however, differentiate itself from the closely related sibling skill.report_outcome, which an agent would have to disambiguate on its own.

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

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

It implies usage ('Report a finished agent run') and gives a clear content rule ('Send step summaries only ... never prompts or outputs'), but there is no explicit when-to-use versus skill.report_outcome or guidance on whether reporting should happen once per run or incrementally per step. The exclusion is about payload contents, not about choosing 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?

With no annotations, the description carries the full behavioral burden. It does disclose an auth requirement (MODELBOUND_API_KEY), which is genuine value, but says nothing about runtime cost, duration, side effects, or whether any data is modified — the operations surrounding it (test, optimize) suggest those questions matter.

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

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

Two short sentences with no waste, and the core purpose is front-loaded ahead of the prerequisite. Appropriate size for the information conveyed.

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?

No output schema and no annotations mean the description must convey return behavior and effects, and it does not. For a benchmark tool the agent has no idea what results it produces, how long it runs, or what the single parameter must contain.

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 skill_id is entirely undocumented in structured fields. The description's phrase 'for a skill' only weakly implies that skill_id identifies the target skill; it adds no format, ID-source, or constraint detail.

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: 'Run benchmark latency suite for a skill.' An agent can grasp the operation without opening the schema. It does not, however, distinguish it from siblings like skill.test or optimization.run, which could look similar.

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 a prerequisite ('Requires MODELBOUND_API_KEY') but no guidance on when to choose this over skill.test, optimization.run, or other evaluation tools. There are no exclusions or scenarios described.

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 must carry the full behavioral burden. It discloses the MODELBOUND_API_KEY requirement, which is valuable, but does not state whether the operation is read-only (though implied by 'compare'), what the output looks like, or any other constraints.

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

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

Two short sentences, front-loaded with the purpose. The auth requirement is a useful addition. The description is efficient, though terse given the gaps in other dimensions.

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 3-parameter tool with no annotations and no output schema, the description is incomplete. It omits parameter semantics, usage guidelines, and behavioral details beyond the API key requirement. An agent would have to infer much from the name and schema alone.

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 adds no meaning for the three parameters (skill_id, to_version, from_version). It implies two versions are being compared but does not explain defaults, formats, or which are required beyond the schema's required marker.

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 (Compare) and resource (skill versions), with a helpful example of 'latest vs current'. It distinguishes from skill.versions (which lists versions), but does not explicitly differentiate from skill.diff, which may also compare content.

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

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

Provides no guidance on when to use this tool versus alternatives like skill.diff or skill.versions. Only an auth prerequisite is mentioned; there is no context about appropriate scenarios 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 exist, so the description carries the full behavioral burden. 'Saved' hints at persistence, but the description says nothing about permissions required, whether duplicate names are rejected, validation rules, or side effects on the skill's evaluation set.

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

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

Two short sentences with the required-parameter summary front-loaded and set off by periods. No filler or repetition; it just stops short of adding higher-value 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 mutation tool with no annotations, no output schema, and 0% schema coverage across five parameters, the definition is too thin. It omits return behavior, the meaning of cross_repo, and any prerequisite context needed to invoke it confidently.

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 names four of five parameters (skill_id, name, prompt as required; notes 'for grading'), which is useful, but cross_repo is completely undocumented anywhere and the format/meaning of skill_id and prompt is not clarified.

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: 'Create a saved automated check test case for a skill.' An agent can tell the general action. However, it does not differentiate from the sibling eval.createCase, which appears to create a similarly-named artifact, so the boundary is left ambiguous.

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

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

No when-to-use guidance is provided. With siblings like eval.createCase, skill.test, and skill.testCases present, the description never says under what circumstances this tool should be chosen over those alternatives, leaving routing entirely to inference.

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

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

With no annotations, the description carries the full burden. It discloses the return format (unified diff) and the two diffing modes, which is useful. However, it does not address authentication, existence/error behavior for unknown versions, or read-only nature, leaving real gaps for a no-annotation 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?

Two short sentences, front-loaded with the core purpose followed by the actionable next-step hint. Every clause earns its place with no filler.

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

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

There is no output schema, so the description need not explain returns—yet it names the unified diff format, which is a bonus. Combined with the skill.versions pointer, it is nearly complete for a 4-param read tool; only the two undocumented required params leave a small hole.

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 only 50%: to_version and against_body are documented in the schema, while skill_id and from_version are bare. The description partly compensates by explaining the two-version mode and pointing to skill.versions for version labels, but it never clarifies what skill_id or from_version expect beyond the obvious.

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 (return a unified diff) on a specific resource (two versions of a skill), and clarifies the two modes: version-to-version or live-vs-arbitrary-string. It distinguishes itself from the sibling skill.versions by describing their complementary relationship rather than overlapping it.

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

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

It gives an explicit prerequisite/first-step: 'Use skill.versions first to find version labels,' which tells the agent how to obtain inputs. It lacks explicit when-not guidance or exclusions (e.g. use skill.compareVersions for semantic comparison), so it stops short of 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?

With no annotations, the description carries the full behavioral burden. It does disclose two genuinely useful traits: the auth requirement (MODELBOUND_API_KEY) and that results carry stable keys plus ignored_keys. However, it omits whether ignored findings are excluded, pagination behavior, and any read-only guarantee beyond the implicit 'List'.

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

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

Three short sentences, front-loaded with the core action and followed by the return shape and auth requirement. No filler, though the return-contents sentence is slightly terse given no output schema exists.

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

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

For a one-parameter list tool with no output schema, the description gives a workable picture: what is listed, what comes back, and what auth is needed. It still leaves open what a 'finding' contains, whether ignored findings are filtered, and how skill_id is resolved.

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 single required parameter skill_id is undocumented in both schema and description. The description never clarifies whether skill_id is a local skill name, a cloud ID, or workspace-scoped, which is a real ambiguity for an agent.

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: 'List safety and quality findings for a skill.' It also names the return contents (findings, ignored_keys), which helps distinguish it from the ignore/unignore siblings, but it never explicitly differentiates itself from adjacent listing tools such as skills.checks.

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 when-to-use guidance, no mention of prerequisites beyond the API key, and no routing to alternatives such as skill.ignoreFinding or skills.checks. The agent must infer the call context entirely from the tool name.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does add one genuinely useful non-schema fact - that MODELBOUND_API_KEY is required - but says nothing about whether the ignore is persistent across runs, whether it affects reports/checks, or how it interacts with the class/severity fallback matching that could suppress more than one finding.

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

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

Two short sentences, zero filler, and the core action plus the addressing mechanism are front-loaded before the credential note. Near-optimal sizing for the amount of information conveyed.

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 5-parameter mutation tool with no annotations and no output schema, the description is thin. It covers the credential requirement and the two lookup strategies, but omits the purpose of the required skill_id, the persistence/scope of an ignore, and any statement of what the tool returns or affects.

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% across 5 parameters, so the description must compensate. It loosely maps finding_key, class, severity, and message to the two addressing modes, which is real added value, but leaves the required skill_id unexplained, gives no formats or matching semantics, and never states whether finding_key takes precedence over the class/severity/message triple.

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 ('Ignore a finding') and even names the addressing mechanisms (stable key, or class/severity/message). An agent immediately knows what the tool operates on, though it never explicitly contrasts itself with the sibling skill.unignoreFinding, which is the only meaningful confusion risk.

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 rather than stated: the agent can infer it is called to suppress a known finding, and the parenthetical gives two targeting modes. There is no guidance on when to prefer this over alternatives, no precedence rule between finding_key and class/severity/message, and no mention that skill.unignoreFinding reverses it.

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

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

No annotations exist, so the description carries the full burden. It does disclose a genuine behavioral trait beyond the schema: the MODELBOUND_API_KEY auth requirement, plus the fact that data is a rolling window of real-use outcomes. It does not say whether results are per-skill aggregates or per-run records, how they are ordered, or what happens when no data exists for the window.

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

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

Three short sentences, front-loaded with what it returns, then when to use it, then the auth prerequisite. No filler and no repetition of the tool name.

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 read tool with no output schema, the description covers purpose, outcome vocabulary, usage intent and auth. It stops short of explaining the shape of the returned reliability data, which is the main remaining gap given there is no output schema to lean on.

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 100%: both 'days' (default 30) and 'skill_id' (optional Skill UUID) are fully documented in the schema. The description adds only the notion of a rolling window, which the schema already conveys; baseline 3 applies.

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 ('Read back'), a specific resource (team skill performance), and a concrete outcome taxonomy (worked / partial / failed) over a defined window. The phrase 'in real use' separates it from synthetic-evaluation siblings like skill.benchmark, eval.run and skill.compareVersions.

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 two explicit use cases: picking the most reliable skill for a task, and finding skills that need attention. It does not, however, name a specific alternative or state when NOT to use it (e.g., when to prefer skill.benchmark or skill.testRuns instead).

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the auth requirement ('Requires MODELBOUND_API_KEY') and the downstream effect ('it is how the skill gets improved'), plus an excerpt-length constraint, but says nothing about where the report goes, whether it is reviewed, or whether it can be revised after submission.

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

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

Three short sentences, front-loaded with purpose and trigger, each carrying a distinct piece of information. No filler, though it is quite terse given the operation's importance.

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 feedback-reporting tool with a fully self-documenting schema and no output schema, the description covers purpose, timing, and the one environmental prerequisite. Missing only return/confirmation behavior, which is minor here.

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 83%, so the schema already documents the parameters and enums. The description only adds the 'keep excerpts short' guidance for output_excerpt/prompt_excerpt, adding marginal value beyond the schema, which makes the baseline 3 appropriate.

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 ('Report how a skill performed') and ties it to the post-task moment. The purpose is unambiguous, though it does not explicitly distinguish itself from the near-named sibling report_run or skill.findings.

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 clear timing context ('Call this once the task that used the skill is finished'), which is the key trigger for invocation. It provides no explicit exclusions or named alternatives, so it stops short of 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?

With no annotations, the description carries the full burden, and it does disclose useful traits: the checks are deterministic (not LLM-judged) and the result is a categorical pass/warn/fail rather than a numeric score. It omits whether the check is read-only, whether it touches the filesystem or network, and what the heuristics actually inspect.

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

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

Two short, front-loaded sentences with no filler; the outcome semantics are stated immediately. The unexplained internal codename 'scanner h5' adds a token of jargon without turning it into 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?

With no output schema and no annotations, the description does cover the return shape at a high level (pass/warn/fail with findings), which is the most important missing structured data. It still leaves parameter meaning, usage routing, and side-effect profile unaddressed, so it is only minimally 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 single 'path' parameter has 0% schema description coverage, so the description must compensate. 'A local skill' hints that path points at a local skill, but it never clarifies directory vs file, absolute vs relative, or whether a skill root or a manifest is expected.

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 ('Check a local skill') plus the method ('deterministic heuristics, scanner h5') and the outcome type ('pass / warn / fail with findings'). It does not differentiate itself from close siblings such as skills.lint, skills.validateFormat or skills.flightCheck, so an agent must guess which checker applies.

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

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

No when-to-use, when-not-to-use, or alternative is offered. The word 'local' is the only routing signal, implicitly contrasting with cloud tools, but nothing tells the agent why to pick this over the many other skill-checking siblings.

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

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

No annotations are provided, so the description must fully disclose behavior. It explains the conversion process through a canonical representation and notes that omitting outPath returns the converted body without writing. However, it does not address error handling, overwrite behavior, or side effects, leaving gaps for an agent.

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 two sentences: the first states the core purpose with an example, the second explains the internal representation. No unnecessary words or repetition, making it easy for an agent 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?

Given the absence of an output schema, the description should explain return values more thoroughly. It mentions returning the converted body but not the format (e.g., string). It also omits error states and prerequisites. For a relatively simple tool, it covers core functionality but lacks completeness in edge cases.

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 75% (missing path description). The description indirectly implies path is the file path, but does not explicitly define it. It adds no additional parameter details beyond the schema, and for the undocumented path parameter, the description does not compensate fully. Baseline for high coverage is 3.

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 'convert' and resource 'skill file', with an example IDE format conversion (cursor → claude). It distinguishes this tool from siblings like skills.lint or skills.diff by specifying the conversion action and internal canonical representation.

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 an example but lacks explicit guidance on when to use this tool versus alternatives, such as when to convert vs. when to lint or diff. No prerequisites or limitations are mentioned, leaving the agent to infer usage 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?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It reveals the key requirement and that only the local side is computed. However, it does not specify whether the diff is destructive (likely read-only), the output format, or error handling. A more transparent description would clarify these aspects.

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 with two sentences, no unnecessary words. The first sentence front-loads the core purpose, and the second adds a critical behavioral note about the API key. This structure is efficient and easy to parse.

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 lack of an output schema, the description should ideally explain what the diff output contains (e.g., text, structured result). It also does not mention whether the tool is read-only or modifies files. While the key requirement is noted, the overall completeness is moderate; a user might need additional context to fully understand the tool's behavior.

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

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

The input schema has 100% description coverage, so the schema already defines both parameters ('path' and 'slug'). The description does not add any additional meaning beyond what the schema provides, maintaining the baseline score of 3.

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: diff a local skill file against its cloud counterpart by slug. It specifies the verb (diff), the resources (local file and cloud counterpart), and the method (by slug). This distinguishes it from sibling tools like cloud.pushSkill or cloud.pullSkill which perform sync 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 provides some usage guidance by noting that the local-side diff is computed here and the cloud half requires MODELBOUND_API_KEY. This informs the agent that a cloud diff depends on an external credential, helping decide whether this tool is sufficient. However, it does not explicitly state when to prefer this tool over siblings like skills.readLocal or skills.listLocal for comparison tasks.

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 and does disclose meaningful traits: offline/local-only execution, zero AI cost, and that findings carry blocking severity. It implies a non-destructive read (a scan), but says nothing about how results are surfaced or whether anything is persisted, so it stops short of full behavioral 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?

Three tight sentences, front-loaded with purpose and the enumerated checks, then the input options, then the usage constraint. No filler or repetition; the parenthetical list earns its space by defining scan scope.

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-param tool with no output schema and no annotations, the description covers what it checks, how to supply input, and the severity model ('blocking findings'). It does not describe the return shape beyond that, but enough is present to call it correctly.

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

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

Schema description coverage is 0% with two undocumented params, so the description must compensate — and it does by clarifying the either/or intent: 'Pass a file path or raw content.' It leaves open whether both may be supplied simultaneously or which takes precedence, but the core semantics of both parameters are conveyed.

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

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

States a specific verb and resource ('offline safety scan for a skill or prompt') and enumerates the scan dimensions (prompt injection, exfiltration, secrets, destructive commands, wildcard tools, loop hazards, clarity, token budget). This clearly separates it from siblings like skills.lint and skills.validateFormat, which handle formatting/lint concerns rather than safety scanning.

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?

'Blocking findings should be fixed before shipping' gives a clear usage context (pre-ship gate), and 'Local-only, zero AI cost' removes hesitation about running it. It does not, however, explicitly contrast itself with skills.lint/skills.validateFormat or state when NOT to use it, so it falls short of 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 provided, so description carries burden. 'Lint' implies read-only analysis, but this is not explicitly confirmed. No mention of authorization or other 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?

Single sentence with front-loaded verb and resource. Efficient but could be slightly more structured (e.g., list parameters).

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?

Minimal for a simple lint tool. No mention of output format, success/failure behavior, or differentiation from similar sibling tools like skills.validateFormat.

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?

0% schema description coverage; description does not explain 'path' or 'maxTokens' parameters beyond the tool's general purpose. Agent gains no extra meaning.

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

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

Clear verb 'Lint' with specific resource 'skill file' and explicit checks (front-matter, token count, broken links, TODO markers). 'Local-only' distinguishes from cloud-based sibling tools.

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 it operates on local skill files, implying not for cloud skills. Does not explicitly list alternatives or when to avoid, but the scope 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?

No annotations provided, so description carries full burden. It states the tool lists files from detected IDE directories but does not explain how detection works, whether listing is recursive, or what the output format is.

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?

Single sentence with no wasted words; essential information is front-loaded and easy to parse.

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 listing tool with one optional parameter, the description is mostly complete. Lacks details on return format and directory detection criteria, but sufficient for basic understanding.

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

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

Schema coverage is 100% with one parameter 'adapter' described as 'Optional adapter id to scope the listing.' The description adds no additional meaning beyond the schema, so baseline 3 applies.

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

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

Description clearly states the tool lists skill/rule files from detected IDE directories, using specific verb 'list' and resource 'skill/rule files', distinguishing it from sibling tools like skills.readLocal.

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

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

No guidance on when to use this tool vs alternatives such as cloud.listSkills or skills.readLocal. Missing context on preferred scenarios or prerequisites.

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

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

No annotations provided, so description carries burden. States it returns 'raw contents' and enforces path restriction, but does not disclose what happens on invalid path, file absence, or if return is text/binary.

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

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

Two sentences, zero wasted words. Front-loaded with action and constraint.

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

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

For a simple read tool with one parameter and no output schema, the description is adequate but lacks details on return type and error behavior, leaving some gaps.

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

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

Schema coverage is 0%, but description adds semantic constraint on the 'path' parameter (must be inside cwd), which is not present in schema. However, no further details on format or allowed values.

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

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

Description clearly states verb 'Read', resource 'local skill file', and adds constraint 'Path must be inside current working directory'. Distinguishes from sibling tools like skills.listLocal (listing) and skills.writeLocal (writing).

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?

Implies usage for reading raw contents of local skills, but no explicit guidance on when to use versus alternatives or prerequisites beyond the path constraint.

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, and it does disclose two useful behaviors: the approved body hash is stored and a status check (pass/warn/fail) runs at approval time. However it omits what happens if the status is fail/warn (does the approval still succeed?), required permissions, and reversibility.

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 with the action verb first and no wasted words. It is efficient, though it packs two clauses that could arguably be split for clarity.

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

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

For a mutation tool with zero annotation coverage, no output schema, and three undocumented parameters, the description is too thin. It leaves the agent without parameter semantics, permission requirements, or the outcome behavior on a failed/warn status.

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 carry parameter meaning, and it does not: 'path', 'notes', and 'reviewed_by' are never explained or mapped to the prose. The mention of a 'body hash' and 'status' does not correspond to any documented 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?

States a specific verb ('Approve') and resource ('a skill'), which cleanly distinguishes it from sibling review verbs like reviewReject and reviewRequest. It adds a concrete note about storing the body hash and running a status check, but never names the sibling alternatives to sharpen the contrast.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the alternative actions (reviewReject, reviewRequest, reviewGate). 'at approval time' hints at timing but does not tell the agent when this tool is the correct choice versus a sibling.

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, and it does disclose one genuinely non-obvious trait: the blocked=true semantics when a skill is unapproved. That is useful output/exit behavior an agent cannot infer from the schema. But it omits any statement of side effects, permissions, read-only nature, or what happens on the approved path.

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 a single tight sentence with the gating behavior front-loaded and no filler. The brevity is efficient, though it borders on under-specification rather than pure conciseness.

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

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

With no annotations, no output schema, and an undocumented required parameter, the definition is missing too much: what 'path' points at, what 'approved' means in this system, and what the tool returns beyond blocked=true. For a gating tool in a large review/pipeline toolset, this is inadequate.

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 'path' has 0% schema description coverage, so the description needs to compensate and does not. It never says whether path refers to a skill directory, a manifest file, or a repository root, leaving the one input ambiguous.

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 identifies a "CI gate" that emits blocked=true when a skill is not approved, so the resource and gating intent come through. However, it reads as a cryptic fragment rather than a clear verb+resource statement, and it never distinguishes this gate from review-adjacent siblings like skills.reviewStatus or skills.reviewApprove. An agent can guess the purpose but not confidently separate it from neighbors.

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 when-to-use, when-not-to-use, or alternative guidance. The mention of 'CI gate' implies automated pipeline usage, but nothing states when an agent should call this versus skills.reviewStatus or skills.flightCheck.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'reject' without disclosing whether the rejection is reversible, what state transition it triggers, whether it requires an in-review status, or what permissions are needed — significant gaps for a mutation 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 short sentence with no waste and the action front-loaded. However, it is under-specified rather than genuinely concise — the brevity comes at the cost of the behavioral and parameter detail an agent needs.

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?

A mutation tool with no annotations, no output schema, and 0% parameter description coverage should compensate with more context. Missing path format, side effects, state prerequisites, and the outcome of a successful rejection leave the definition incomplete.

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

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

Schema description coverage is 0% and the description explains only 'notes' (as reviewer notes). The required 'path' parameter is never clarified (file path vs. skill identifier vs. registry path), and 'reviewed_by' is not mentioned at all.

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 (Reject) and resource (a skill), and the sibling family (skills.reviewApprove, skills.reviewRequest, skills.reviewStatus) makes the action immediately legible as part of the review workflow. It does not explicitly name the approve sibling it is the inverse of, but the verb is unambiguous.

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

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

No when-to-use guidance, no exclusions, and no reference to alternatives such as skills.reviewApprove or skills.reviewRequest. The reviewer context is only inferable from the sibling names, not from the 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?

No annotations are provided, so the description carries the full behavioral burden. It states the resulting state ('pending_review') but omits permissions, side effects, reversibility, and any interaction with the review lifecycle.

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 front-loaded sentence with no filler; appropriately terse. It could be more informative, but it is not verbose.

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 state-changing tool with no annotations, no output schema, and an undocumented required parameter, the definition is far too sparse. It should explain the path argument and the review workflow 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%, and the description never mentions the required 'path' parameter or its expected format. With one required parameter and no schema explanation, the description fails to compensate.

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 ('Move') and resource ('skill') and target state ('pending_review'), so the core action is clear. It does not distinguish itself from siblings like skills.reviewApprove/reviewReject or explain what 'pending_review' entails, so it falls short of a 5.

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

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

No guidance on when to use this tool versus related review siblings (reviewStatus, reviewApprove, reviewReject, reviewGate). The action is implied but there are no prerequisites 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 behavioral burden. It does disclose the returned content (review_state, review_meta, check status, confidence trend), which is genuinely useful given there is no output schema, but it says nothing about permissions, whether it is purely read-only, or any side effects or rate limits.

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

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

A single tight sentence with no filler, and the returned-field enumeration is front-loaded. Nothing is wasted, though it is arguably too terse given the gaps in parameter and usage guidance.

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

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

With no output schema, listing the returned fields is a real contribution and covers the 'what comes back' question reasonably well. However, the required path argument is unexplained and there is no routing against the review-workflow siblings, leaving the definition only minimally adequate for a tool in a dense review toolset.

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 never mentions the single required 'path' parameter. It gives no format, relativity (repo-relative vs absolute), or example, so an agent gets no help on how to supply the identifier that the tool requires.

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 ('Show') and resource (review state of a skill), and enumerates the exact fields returned (review_state, review_meta, check status, confidence trend), which is highly descriptive. It does not explicitly distinguish itself from the review workflow siblings (reviewRequest/Approve/Reject/Gate), so it falls short of a 5.

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

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

There is no when-to-use guidance and no alternatives named. The read-only intent is only implied by the verb 'Show'; an agent must infer that this is the status-check counterpart to the review mutation siblings and that it needs the same path identifier they use.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the two behavioral traits that matter — the file is seeded with default scope constraints and lands in a 'draft review state' — but omits whether an existing file is overwritten, what permissions are required, and where on disk it is written.

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 with no filler; the created artifact and its state are stated up front. It is efficient, though it trades away some needed detail 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?

For a file-creating mutation with no annotations, no output schema, and half the parameters undocumented, the description is too thin. It should disclose overwrite behavior, required auth, and the on-disk effect, none of which appear.

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 50%: name and description are undocumented in the schema, and the description never explains any parameter. The phrase 'default scope constraints' loosely relates to the noScope flag and 'path relative to cwd' is never addressed, so the description fails to compensate for the coverage gap.

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

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

The description states a specific verb and resource ('Create a new SKILL.md') plus the resulting state ('default scope constraints and draft review state'). It is clear what gets produced, though it does not differentiate itself from siblings like skills.writeLocal or cloud.pullSkill that also create skill artifacts.

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 versus alternatives such as skills.writeLocal (writing an existing skill) or cloud.pullSkill (fetching a remote one). The description gives no prerequisites, conditions, or exclusions, leaving the agent to infer selection from the name alone.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses only that MODELBOUND_API_KEY is required (a genuine auth note). It says nothing about whether this is a read-only advisory call or whether suggestions are persisted, nothing about cost/latency, and nothing about the response shape, which matters given there is no output schema.

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

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

Two short sentences with the capability first and the prerequisite second; nothing is padded or repeated. It is efficient, though the terseness partly reflects omitted information rather than disciplined editing.

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

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

With no annotations, no output schema, and an undocumented required parameter, the description leaves the agent guessing about return values, side effects, and how to choose this over the optimization.* siblings. For a cloud/API-backed tool requiring credentials, more context is warranted.

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 the single skill_id parameter, so the description must compensate and does not. It never states the expected format of skill_id (local path vs. registry id vs. version-qualified id), which an agent would need to call this correctly.

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 gives a specific verb+resource ("suggest skill improvements") and even names the input sources (findings, tests, real-world outcomes), so the agent knows what the tool produces. It does not, however, distinguish this from nearby siblings such as optimization.run, optimization.preview, skill.benchmark, or skill.findings, which plausibly overlap 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?

There is no when-to-use guidance, no statement of when this is preferable to optimization.run or skill.findings, and no exclusions. The only conditional information is the API-key prerequisite, which is a precondition rather than usage 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?

With no annotations, the description must disclose behavior. It only says 'validate' without explaining what validation checks are performed, what side effects (if any) occur, or what constitutes success/failure.

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

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

The description is a single sentence, which is concise but lacks structure. It is not front-loaded with key information; every word is necessary but insufficient.

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

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

Given the low complexity (1 param, no output schema), the description is incomplete. It does not mention return values, standard details, or any error handling, leaving the agent guessing.

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

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

The single parameter 'path' has no description in the schema (0% coverage) and the tool description does not clarify its expected format (e.g., filesystem path, URL) or constraints.

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 validates a skill file against a specific standard, distinguishing it from sibling tools like skills.lint or skills.convert.

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 vs. alternatives such as skills.lint, which might perform similar validation. No context on prerequisites 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 provided. Description discloses parent directory creation and path constraint but omits overwrite behavior, permissions, or side effects of a write 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?

Two concise sentences with no redundancy. Every sentence adds value: what it does, directory creation, and path constraint.

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?

Moderately complete for a write tool with 2 params. Missing overwrite behavior, return value, and error conditions. No 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 has 0% description coverage. Description adds path constraint but does not explain contents format or other details. Baseline of 4 due to 0% coverage is not fully met.

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 writes a local skill file, creates parent directories, and enforces the path constraint. This differentiates it from sibling cloud and read/list tools.

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?

Implies use for writing local skill files but lacks explicit guidance on when to use vs alternatives or when not to use. The path constraint is mentioned but no comparative 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 full burden, and it does disclose the key trait that execution is against a live model (implying real cost/latency/non-determinism) plus the shape of what comes back. It omits auth requirements, rate limits, and any failure/timeout behavior.

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

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

Three sentences, zero filler, purpose stated first and the mode-selection rule immediately after. Every clause carries information an agent needs.

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

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

With no output schema, the description usefully names the return fields (adherence_score 1-10, verdict, latency_ms) and the live-model behavior. But for a 4-param, 0%-coverage tool with no annotations, the unexplained required skill_id and absent failure/cost semantics leave gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the relationship among test_case_id, prompt, and skill_md (mutually exclusive modes), but never addresses skill_id, which is the sole required parameter. Partial compensation only.

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 concrete verb+resource+"single" scope ("Run a single skill test case against the live model"), which implicitly separates it from plural/reporting siblings such as skill.testRuns and skill.testCases. It does not explicitly name an alternative, so sibling differentiation is inferred rather than stated.

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 routes between two invocation modes ("Pass test_case_id for a saved case or prompt + skill_md for an ad-hoc run"), which is real usage guidance for choosing inputs. However, it never says when to reach for this tool versus neighbors like eval.run, skill.benchmark, or skill.testRuns.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read operation but says nothing about permissions, pagination, ordering, or whether results are truncated, which matters for a list 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?

One short, front-loaded sentence with no filler. It is efficient, though the brevity is partly under-specification rather than discipline.

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?

No output schema and no annotations, so the description should cover the return shape and any filtering behavior, but it does neither. For a list tool with an undocumented parameter, this is thin.

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 the single required skill_id parameter. The description doesn't clarify what a skill identifier is, where it comes from, or its format, leaving the only parameter fully 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 (List) and resource (saved test cases) scoped to a skill, which is clear on its own. It doesn't distinguish itself from nearby siblings like eval.listCases or skill.testRuns, but the core purpose is unambiguous.

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

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

No guidance on when to use this versus alternatives such as eval.listCases, skill.testRuns, or skill.test. The agent must infer the routing from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the sort order (latest first) but says nothing about pagination, the meaning of the limit default, whether the result is truncated, or required permissions for a tool that clearly reads another skill's run history.

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 tight sentence with the key scope and ordering front-loaded. No wasted words, though it is arguably too brief given the undocumented parameters.

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 list tool with no output schema this is minimally viable, but with zero annotation and schema-description coverage the description leaves the limit parameter and return shape unexplained.

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 does not. It implies skill_id via 'for a skill' but never explains limit, its default of 20, or any bounds.

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 (List) and resource (recent test runs for a skill) plus the ordering (latest first). It is understandable on its own, but it does not explicitly distinguish itself from nearby siblings like skill.testCases, skill.benchmark, or skill.reliability.

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

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

No when-to-use, when-not-to-use, or alternative tools are mentioned. The agent must infer that this is the read-only way to view past runs versus skill.test which executes them.

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

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

With no annotations, the description carries the full behavioral burden. It does add one useful piece of context beyond the schema (the MODELBOUND_API_KEY requirement), but says nothing about reversibility, idempotency, failure modes, or what changes as a result of un-ignoring.

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

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

Two short sentences with the action front-loaded and no filler. Both sentences carry information, though the second is a bare prerequisite rather than substantive detail.

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

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

For a 5-parameter mutation tool with no annotations and no output schema, the description is too thin. An agent cannot tell how to identify the target finding, what happens on success, or how this pairs with ignoreFinding.

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% across 5 parameters, so the description needed to compensate and does not. It never explains what skill_id, finding_key, class, message, or severity do, or why the latter four exist for an un-ignore operation.

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 gives a specific verb+resource ('Un-ignore a previously ignored finding'), which immediately distinguishes it from the read-only finding tools. It doesn't explicitly name its natural counterpart, skill.ignoreFinding, so the sibling-routing is left implicit.

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 statement of when to use this versus skill.ignoreFinding, nor any precondition such as whether the finding must currently be in an ignored state. The only contextual note is an environment/auth requirement, not usage 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?

With no annotations, the description carries the full burden; it does disclose the shape of each entry (version label, sha, created_at, actor) and the backing store (file_versions), which is real value. It says nothing about ordering, pagination, or whether skill_id/file_id are mutually exclusive, so the behavioral picture is incomplete.

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

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

Two sentences, no filler: the purpose is front-loaded and the return contents follow immediately. Every clause earns its place.

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

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

Listing the returned fields partly compensates for the absence of an output schema, and no annotations exist to be missed. However, with zero schema description coverage, the description should at least resolve the skill_id/file_id choice and mention the limit default; that gap leaves the agent guessing.

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% across three parameters. The phrase 'a skill or file' implicitly maps to skill_id/file_id and hints they are alternatives, but the limit parameter (default 50) and the interaction between the two IDs are entirely undocumented in both schema and description.

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

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

The description gives a specific verb (List) and resource (historical versions of a skill or file), plus its underlying source (file_versions). An agent can distinguish it from mutation siblings like skill.test or skills.scaffold, though it never explicitly names a close sibling such as skill.compareVersions or skill.diff.

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 explicit when-to-use guidance and no exclusions. It is left to inference that this is the inspection/history tool versus skill.compareVersions or skill.diff, which are the obvious alternatives for version-related work.

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 but does disclose two behavioral facts: the direction of the sync and the API-key auth requirement. It stops short of conflict/overwrite behavior, idempotency, or whether an existing repo-linked skill is replaced.

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

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

Two sentences, zero waste, with the verb and direction front-loaded and the auth requirement appended. It is appropriately sized, though terse given how little structured data supports it.

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?

No annotations, no output schema, and 0% parameter coverage mean the description should do more. It names the return value and auth requirement but omits required-parameter semantics and conflict behavior, leaving an agent under-informed for a 5-param write 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% across 5 parameters, so the description must compensate. It loosely maps 'from the IDE' to source_ide and 'local skill file' to source_path, but leaves body_md, branch, and repo_url entirely unexplained, which is a significant gap for a mutation tool.

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

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

The description states a specific verb (sync), resource (local skill file), and direction (from IDE to cloud), plus the return (repo-linked skill UUID). This distinguishes it reasonably from siblings like cloud.pushSkill/cloud.pullSkill, though it never names an alternative explicitly.

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

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

It gives a prerequisite (MODELBOUND_API_KEY), which is useful context, but offers no when-to-use guidance or exclusions versus the many sibling sync/write tools (cloud.pushSkill, skills.writeLocal). Usage is only implied by the 'from IDE' framing.

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 but does disclose two useful traits: an auth prerequisite ('Requires MODELBOUND_API_KEY') and default scoping behavior ('Scopes skills to the current repo by default'). It omits whether the context persists, is per-session, or is idempotent – meaningful gaps for a state-setting 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?

Three short sentences, front-loaded with the purpose and followed by the default-scope and auth facts. Zero filler; every clause carries operational 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 context-setup tool with no output schema and no annotations, the description covers purpose, timing, auth, and default behavior – enough to invoke correctly. It could say more about persistence and whether callers must re-set context across sessions.

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 100%, so the schema already documents workspace_path, repo_full_name, and file_hints. The description adds no parameter-level meaning (e.g., default-scope override via file_hints) beyond what the schema provides, so baseline 3 applies.

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 ('Set workspace context') and names the operations it primes ('skill list/get/test/pipeline ops'). An agent can identify it as a setup step, though it doesn't name a sibling it conflicts with.

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 to call it 'before skill list/get/test/pipeline ops', giving clear timing context. It does not state when NOT to call it or what happens if it's skipped or already set, so it stops short of full guidance.

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