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

No annotations are provided, so the description carries the behavioral burden. It usefully discloses that results are sections with path and line numbers and instructs the agent to use citations and not paraphrase away constraints. However, it does not address read-only behavior, failure cases, or limitations such as missing documentation.

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 WHEN/HOW structure is compact and front-loaded, with the use condition appearing first. The single sentence is information-dense and every clause carries meaning, though a bit more structure around depth and sdkVersion would improve 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?

There is no output schema and no annotations, so the description must cover both behavior and return shape. It partially does this by mentioning sections with path and line numbers, but it omits depth semantics, sdkVersion impact, and any caveats about citation availability.

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 67%, and the description adds no parameter-specific meaning. It does not explain how depth changes the response or how sdkVersion affects the explanation, leaving the agent to infer from enum values and a minimal schema description.

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

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

States a specific verb ('explain') and resource ('Udon/VRChat topic') and distinguishes itself by promising a 'cited explanation'. This makes it easy to separate from sibling tools like search_documentation or search_reference.

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 'WHEN:' clause gives a clear condition for use: the user needs a cited explanation of a Udon/VRChat topic. It does not explicitly name alternatives or exclusion cases, so it stops short of a 5, but the intended usage 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 are provided, so the description carries the full behavioral burden. It clearly frames the tool as an explanatory step in a loop, indicates that it surfaces cited rules/docs, and warns against guessing fixes, implying it is read-oriented rather than a mutating fixer. It does not describe the exact return format or side-effect profile, but for a one-parameter explainer that is a minor gap.

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

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

The description is compact, front-loaded with WHEN/HOW, and every sentence contributes actionable guidance. It avoids redundancy and clearly sequences the call within the broader fix loop.

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

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

For a simple one-parameter tool in a clear workflow, the description covers when to call it, how often, what to do with the output, and what to do next. It does not describe the output schema or edge cases, but the absence of an output schema and the low complexity make this acceptable.

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 the schema already documents ruleId well. The description reinforces the key semantics—'once per unique ruleId from the result'—but adds little beyond what the schema description already says. This meets the baseline but does not exceed it.

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 the context (validate_code returned issues) and the resource (unique ruleId), and the name 'explain_validation' makes the core function clear. It does not explicitly state 'returns an explanation of the rule/docs for a validation issue,' but the workflow makes that inferable. It distinguishes itself from validate_code and generic search tools by tying it to the fix loop.

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 an explicit WHEN ('validate_code returned issues') and HOW (call once per unique ruleId, read cited rule/docs, apply fix, re-run validate_code). It also says not to guess fixes, which is an implicit exclusion. It does not explicitly compare against sibling tools like read_rule or explain_topic, so it stops short of a perfect 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 behavioral disclosure burden. It discloses that the returned value is a base template, not final code, and that networking must not be invented. This is meaningful context for an agent deciding how much to trust or extend the output. It does not discuss side effects, but the get_ prefix and template-retrieval nature make that low-risk.

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

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

The description is extremely compact and front-loaded: WHEN, HOW, constraint, and next step in three short clauses. Every phrase earns its place, and the structure makes the intended workflow immediately clear.

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

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

For a single-parameter, no-output-schema tool, the description is nearly complete: it states when to use it, what to do with the result, a critical constraint, and the follow-up action. It does not mention where to find a valid templateId (e.g., list_templates), but the schema covers the parameter adequately.

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 the schema already documents templateId. The parameter description adds 'filename' as a synonym and repeats the workflow guidance, but it does not meaningfully clarify what values are valid or how to obtain them. This is a baseline-3 case where the schema carries the load.

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 conveys a specific purpose: fetch a template to use as the base for UdonSharp code before writing it. It clearly frames the tool as a source-template provider and even ties it to the next step, validate_code. It does not explicitly differentiate from list_templates or search_documentation, but the 'returned source as BASE' language gives enough specificity.

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

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

The description gives explicit WHEN ('before writing UdonSharp') and HOW ('use the returned source as the BASE — adapt fields/logic') guidance. It also instructs what not to do (invent networking) and what to do next (call validate_code). It stops short of naming alternatives or stating when not to use this tool, so it is not a full 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 provided, the description carries the full burden of behavioral disclosure, but it remains terse. It does not state whether the operation is read-only, what the return payload looks like (e.g., full rule objects vs. references), or any side effects. The 'HOW' clause hints that the list yields items needing follow-up reads, but this is implicit rather than explicit. For a tool lacking any annotation coverage, this is a significant gap.

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

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

The description is extremely concise, using a WHEN/HOW structure that immediately conveys the intended trigger and follow-up action. Every word serves a purpose: the WHEN clause sets the invocation condition, and the HOW clause routes to complementary tools. No filler or redundancy 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 simple listing tool with one optional parameter and no output schema, the description covers the high-level purpose and workflow. However, it omits the shape of the returned data (e.g., whether it returns rule IDs, names, or full contents) and any pagination or ordering behavior. Given the HOW hint, an agent can infer that the output is a collection of rule references, but this inference is not explicit and leaves room for misinterpretation.

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%, as the only parameter (skillId) already carries a description ('Filter rules by skill'). The tool description adds no additional meaning or constraints beyond the schema, so it does not enhance the parameter semantics. Per the rubric, a baseline of 3 applies when the schema fully covers parameter meaning.

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

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

The description explicitly states the verb 'list' and resource 'UdonSharp rules', making the tool's purpose unambiguous. It further clarifies the timing ('before coding') and implicitly distinguishes from read_rule by framing it as a precursor to reading individual rules. The resource is specific enough to separate it from sibling list tools like list_skills and list_templates.

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 a clear WHEN condition ('when you need the set of UdonSharp rules before coding') and a directed HOW workflow ('list then read_rule for any rule that applies'). This gives concrete guidance on when to invoke the tool and how to proceed, though it does not explicitly mention alternatives or when not to use it. The workflow implication is strong enough to be considered clear 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 provided, the description carries the burden of disclosing behavioral traits. It implies a read-only listing operation but does not explicitly state that it has no side effects, what exactly is returned, or any ordering or scope limitations. For a list tool this is a meaningful omission.

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 just two short sentences, both highly informative. It front-loads WHEN and HOW, contains no filler, and every word earns its place. This is an excellent model of concise, scannable tool documentation.

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, parameterless list tool, the description covers the essential use case and even connects to the follow-up tool (read_skill). However, because there is no output schema, a brief note on what the returned list actually contains (e.g., skill names, descriptions) would have made it fully complete.

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

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

The tool has zero parameters, and the schema description coverage is 100% by default. The baseline for a zero-parameter tool is 4, and there are no parameter details needed. The description adds no parameter info, but none is required.

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 ('list') and resource ('skills from the repo'), and clearly distinguishes itself from 'read_skill' by noting it is done 'before reading one.' This makes the tool's purpose unmistakable even among many siblings.

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

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

The description explicitly provides a WHEN condition ('starting an Udon session or discovering available skills') and a HOW sequence ('before reading one with read_skill'). This is direct usage guidance that tells an agent exactly when to invoke this tool and how it fits into a workflow.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. 'List .cs templates' conveys the read-only listing behavior, but it does not describe what information is returned, whether the skillId filter affects results, or any ordering/format details. This is adequate but not richly transparent.

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

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

The description is compact and information-dense, with the WHEN condition and HOW workflow front-loaded. Every phrase earns its place, and there is no redundant framing or 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 simple list tool with one optional parameter and no output schema, the workflow context is useful and mostly sufficient. It lacks an explicit statement about return contents or the optional filter, but the intended use and follow-up action are clear.

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

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

The schema already documents skillId with 'Filter templates by skill' at 100% coverage. The description does not mention the parameter or add extra meaning, so the baseline score of 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 uses specific language: 'list .cs templates' and positions it as the first step in a template→validate→fix workflow. This clearly distinguishes it from sibling get_template, which retrieves a specific template rather than listing available ones.

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

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

The description gives explicit when-to-use context ('about to write UdonSharp') and a concrete workflow ('then get_template for the closest match and adapt it'). It does not discuss when not to use the tool or compare it to other siblings, but the context is clear enough for an agent to select it appropriately.

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

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

With no annotations provided, the description must disclose behavior, but it only offers usage guidance. It does not state that the tool is read-only, what it returns, or any error handling. The instruction 'do not skip constraints' is ambiguous about tool behavior versus agent behavior.

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

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

The description is extremely concise, using a WHEN/HOW structure that front-loads the key context. Every word earns its place, though it could be slightly expanded 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 simple read tool with one parameter, the description covers when and how to use it, but does not explicitly state what is returned (e.g., the rule content) or behavior on missing rules. Since there is no output schema, this is a gap.

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

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

The schema covers the single parameter ruleId with a description. The tool description adds no additional meaning about the parameter, so it sits at the baseline 3 for 100% schema coverage.

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

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

The description does not explicitly state 'reads a rule' but implies it via 'WHEN: implementing something covered by a named rule.' It does not directly name the action or resource, and the sibling tools like read_skill and list_rules are not differentiated. The purpose 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 gives a clear condition for use ('implementing something covered by a named rule') and instructions on how to apply the rule ('apply purpose/constraints/examples; do not skip constraints'). It does not mention alternatives, but the WHEN clause effectively guides selection.

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

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

No annotations are provided, so the description carries the full disclosure burden. The description does clarify what the tool returns conceptually ('rules, refs, templates') and implies a read-only operation, but it does not explicitly state that no state is modified, nor describe failure or edge-case behavior. This is adequate for a simple read tool but not rich.

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

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

Two compact sentences, each earning its place: the first states the trigger condition, the second gives the required call sequence and a follow-up instruction. The WHEN/HOW formatting makes the guidance scannable and front-loaded.

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

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

For a low-complexity tool with one well-documented parameter and no output schema, the description gives the essential context: what data is returned, when to use it, and how to sequence it after list_skills. It is missing only explicit 'use read_rule instead' guidance to be fully complete.

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

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

The schema has 100% description coverage for the single parameter skillId, including an example value. The tool description adds no additional parameter semantics beyond what the schema already documents, so the baseline of 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 uses a specific verb ('read') and a clear resource ('full skill contract') and enumerates its contents: rules, refs, templates. This distinguishes it from sibling tools like list_skills, which lists skills, and read_rule, which reads a single rule. An agent can tell exactly what this tool is for.

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 the tool ('WHEN: you need the full skill contract') and how to sequence it ('call after list_skills'). However, it does not explicitly state when not to use it or name alternatives such as read_rule for fetching a single rule, so it stops short of full exclusion guidance.

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

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

No annotations are provided, so the description carries full burden. It fails to explain how the target SDK version is determined since the input schema has zero parameters. This creates ambiguity about how the tool selects a version. It also doesn't disclose the return format or any side effects (though read-only is implied). The lack of clarification on the version mechanism is a significant behavioral transparency gap.

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

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

The description is concise, using a WHEN/HOW structure that front-loads the key information. Every sentence earns its place, and there is no fluff. It's appropriately sized for a tool with no parameters, though it could be slightly more explanatory without losing brevity.

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-param tool with no output schema and no annotations, the description must fully explain how it works. It leaves the target SDK version mechanism unexplained, making it incomplete for an agent to call correctly. The description hints at usage but doesn't clarify what the tool returns or how the version is specified, so agent adoption would be hindered.

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

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

The tool has zero parameters and schema coverage is 100% (empty), so baseline is 4. However, the description introduces an implicit 'target SDK version' concept without explaining how it's supplied, conflicting with the empty schema. This mismatch reduces the usefulness of the description for parameter understanding, so a 3 is 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?

The description states a clear purpose: checking which APIs exist for a target SDK version. It uses a specific verb ('checking') and resource (API matrix), and the WHEN clause provides context. However, it doesn't explicitly distinguish itself from sibling tools like search_sdk_feature, though the 'read the matrix' phrasing implies a lookup rather than a search.

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 explicit WHEN and HOW guidance: use it when checking API existence and read it before using version-specific features. This gives clear context for when to invoke it, but it doesn't mention alternatives or exclusions. The guidance is actionable and sufficient for most cases.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says to 'check' anti-patterns but does not state what the tool returns, whether it is a read-only search, or how results are structured. This is a significant gap for an unannotated 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 roughly 30 words and every phrase adds actionable guidance. The WHEN/HOW structure front-loads the most important usage information and avoids filler or repetition.

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

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

For a simple two-parameter search tool, the description gives enough context to know when to call it, but it omits what a successful result looks like and how to interpret the returned anti-patterns. With no output schema and no annotations, this leaves the agent partly guessing about return semantics.

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 describes the query parameter as an 'Anti-pattern to check BEFORE using unfamiliar C# patterns in UdonSharp,' and the description reinforces that context. However, the description adds nothing about the limit parameter, and schema coverage is only 50%, so parameter meaning is only partially expanded.

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

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

The description clearly identifies the resource ('anti-patterns') and the action ('check'), and adds concrete trigger context: 'BEFORE using unfamiliar C# patterns' and 'when validate_code fails with a common mistake'. It is distinguishable from siblings like search_documentation by focusing on anti-pattern avoidance, though it never explicitly says it searches a repository of anti-patterns.

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 WHEN clause explicitly names two situations to use this tool: before using unfamiliar C# patterns and when validate_code fails with a common mistake. The HOW clause adds that the agent should 'prefer documented alternatives,' which helps route away from anti-patterns afterward, though it does not explicitly compare against sibling tools.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says to apply recommended patterns from the repo, without describing whether this is a read-only search, what output format is returned, whether results are ranked, or what happens when no matches are found.

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

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

The description is compact, front-loaded with the WHEN condition before HOW, and contains no filler or repetition. Every phrase contributes either a usage trigger or an implementation step.

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

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

For a tool with no output schema, the description should explain what the search returns or how results should be consumed, but it only gives workflow guidance. An agent can determine when to invoke it, but not what to expect back or how to interpret the response.

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 50%, and the tool description adds no meaning for query or limit. The reference to 'structure, performance, or idiomatic UdonSharp' hints at what query topics may be useful, but it does not explain query syntax, result count behavior, or the limit parameter's role.

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 ties the tool to refining structure, performance, and idiomatic UdonSharp, which conveys a specific search purpose beyond the bare name. It does not explicitly state what the tool 'searches' or what resource it queries, so it stops short of fully distinguishing itself from siblings like search_reference or search_antipattern.

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 WHEN clause gives concrete triggering conditions: refining structure, performance, or idiomatic UdonSharp. The HOW clause adds workflow context by saying it applies patterns after drafting from a template, but it does not name alternatives or state when not to use the tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It conveys that the tool is a pre-flight constraint check and warns about the consequence of skipping it, but it does not describe the return format, whether the operation is read-only, or what a successful check looks like.

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

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

The description is compact, front-loaded with the critical WHEN instruction, and every sentence adds value: when to use it, how to use it, and why it matters. There is no redundant or filler content.

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

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

The description is adequate for selecting and invoking the tool with the required query parameter, and the schema covers the optional limit. It does not describe the output format, but for a constraint-search tool the key contextual information about when and why to use it 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?

The query parameter is clearly explained with examples (List<T>, Coroutine, LINQ), and the tool description reinforces what kinds of values to search for. The limit parameter is not described in prose, but its schema provides default, minimum, and maximum, so the agent still has enough information to use it.

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 that the tool checks constraints before using any C# feature in UdonSharp, with concrete examples like List<T>, Coroutine, and LINQ. This makes the tool's purpose specific and distinct from siblings that cover general documentation, topics, rules, or examples.

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 an explicit 'WHEN' instruction: use it before any C# feature in UdonSharp, and warns that skipping it causes invalid Udon. It does not explicitly name alternative tools or state when not to use it, so it falls slightly short of full routing guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses the search mechanism (keyword/fuzzy) and the repository scope, but does not mention behavior like result ranking, pagination, or what happens with no results. It is not misleading, but it is thin on behavioral detail beyond the search mode.

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, each earning its place: the first gives the trigger condition, the second the mechanism and scope, the third the alternative to avoid. Front-loaded with the most important usage signal. No wasted words.

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

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

For a search tool with 3 parameters and no output schema, the description covers the core usage context well: when to use, what it searches, and how it behaves. It lacks detail on result format and limit semantics, but the schema covers the limit parameter's range and default, so the description is reasonably complete for an agent to invoke it correctly.

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

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

Schema description coverage is 67%: 'query' and 'sdkVersion' have descriptions, but 'limit' has none. The description adds context that the search is keyword/fuzzy and scoped to Udon/VRChat docs, which helps interpret the query parameter, but it does not add detail for 'limit' or 'sdkVersion' beyond the schema. Baseline 3 is 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?

The description states a specific verb ('search'), a resource ('indexed agent-skills repo'), and a clear scope ('Udon/VRChat docs question'). It also distinguishes itself from siblings by naming the domain it covers and explicitly warning against inventing APIs from general C# knowledge.

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

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

The description explicitly says WHEN to use it ('before answering any Udon/VRChat docs question') and HOW ('keyword/fuzzy search the indexed agent-skills repo'). It also provides a clear exclusion: prefer this over inventing APIs from general C# knowledge. This is strong 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 carry the behavioral burden, and it does add useful context: examples returned should be adapted, not invented from, and validation should follow. However, it does not describe result format, pagination, or behavior when no matches are found, which are moderate gaps for a search 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 compact and front-loaded with WHEN, HOW, and next-step directives. Every sentence contributes actionable workflow guidance without filler or repetition.

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

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

For a simple two-parameter search tool, the description covers when to call it, how to use the results, and what to do next. It is slightly thin on limit semantics and explicit sibling alternatives, but the essential 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?

The query parameter is already described in the schema, and the description reinforces the intended usage without adding new parameter-level detail. The limit parameter has type, default, and range in the schema but no semantic explanation here, leaving a modest gap at 50% schema description coverage.

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

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

The description identifies the tool as a source of UdonSharp examples to use as a code base, which distinguishes it from documentation, template, and rule tools. It is clear about the resource and intended use, though it never literally states 'searches for examples' outside the schema.

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

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

The description explicitly says WHEN to use it ('before writing UdonSharp'), recommends pairing it with get_template, and specifies the follow-up action validate_code. It provides a clear workflow context, though it does not explicitly name sibling tools to avoid or describe when not to use 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 are provided, so the description must carry the full behavioral burden. It hints at content source ('docs/templates') and preferred patterns, but it does not disclose return format, ordering, pagination limits, side effects, or failure behavior. For a search tool, the agent is left guessing what the response contains.

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 with clear WHEN/HOW labels, no filler, and the most actionable condition is front-loaded. The abbreviation 'Manual + RequestSerialization' is slightly cryptic without context, but overall the structure is efficient and scannable.

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

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

There is no output schema, no annotations, and 18 sibling tools, many overlapping as search utilities (search_documentation, search_constraints, search_examples). The description explains when to call it but not what results to expect or what distinguishes this search from siblings. This is insufficient for reliable tool selection and invocation.

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

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

Schema description coverage is 50%, with only 'query' having a description ('Networking topic to search'). The tool description adds no additional meaning to either parameter: it doesn't explain query syntax, what makes a good query, or what 'limit' affects. The description neither compensates for the undocumented 'limit' nor enriches the documented 'query', so baseline 3 is 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?

The description gives clear scope (networking topics, ownership, sync mode, late joiners, serialization, RPC) and instructs to search and prefer Manual + RequestSerialization patterns. However, it never states a direct verb+resource definition like 'Searches networking documentation and returns relevant results.' The verb 'search' only appears in a workflow instruction, so the core purpose is inferred from the name and context 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?

Explicitly provides trigger conditions: 'WHEN: any ownership, sync mode, late joiners, serialization, or RPC work' and a workflow rule 'search before writing synced fields.' This is strong guidance, but it does not explicitly mention when not to use it or name sibling tools as alternatives, so it falls short of the full 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 provided, the description carries the full burden of behavioral disclosure. It only states that the tool searches reference docs, but does not mention whether it is read-only, what it searches (file names, content, metadata), what the return format is, or how failures/empty results are handled. The 'search before inventing' hint implies a read-only lookup but is not explicit.

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

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

The description is extremely concise and well-structured, using a WHEN/HOW format that front-loads the most important context. Every word earns its place, and there is no 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?

The description gives adequate context for deciding when to invoke the tool, but lacks important operational details. It does not explain the meaning or behavior of 'limit' and 'skillId', nor does it describe the output. Given the tool's relative simplicity, this is a noticeable but not critical gap for an agent trying 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 only 33% (only 'query' has a description). The tool description adds some context for query by suggesting it can contain method names or event signatures, but it says nothing about 'limit' or 'skillId'. For a tool with low schema coverage, the description was expected to compensate and did not.

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

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

The description clearly states the tool's purpose: looking up API/reference docs in the references/ directory, with a specific directive to 'search before inventing method names or event signatures.' This is a specific verb+resource combination that distinguishes it from broader documentation tools like search_documentation, though it does not name the sibling explicitly.

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

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

The 'WHEN' clause gives a clear condition for use (looking up API/reference docs in references/), and the 'HOW' clause provides specific guidance: search before inventing method names or event signatures. This gives an agent actionable context, though it stops short of explicitly contrasting with sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys intent as a search operation but says nothing about what results look like, how matching works, whether sdkVersion changes behavior, or any limitations. The read-only nature lowers risk, but transparency is thin.

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

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

The description is compact, front-loaded with the trigger, and uses a clear WHEN/HOW structure. Every clause earns its place and the inline examples improve scannability without adding fluff.

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

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

The WHEN/HOW framing and feature examples are enough to start using a simple search tool, but there is no information about result shapes, sdkVersion usage, or how this differs from the many sibling search tools. It is minimally adequate with notable 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 only 33%, with query described and limit/sdkVersion effectively undocumented. The description adds feature examples but does not explain the meaning or effect of limit or sdkVersion, so it fails to compensate for the schema's gaps.

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 makes clear this is a search tool aimed at SDK features, with concrete examples like NetworkCallable and PlayerData. It does not state the action in a plain declarative sentence and does not explicitly contrast sibling tools, but the resource and verb are inferable.

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 WHEN clause gives a crisp trigger—use it when unsure whether a feature exists or how it works—and the HOW clause directs the agent to search before coding. It lacks explicit when-not-to-use guidance or named alternatives among the many sibling search tools, but the context is clear enough.

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

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

With no annotations, the description carries full responsibility for disclosing behavior. It mentions that validation can produce issues with 'unique ruleId' and mandates a re-run loop, but it does not explicitly state whether the tool is read-only, what a successful response looks like, or whether it modifies anything. It offers workflow context but lacks a clear statement of output and side effects.

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 highly concise, using a structured 'WHEN/HOW/If' format that front-loads the critical mandatory usage condition. Every sentence carries functional weight, including the failure-handling workflow and the final policy statement. There is no redundant fluff, making it easy for an agent to parse and act on.

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

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

The description covers the main workflow and mandates usage after edits, but it omits explanation of the 'sdkVersion' parameter entirely and does not describe the tool's return format or success criteria beyond 'valid'. Given no output schema and no annotations, this leaves an agent uncertain about what response to expect, especially for optional parameters.

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 50%, meaning only the 'code' parameter is described in the schema, and that description is detailed ('Full UdonSharp C# to validate AFTER writing/editing...'). However, the tool description itself does not add semantics for the 'sdkVersion' parameter, which is left undocumented in both schema and description. The description merely repeats 'pass full code' without clarifying the optional SDK version parameter or its purpose.

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 tool name 'validate_code' clearly indicates the action of validating code, and the description reinforces this with 'WHEN: after writing or editing any UdonSharp script (mandatory)'. However, it does not explicitly distinguish itself from sibling tools like explain_validation or list_rules, leaving the exact validation scope implied 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 provides explicit usage guidance with 'WHEN: after writing or editing any UdonSharp script (mandatory)', making the trigger condition clear. It also gives a precise workflow: on issues, call explain_validation, fix, and re-run validate_code until valid, and ends with a strong directive 'Never ship code that failed validation.' This fully addresses when and how to use the tool relative to its follow-up sibling.

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