API Acre

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is established. The description adds meaningful behavioral detail: it normalizes, checksums, and identifies the zero address, which goes beyond the bare annotation. It stops short of explaining output format or edge cases, but with an output schema present, this is acceptable.

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, well-structured sentence that front-loads the action and resource. It has no waste and every word contributes to meaning.

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

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

For a simple read-only tool with one parameter and an output schema, the description is fairly complete. It covers validation, normalization, checksumming, and the zero-address edge case. It doesn't mention error conditions or return values, but the output schema likely fills that gap. Given the tool's simplicity, this is solid.

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 carries the burden. It provides domain context ('Ethereum or EVM wallet address') for the 'address' parameter, which is helpful. However, it lacks specifics about accepted formats (e.g., hex, checksummed, mixed case) or what 'normalize' entails. The description partially compensates but leaves room for ambiguity.

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

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

The description clearly states the tool's function with specific verbs: 'Validate, normalize, and checksum' and identifies the exact resource ('Ethereum or EVM wallet address'). It also adds a distinct behavior ('identify the zero address') that differentiates it from sibling tools like crypto.calldata-decode and crypto.typed-data-hash.

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

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

The description implies a clear use case: anyone needing address validation or normalization for Ethereum/EVM addresses. It does not explicitly mention when not to use it or name alternatives, but the domain-specific wording makes the intended context unambiguous. Given the sibling tools are clearly different operations, this is sufficient.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context, such as input format requirements (e.g., hex-encoded calldata) or error handling behavior, beyond what the annotations provide.

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

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

The description is a single sentence, front-loaded with the verb 'Decode,' and contains no filler or repetition. Every word contributes meaning.

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

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

The tool is simple, has an output schema, and safety annotations are present, but the description fails to compensate for 0% schema coverage regarding input formats (e.g., whether calldata must be hex with 0x prefix). It is minimally viable but leaves meaningful usage 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%, and the description only clarifies the function_signature parameter ('supplied Solidity function signature') while leaving calldata format undefined. The parameter names and the example in the schema help, but the description does not fully compensate for the missing property descriptions.

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

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

The description uses a specific verb and resource: 'Decode Ethereum or EVM ABI calldata arguments using a supplied Solidity function signature.' This clearly distinguishes it from sibling tools like crypto.address-inspect and crypto.typed-data-hash.

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 given on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only states the operation, leaving usage to be inferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that the tool validates data and derives specific values, but does not disclose any additional side effects, auth requirements, or error behavior. This is adequate but not rich.

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

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

The description is one concise sentence with no redundant words. It front-loads the primary action and then lists the derived outputs, making it easy to parse and understand.

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?

While the output schema exists to describe return values, the tool's complexity (EIP-712 standard) demands more detail about the input structure and validation behavior. The description covers the purpose and outputs but is minimal for a complex tool with no parameter documentation.

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% with the only parameter (typed_data) being a free-form object. The description identifies it as EIP-712 typed structured data but fails to explain the required internal structure (e.g., types, primaryType, domain, message), which is critical for correct invocation. It provides some context but insufficient guidance.

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 action verbs ('Validate', 'derive') and identifies the exact resource (EIP-712 typed structured data) along with the outputs (domain separator, message hash, signing digest). This clearly distinguishes it from sibling tools like crypto.address-inspect and crypto.calldata-decode.

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 clearly implies when to use the tool (for handling EIP-712 typed data) and the context is distinct from siblings. However, it lacks explicit exclusions or named alternatives, so it does not fully meet the 'explicit when/when-not' criterion.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds context by specifying the exact cleaning operations performed (key normalization, whitespace trimming, empty value standardization), which helps the agent predict the output transformation. It does not mention edge cases or return structure, but the output schema covers that.

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, well-structured sentence that front-loads the primary action and resource, followed by specific operations. Every word earns its place; there is no fluff or redundancy.

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, combined with the schema and annotations, covers the essential usage. It specifies the supported formats, the core transformations, and the safety profile. Minor gaps exist—such as not explicitly stating that 'content' is the input record string—but the output schema and parameter names fill those 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 carries the burden. It maps the boolean parameters to actions: 'normalizing keys' aligns with normalize_headers, 'trimming whitespace' with trim_strings, and 'standardizing empty values' with empty_to_null. While format and content are self-explanatory from the schema, the description adds meaning to otherwise undocumented parameters.

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

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

The description uses a specific verb ('Clean') and identifies the resource ('CSV, JSON, or YAML records') along with concrete actions (normalizing keys, trimming whitespace, standardizing empty values). This clearly distinguishes it from sibling tools like data.convert or data.deduplicate, which serve different purposes.

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

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

The description implies usage for data cleaning but does not explicitly state when to choose this tool over alternatives such as data.convert or data.deduplicate. There are no exclusions or comparisons, so the guidance is only implicit.

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

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

Annotations already cover readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is established. The description adds 'machine-readable response' to indicate structured output, but provides no further behavioral details such as error handling, validation, or size limits. This is adequate but not rich.

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

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

A single sentence that is front-loaded with the verb 'convert' and specifies the exact formats. Every word earns its place; there is no 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?

The tool is simple and has an output schema and comprehensive annotations. The description covers the core purpose and behavior. It does not mention edge cases or limits (e.g., max content length), but these are minor for a conversion tool, and the output schema handles return expectations.

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 0% description coverage, but the description 'Convert structured data between CSV, JSON, and YAML formats' implies that 'content' is the data, 'format' is the source format, and 'target_format' is the destination. Combined with the enums, this gives enough meaning to all three parameters, compensating for the missing schema descriptions.

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

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

The description uses the specific verb 'convert' and clearly states the resource: structured data between CSV, JSON, and YAML formats. This immediately distinguishes it from sibling data.* tools like data.clean or data.deduplicate, which serve different purposes.

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 intended usage is clear: converting data between three named formats. No explicit when-not or alternative is given, but sibling tools are unrelated (cleaning, profiling, etc.), so the use case is unambiguous. It lacks an explicit exclusion statement, keeping it from 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?

Annotations already mark the tool as read-only, idempotent, and non-destructive, and the description does not contradict them. It adds useful details about the identity-field-based removal and the reporting of the removed count, which is beyond the annotations. It could mention first/last behavior, but that is a schema detail.

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, information-dense sentence with no filler. Every phrase adds meaning: the action, supported formats, matching mechanism, and output metric.

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 core purpose, input formats, identity-field selection, and output count while annotations cover safety. An output schema exists, reducing the need to describe return values. The only notable omission is the keep parameter, but overall the description is adequate for a moderately complex dedup tool.

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

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

With 0% schema description coverage, the description must explain parameters itself. It covers content ('records'), format ('CSV, JSON, or YAML'), and keys ('selected identity fields'), but it omits the 'keep' parameter entirely. Since keep controls whether the first or last duplicate is retained, this is a significant undocumented 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?

The description opens with the specific verb 'Remove duplicate' and identifies the resource ('CSV, JSON, or YAML records') and the mechanism ('using selected identity fields'). It clearly distinguishes this from sibling data tools like data.clean or data.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?

The description implies when to use the tool (when deduplicating structured CSV/JSON/YAML data) and mentions the identity-field customization option. It does not explicitly name alternatives or state when not to use it, but the context 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the read-only nature is covered. The description adds useful behavioral context by listing what profiling reveals (field types, nulls, uniqueness, samples), going beyond the annotation and making the tool's analysis behavior concrete.

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

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

A single front-loaded sentence states the verb, target data formats, and the analysis outputs with no filler. Every word contributes to understanding the tool's purpose.

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 presence of an output schema, strong annotations, and only two simple parameters, the description is sufficiently complete. It covers what the tool accepts and what analysis it performs; return structure is left to the output schema, which is 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 description coverage is 0%, so the description must compensate. It adds the idea that 'content' holds serialized records in one of the three formats, but it does not explain expected JSON structure (e.g., array vs JSONL), CSV header handling, size limits, or how content and format interact beyond the enum.

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

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

The description uses the specific verb 'Profile' and names supported formats (CSV, JSON, YAML) along with concrete analysis dimensions (field types, nulls, uniqueness, samples). This clearly distinguishes it from sibling tools like data.schema or data.clean.

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

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

The description implies when to use the tool—when profiling structured records—but it never explicitly states alternatives, exclusions, or prerequisites. It does not mention when to prefer data.schema or data.clean, leaving the decision partially implicit.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, establishing a safe, non-destructive operation. The description adds behavioral context about the output including nullable fields and primitive types, which provides detail beyond the annotations. It does not contradict any annotation, and the added info enhances transparency.

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

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

The description is a single sentence that is front-loaded with the action verb 'Infer' and efficiently conveys the core purpose. It avoids fluff and every phrase contributes meaning.

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

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

Given the tool's relative simplicity (2 parameters, an output schema, and clear annotations), the description covers the essential purpose and output characteristics. It could mention limitations (e.g., empty records, size handling) but is sufficiently complete for typical usage, especially with the output schema specifying the return structure.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. However, it only indirectly references 'format' by naming CSV, JSON, and YAML, and never explains what 'content' should contain, its expected structure, or size constraints. The added value beyond the schema's enum and type fields is minimal.

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 a specific action ('Infer a JSON Schema') and resource ('from CSV, JSON, or YAML records'), with unique details (nullable fields, observed primitive types). This distinguishes it from sibling tools like data.profile and data.convert, which handle profiling and conversion respectively.

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

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

The description implies when to use the tool (when you need a schema from structured data) but provides no explicit guidance on when not to use it or which alternatives to prefer. It does not mention sibling tools like data.profile for statistical summaries or data.convert for changing formats, so the usage context is clear but not fully contrasted.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds beyond that: the output is deterministic, privacy scrubbing occurs, and field-level evidence hashes are generated. These are non-obvious behavioral traits valuable to an agent, though it does not clarify what 'privacy scrubbing' entails.

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 entire description is a single, information-dense sentence. It front-loads the core purpose (Normalize) and packs in output types and key features without fluff or redundant phrasing. Every phrase adds value.

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

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

The tool has three parameters with no schema descriptions and no parameter-level guidance in the description. While an output schema exists and annotations cover safety, the description lacks usage context (when to choose this over data.convert or research.feed-normalize) and parameter semantics. It is a solid summary but incomplete for a tool with 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?

Schema description coverage is 0%, and the description does not mention the parameters base_url or include_types. The only implicit hint is 'caller-supplied inline Schema.org JSON-LD' mapping to the html parameter. With three parameters, the description fails to compensate for the lack of schema descriptions, leaving the agent to guess the meaning and usage of base_url (e.g., URL resolution) and include_types (entity filtering).

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

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

The description starts with a specific verb 'Normalize' and identifies the resource as 'caller-supplied inline Schema.org JSON-LD'. It lists the exact output entity types (Organization, Product, Service, Article, Event) and adds distinctive features ('deterministic', 'privacy scrubbing', 'field-level evidence hashes'), clearly separating it from sibling tools like data.clean or data.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?

The description implies usage: use this tool when you have inline Schema.org JSON-LD to normalize into specific entity types. However, it provides no explicit when-not-to-use guidance or mentions of alternative tools, leaving the agent to infer the context from the tool name and sibling list.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering safety. The description adds value by listing specific metric categories but does not disclose behavior for unsupported languages, error handling, or output structure. With annotations present, the bar is lower, but the description still lacks richer behavioral context.

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, front-loaded sentence with no redundant details. Every word contributes to conveying the tool's purpose.

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 output schema exists and annotations are good, the description adequately covers the core purpose. However, it is minimal and does not address language support specifics or parameter semantics. It is sufficient for a read-only analyzer but leaves some gaps in completeness.

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%, yet the description only implies that 'code' holds source code and does not mention the 'language' parameter at all. It fails to compensate for the low schema coverage, leaving the language parameter's role and accepted values unspecified.

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 a specific verb 'Measure' and resource 'source-code size, functions, branching complexity, and maintainability signals', which distinguishes it from sibling tools like dependency-audit and license-audit. It is unambiguous about the tool's core function.

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 usage context is implied (analyzing source code metrics) but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It does not mention that 'supported languages' limits applicability or how to handle unsupported languages.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the output behavior (returning affected packages and vulnerabilities) and the OSV source, but does not disclose additional traits like performance, rate limits, or error handling. No contradiction.

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, well-structured sentence that packs all key information without waste. It front-loads the verb and resource, then specifies scope and outcome efficiently.

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 a rich input schema, output schema, and good annotations, the description is complete enough for a typical audit tool. It covers the core purpose and result, though it omits minor details like handling of unfound dependencies or format specifics. Overall, sufficient for an agent to select and invoke correctly.

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

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

Schema description coverage is 0%, but the schema itself is self-explanatory with an ecosystem enum and a dependencies array with name/version fields and bounds. The description redundantly lists the ecosystems but adds no additional meaning 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 uses a specific verb ('Audit') with a clear resource ('dependencies'), explicitly enumerates all supported ecosystems, and specifies the action (against OSV) and outcome (return affected packages and vulnerabilities). This distinguishes it from sibling tools like license-audit and secret-scan.

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 clearly implies when to use it: whenever you need to audit exact dependency versions for known vulnerabilities across multiple ecosystems. It doesn't explicitly state exclusions or alternatives, but sibling names like license-audit and secret-scan provide context, making the use case 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds the core behavior of classification and flagging, but no extra behavioral context like how unknown licenses are handled or what 'commercial' policy entails. This is acceptable but not adding much beyond annotations.

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, front-loaded sentence that efficiently states the tool's purpose and outcome. There is zero waste and every word contributes to meaning.

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

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

Given the moderate complexity (2 params, one with enum, array of objects) and the presence of an output schema, the description covers the main purpose but leaves key contextual gaps: the meaning of 'policy' and any guidance on when to use this vs. dependency-audit. Annotations cover safety, but the description is not fully complete 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 description coverage is 0%, and the description fails to explain the 'policy' parameter, which is a critical enum that changes classification behavior (permissive vs commercial). It also doesn't mention that dependencies must be name/license pairs. The description does not compensate for the missing schema descriptions.

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

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

The description uses a specific verb 'Classify' and clearly names the resource 'software dependency licenses'. It also specifies the outcome 'flag packages that need commercial or legal review', which distinguishes it from sibling tools like developer.dependency-audit or developer.openapi-audit.

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

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

The description implies usage for license compliance review but offers no explicit when-to-use guidance or alternatives. It doesn't mention that developer.dependency-audit might be better for vulnerability scanning, leaving context only implicit from the tool name and sibling list.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe read-only nature is covered. The description adds context about the audit scope (what is checked), but does not disclose additional behaviors such as validation error handling or output format. Since an output schema exists, return values are not required here.

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 that front-loads the action and specifies the audit targets. There is no filler, repetition, or unnecessary detail; every word contributes to understanding the tool's purpose.

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 captures the core functionality but omits parameter details (especially 'format') and the meaning of 'consistency problems'. The output schema covers return values, but the complete input contract is not fully described. For a 2-parameter tool with minimal schema descriptions, the description is adequate but has clear 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%, and the description does not explain the 'format' parameter (JSON/YAML, default YAML) or the expected format of the 'document' parameter (e.g., raw string vs. path). The description only implies 'document' via the phrase 'OpenAPI document', leaving parameter semantics under-specified.

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+resource ('Validate and audit an OpenAPI document') and lists concrete audit targets (missing operation IDs, descriptions, responses, consistency problems). It clearly distinguishes itself from sibling audit tools (e.g., dependency-audit, license-audit, security-audit) by focusing on OpenAPI documents.

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

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

Usage is implied by the resource type (OpenAPI document), but there is no explicit guidance on when to use this tool versus alternative audit tools. No exclusions or alternative tool recommendations are provided, despite the presence of many sibling audit tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds the critical behavioral trait that it does not return secret values, which is a privacy guarantee beyond annotations. It also specifies what it detects (API keys, tokens, credentials), adding useful context.

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

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

The description is a single, focused sentence that front-loads the action and includes all essential information without redundancy. Every clause contributes to understanding the tool's purpose and behavior.

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 tool with output schema and annotations covering safety, the description provides complete context: what it scans, what it detects, and the key behavior of not exposing secrets. No major gaps remain, and the output schema covers 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?

The input schema has one required 'content' parameter with no description. The tool description compensates by specifying that content should be 'source code or configuration text,' giving semantic meaning to the parameter. This adds value beyond the schema's bare type and maxLength.

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

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

The description uses the specific verb 'Scan' with a clear resource ('source code or configuration text') and identifies the detection targets ('leaked API keys, tokens, and credentials'). It also distinguishes itself by noting it does not return secret values, setting it apart from potentially similar tools like document.redact.

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 clearly implies when to use the tool: when you have source code or configuration text to check for secrets. It does not explicitly mention alternatives, but the specialized purpose makes it distinct from sibling tools like data.clean or developer.dependency-audit. Lacks explicit exclusions or alternative references, hence not 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful context about the output format (additions, removals, changes by path), but does not disclose additional behavioral traits like handling of nested objects or edge cases. This aligns with the lowered bar for annotated tools but adds only moderate value.

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 that is front-loaded with the action 'Compare' and clearly states the resource and output. Every word earns its place; there is no redundancy or 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?

Given the moderate complexity (3 parameters, output schema present, annotations cover safety), the description is sufficiently complete. It covers the core purpose and expected output without needing to explain return values in detail because an output schema exists. Only minor missing context is explicit differentiation from sibling tools, but the structured orientation provides enough.

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 clarifies the tool deals with JSON or YAML documents, making the 'before' and 'after' parameters understandable as the two documents being compared. The 'format' parameter's purpose is implied by the mention of JSON/YAML, and the enum values fill in the rest. This is adequate compensation for the missing schema descriptions.

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

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

The description clearly states the tool compares JSON or YAML documents and returns specific machine-readable output (additions, removals, changes by path). This uses a specific verb+resource and distinguishes it from siblings like document.diff by specifying structured formats and path-based changes.

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

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

The description implies usage for comparing structured JSON/YAML data but provides no explicit guidance on when to use this tool versus alternatives like document.diff. It does not mention exclusions or workflows, so it functions at the level of implied usage rather than explicit guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the baseline is lower. The description adds that the tool performs a 'probe' without payment, implying a network request to the endpoint, and returns a compliance grade, evidence, and remediation. It does not detail response handling or potential side effects, but given annotation coverage, this is acceptable.

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 that front-loads the core action ('Probe a public endpoint') and follows with specific outputs. 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?

Given the presence of an output schema and rich annotations, the description adequately defines the tool's purpose and key benefit. However, it lacks usage guidelines and leaves parameter semantics unexplained, which slightly reduces completeness for an agent needing to use it correctly.

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

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

The description provides no information about the meaning or usage of the parameters (url, body, method). With schema_description_coverage at 0%, the description does not compensate for this gap. Parameter names are somewhat self-explanatory, but the description could have explained how body and method affect the probe.

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 ('Probe a public endpoint'), the resource ('public endpoint'), and the outcome ('return an x402 v2 compliance grade, protocol evidence, and actionable remediation'). The phrase 'without paying' differentiates it from paid endpoint testing tools, distinguishing it from siblings like web.security-audit.

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

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

The description implies the tool is for verifying x402 compliance of a public endpoint before paying for access. It provides clear context for when to use it, but does not explicitly mention alternatives or exclusions, so it lacks full 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?

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds that it returns structured line additions/removals and a unified diff, which is valuable behavioral context about the output beyond what annotations convey.

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

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

The description is a single sentence that front-loads the action and resource, followed by output details. Every word is necessary, and there is no redundancy or 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?

Given the simplicity of the tool and the presence of a rich output schema, the description provides a basic understanding but misses key details like the meaning of context_lines and how it differs from developer.structured-diff. The output schema likely covers return structure, but the description alone is not fully self-sufficient.

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

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

Schema coverage is 0%, so the description must explain parameters, but it only says 'two texts' without clarifying that 'before' and 'after' are the versions to compare. The 'context_lines' parameter is entirely ignored. The parameter names are intuitive but the description does not add meaningful semantic 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?

The description uses a specific verb 'Compare' and identifies the resource as 'two texts', clearly stating the output: structured line additions, removals, and a unified diff. This distinguishes it from sibling tools like developer.structured-diff, which focus on structural diffs.

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

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

The description implies the tool is used for comparing texts and getting a diff, but it does not explicitly state when to use it versus alternatives such as developer.structured-diff or data.clean. There are no exclusions or context cues beyond the inherent purpose.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to cover safety. It adds the output scope ('clean text and metadata') but does not disclose potential caveats like OCR limitations, file-size constraints, or how different formats are handled. No contradiction with annotations.

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 that is concise, front-loaded with the core verb and resource, and lists supported formats efficiently without extraneous 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?

While annotations provide safety hints and an output schema exists, the description is incomplete regarding input encoding and usage context. It does not mention that binary content must be base64-encoded or how the filename influences parsing, which is needed for a complete understanding of the tool.

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

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

The schema description coverage is 0%, and the description provides no additional meaning for the parameters. It does not explain that content_base64 should be base64-encoded content or that filename is used to determine the format. With no compensation from the description, this is a significant gap.

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

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

The description clearly states the tool's function with a specific verb ('extract') and resource ('documents'), listing supported formats and the output ('clean text and metadata'). It distinguishes itself from siblings like document.diff and document.redact by focusing on extraction rather than comparison or redaction.

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

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

The description implies usage for local document processing by listing file formats, but it does not explicitly state when to prefer this tool over alternatives such as web.extract. There is no mention of exclusions or contrasting use cases 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds the specific PII types it handles, which is useful context, but it does not disclose details about the output format (e.g., placeholder style) or behavior when no PII is found. The description is consistent with annotations, so no contradiction.

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, well-structured sentence that front-loads the action ('Detect and redact PII and personal data in text') and then lists examples. Every word adds value, and there is no redundancy or 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?

With an output schema present and annotations covering safety and idempotency, the description is largely complete for a text-processing tool. It covers the input domain and the types of PII handled. The only notable gap is the unspecified behavior when the 'types' parameter is omitted (whether it defaults to all types), which is not addressed in the description or 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?

The schema provides no descriptions for the two parameters (0% coverage), so the description carries the burden. It explicitly names 'email addresses, phone numbers, IPv4 addresses, payment cards, and US Social Security numbers', which directly correspond to the enum values in the 'types' parameter. The 'text' parameter is implied by 'in text', adding reasonable context, though the maxLength is only in the schema.

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

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

The description uses specific verbs 'Detect and redact' with a clear resource ('text') and lists the PII categories (email, phone, IPv4, payment cards, SSN). It is unambiguous about the tool's function, though it does not explicitly distinguish itself from sibling tools like data.clean or developer.secret-scan, preventing a perfect score.

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

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

The description implies the tool is for redacting PII from text, but it provides no explicit guidance on when to use it versus alternatives, no exclusions, and no mention of related tools. The intended use case is inferable but not stated directly.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds the supported input formats but does not disclose limitations such as handling of malformed tables or performance characteristics. With strong annotations, the added value is moderate.

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, front-loaded sentence with no filler. It concisely conveys the tool's purpose and input scope without unnecessary 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?

Given the presence of an output schema and annotations covering safety, the description is largely adequate. The primary gap is the lack of parameter explanations, but the overall context for selecting and using the tool is sufficient for a simple extraction 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%, and the description does not compensate by explaining the parameters. 'content_base64' is not described as the base64-encoded file content, and 'filename' is only implied. The parameter names are self-evident but the description adds no direct clarification.

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 (Extract) and the specific resource (structured table rows and columns) from supported formats (HTML, DOCX, CSV). This distinguishes it from generic extractors like document.extract and data tools, making the purpose immediately clear.

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 context for when to use the tool: when you need structured table data from HTML, DOCX, or CSV documents. It does not explicitly mention alternatives or when not to use it, but the table-specific scope makes the appropriate scenario evident.

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

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

Although annotations already declare read-only, idempotent, and non-destructive behavior, the description adds valuable context: it fetches external feeds (implying network access) and normalizes them into a stable JSON structure. This goes beyond the structured annotations without contradicting them.

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, front-loaded sentence that efficiently conveys the tool's core function and output. Every word earns its place, with no redundancy 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?

Given the tool's moderate complexity, the presence of an output schema, and strong annotations, the description covers the essential aspects: input type (RSS/Atom), output type (structured JSON), and context (agents/research). It lacks minor details like pagination or error handling, but these are not critical for tool selection.

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 tool description does not mention the 'limit' parameter or explain how 'url' is used beyond the obvious. The parameter names and format hint are helpful, but the description adds no extra meaning, so it fails to compensate for the missing schema descriptions.

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

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

The description uses a specific verb 'Fetch and normalize' and names the resource 'public RSS or Atom feeds', clearly distinguishing it from sibling tools that handle other data types. The output ('stable structured JSON entries') further clarifies its purpose.

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

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

The description provides clear context: it is for agents and research workflows needing to ingest feed data. It doesn't explicitly state when not to use it or name alternatives, but the sibling list contains no competing feed-specific tools, making the intended usage obvious.

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

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

Annotations already establish read-only, idempotent, open-world, and non-destructive behavior. The description adds operational detail beyond annotations by explaining the normalization process, accepting ticker or CIK, and enumerating the detected event categories. It does not disclose rate limits or edge cases, but the output schema covers return values, keeping the bar lower.

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, information-dense sentence that efficiently conveys input, processing, and output. It is front-loaded and free of fluff, every word contributing to the tool's understanding.

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

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

The combination of description, annotations, and output schema gives the agent sufficient context to select and invoke the tool correctly. It covers input types, processing steps, and output categories, though it could mention data source limitations (e.g., U.S. SEC filings only) or edge cases. For its complexity, this is adequately 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?

With 50% schema coverage, the description adds meaningful context for identifier (ticker/CIK) and lookback_days ('recent' filings) but does not clarify the undocumented max_filings parameter or explicitly describe the forms filter. It provides a moderate semantic bridge without fully compensating for the missing parameter descriptions.

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

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

The description uses a specific verb phrase ('look up', 'normalize', 'flag') and clearly identifies the resource (public company SEC filings) and the output (deterministic events). It lists concrete event types, distinguishing it from sibling tools like research.sec-financial-facts and research.sec-insider-transactions.

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

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

The description implies a use case (flagging SEC filing anomalies) but does not explicitly state when to use this tool versus alternatives such as research.sec-financial-facts or research.feed-normalize. It provides clear context but lacks exclusions or explicit alternative references.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds useful context about data normalization and recency, but it does not disclose any potential limitations (e.g., data availability windows, rate limits, or return behaviors) beyond what annotations provide.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the action, resource, and key data types, making it both concise 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 rich annotations, an output schema, and a clear description, the tool is well-specified for selection and invocation. The only minor gap is the absence of any guidance on tool use cases relative to the sibling SEC tools, but the description itself is sufficient for understanding what the tool does.

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% (three of four parameters documented), placing the baseline at 3. The description lists metric categories (revenue, earnings, etc.) which map to the 'metrics' enum, and mentions 'recent' which indirectly relates to 'periods' and 'period_type', but it adds no parameter-specific syntax or format details beyond the schema.

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

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

The description states a specific verb ('Retrieve'), a specific resource ('official SEC XBRL data'), and a clear scope (normalized revenue, earnings, balance-sheet, cash-flow, and diluted-EPS facts). This clearly distinguishes it from sibling tools like research.sec-filing-signals and research.sec-insider-transactions.

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

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

The description implies usage via the specific financial facts it returns, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. For example, there is no reference to sibling SEC tools like sec-filing-signals or sec-insider-transactions, so the choice among them is left 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds useful behavioral context such as the 'recent' time scope, the types of filers (officer, director, 10% owner), and the inclusion of 10b5-1 context, derivatives, and footnotes, which go beyond the schema fields and give realistic expectations about the tool's output.

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

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

The description is a single, dense sentence that front-loads the action and resource. Every clause adds meaningful detail (trader types, transaction categories, metadata like prices, holdings, footnotes) without repetition or 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?

Given the tool's moderate complexity (4 parameters, 1 required, output schema present) and strong annotations, the description is complete. It covers the return content extensively and leaves no major ambiguity about what the tool retrieves and includes.

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%: identifier and include_derivatives have descriptions. The tool description reinforces these by mentioning ticker/CIK and derivatives, and 'recent' implies lookback_days. However, it adds no explicit clarification for max_filings or lookback_days beyond their self-explanatory titles and defaults, so it only partially compensates for the schema 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 begins with a specific verb ('Retrieve') and names a precise resource: recent SEC Form 4 trades for a ticker or CIK. It further enumerates transaction types and trader categories, clearly distinguishing this tool from siblings like research.sec-filing-signals or research.sec-financial-facts.

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

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

The description provides clear context for when to use the tool (when insider transaction details are needed) by listing the covered Form 4 events and data elements. It does not explicitly name alternatives or exclusions, but the sibling research tools have obviously different purposes, so the intended usage is implicitly 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds valuable behavior context by mentioning 'deterministic HTML' analysis and 'actionable WCAG-oriented findings,' which implies static source checks and output format. This does not contradict annotations and goes beyond the structured data.

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 one concise sentence of 14 words, front-loaded with the action verb 'Check' and the resource. Every word contributes meaning, with no redundancy 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 tool with a single parameter, comprehensive annotations, and an output schema present, the description sufficiently covers the behavior. The phrase 'deterministic HTML' hints at static analysis limitations and the 'actionable' output gives insight into results, but it does not explicitly enumerate edge cases or exclusions, leaving room for a 4.

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 a single 'url' parameter with format uri and no description, leaving 0% schema description coverage. The description compensates minimally by specifying 'public page,' implying the URL must be publicly accessible, but it does not elaborate on the parameter further. The schema itself carries most of the semantic weight, so a 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 clearly states the tool's function: 'Check a public page for deterministic HTML accessibility problems and return actionable WCAG-oriented findings.' It uses a specific verb ('Check'), identifies the resource ('public page'), and specifies the scope ('accessibility problems' and 'WCAG-oriented findings'), which differentiates it from sibling tools like web.seo-audit and web.security-audit.

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

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

The description provides clear context that the tool is for accessibility auditing of public web pages, which implies when to use it. However, it does not explicitly name alternatives or state when not to use this tool in favor of other web.* audit tools, so it earns a 4 rather than 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?

Annotations already communicate that the tool is read-only, idempotent, and non-destructive. The description adds that it aggregates multiple assessment areas, but it does not disclose additional behavioral traits such as rate limits, data freshness, or whether the tool performs external network requests.

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, front-loaded sentence that names the primary action and the full set of assessment dimensions without extraneous detail. Every phrase contributes meaning, and the structured listing of signals makes it 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?

The tool has an output schema (unfortunately not provided), so omission of return-value details is acceptable. Although the description succinctly names the assessed areas, it lacks usage context relative to sibling tools and does not explain what 'due diligence' entails at a practical level, making it slightly less complete 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?

The input schema documents a single required url parameter, but the schema description coverage is 0%. The description does not clarify whether the url must be a fully-qualified domain, whether protocol prefixes are accepted, or how domain vs. URL input is normalized, leaving the agent to infer parameter handling from the field name alone.

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

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

The description uses the specific verb 'Assess' with resource 'a business domain' and enumerates eight distinct signal categories (website quality, SEO, security, etc.), making the tool's scope immediately clear. This distinguishes it from sibling tools like web.seo-audit or web.security-audit, which focus on a single dimension.

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 lists the signals assessed, implying the tool is a comprehensive option for holistic domain evaluation. However, it does not explicitly state when to use this tool versus individual audit siblings, nor does it mention any exclusions or trade-offs.

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

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

Annotations already declare readOnly=true and destructive=false; the description adds that the tool compiles an aggregated report from multiple sources, providing useful behavioral context about its investigation nature. There are no contradictions with annotations, and the added context about combining DNS, TLS, and RDAP signals is valuable beyond the structured annotations.

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 one sentence, front-loaded with the core verb 'investigate', and contains no filler. Each clause adds distinct information: the data sources (DNS, TLS, RDAP) and the deliverable format (one structured report). It is optimally concise and well-structured.

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

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

The tool has a simple input (1 required URL) and annotations covering safety; the description sufficiently explains the purpose and the type of output (structured report). An output schema exists, so return values need not be detailed. The only gap is the lack of explicit use-case boundaries, but for a low-complexity tool, this is 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?

The input schema has a single 'url' parameter with no description (0% coverage). The description mentions 'domain' but does not clarify whether the URL must be fully qualified, include a protocol, or if bare domain names are accepted. The format 'uri' is only in the schema, so the description adds minimal semantic value beyond the parameter name, leaving the agent uncertain about input requirements.

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

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

The description uses the specific verb 'investigate' and names the resource 'a domain' plus three concrete signal types (DNS, TLS certificate, RDAP registration). This clearly distinguishes it from sibling tools like web.extract or web.metadata, which focus on different aspects. The purpose is immediately understandable and not a tautology.

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

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

The description implies the tool is for domain intelligence via DNS/TLS/RDAP, but it does not explicitly state when to prefer it over alternatives or when not to use it. Given the sibling list contains many web audit tools (e.g., web.security-audit, web.tech-fingerprint), explicit guidance would be helpful; the usage is inferred 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds that the output is 'clean readable text or Markdown', which is a behavioral trait, but does not disclose other behaviors like redirects, rate limits, or JavaScript rendering. This is adequate but not rich, given the 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?

The description is a single sentence that is front-loaded with the primary action ('Extract'), directly states the resource and output, and includes a concise list of use cases. Every word earns its place, with no redundancy or 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?

Given the tool's simplicity (2 params, output schema present, rich annotations), the description is mostly complete. It explains the core value proposition and output format, and the output schema covers return details. It lacks explicit mention of edge cases (e.g., non-public pages, dynamic content), but these are not essential for the tool's primary use.

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

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

Schema description coverage is 0%, but the schema itself is simple and self-explanatory. The description adds meaning by specifying 'any public web page' for the URL parameter and mentioning 'text or Markdown' for the output parameter. However, it does not explicitly map description phrases to parameter names, leaving some ambiguity. The burden is partially met but not fully compensated.

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

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

The description clearly states the tool's function with a specific verb ('extract') and resource ('web page'), specifying output as clean readable text or Markdown. It distinguishes itself from sibling tools like web.links and web.metadata by focusing on content extraction rather than metadata or links. The mention of use cases ('research, summarization, RAG, or agent context') adds clarity.

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 contextual use cases (research, summarization, RAG, agent context) which imply when to use the tool. However, it does not explicitly name alternatives or state when not to use it, unlike the high-calibration example. It is clear about the primary scenario but lacks exclusionary 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the description's safety profile is covered. The description adds value by disclosing that the audit produces 'scores' and 'prioritized fixes', and that it combines multiple dimensions, giving the agent an expectation of the tool's scope and output. This goes beyond what annotations provide.

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

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

The description is one sentence, front-loaded with the verb and key info, and contains no extraneous words. Every phrase earns its place: 'comprehensive', 'combining', the four audit areas, and 'prioritized fixes' are all necessary.

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

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

The tool is complex (full audit with multiple dimensions), but the description captures the core scope, deliverable, and purpose. Since an output schema exists, the description need not explain return structure. Annotations cover safety semantics. The only missing context is perhaps prerequisites (e.g., publicly accessible URL) or limitations, but these are not critical given the minimal interface and high-level description.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. The single parameter 'url' is evident from the phrase 'website audit', which implicitly defines the target. However, the description does not explicitly explain url format requirements (e.g., must be a full URL vs. domain) or behavior if invalid. The schema's format field provides some basic info, but the description adds minimal detail beyond that.

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 ('Run') and resource ('comprehensive website audit'), explicitly enumerating the combined areas (SEO, security, accessibility, performance) and the output (scores with prioritized fixes). This clearly distinguishes it from sibling tools like web.seo-audit or web.security-audit, which focus on single areas.

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

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

The description implies usage by calling the audit 'comprehensive' and listing multiple facets, suggesting it's for a broad review rather than a specific concern. However, it does not explicitly state when to use this tool versus the individual audit siblings (e.g., 'use this for an overall assessment, or use web.seo-audit for SEO-only'). Guidance is implied but not 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?

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds that links are normalized and classified, and that the page must be public, which provides some context beyond annotations, but lacks details on how normalization/classification works or potential limitations.

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, well-structured sentence with no redundant wording. It front-loads the core actions and resource, making it immediately 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?

The tool is simple, has an output schema, and strong annotations. The description covers the main purpose and scope. Minor additions like edge cases or link classification criteria are not critical given the output schema provides return structure.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at 'internal and external' links relating to include_external, but doesn't explain either parameter's meaning, requiredness, or format. Since there are parameters and no schema descriptions, this is a significant 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 uses specific verbs 'extract, normalize, and classify' with a clear resource ('links from a public web page'). It distinguishes the tool from siblings like web.extract and web.metadata by focusing solely on link processing.

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 clearly implies when to use the tool (for extracting and categorizing links from a page), but it does not explicitly mention alternatives or when-not scenarios. Sibling tools exist but aren't referenced.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which cover safety behavior. The description adds valuable context by specifying 'from a public page', which sets expectations about accessibility, and enumerates the exact metadata fields extracted, clarifying the tool's behavior beyond the annotations.

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, well-structured sentence that leads with the verb 'Extract' and concisely lists the extracted metadata categories. There is zero waste and it is immediately clear what the tool does.

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

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

The tool is simple, has an output schema, and a clear read-only annotation profile. The description adequately covers the core functionality but omits usage guidance (e.g., when to choose this over web.extract) and does not mention any potential edge cases or error conditions. It is minimally viable but not exhaustive.

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

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

Schema description coverage is 0%, so the description carries some burden for parameter meaning. The only parameter is 'url', which is self-explanatory from the schema (type string, format uri), and the description implies the input is a public page URL. However, the description does not explicitly mention the url parameter or provide any additional constraints beyond 'public page'.

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 ('Extract') and the specific types of data returned (canonical URLs, titles, descriptions, Open Graph, Twitter Card, and document metadata), which is specific enough to convey the tool's scope. It does not explicitly contrast with sibling tools like web.extract or web.links, but the list of metadata types helps distinguish 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?

There is no explicit guidance on when to use this tool versus alternatives such as web.extract or web.seo-audit. The description implies it is for metadata extraction, but it does not state when not to use it or mention any complementary tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds the 'public URL' constraint and specifies the measured signals, which is useful. However, it does not disclose potential behaviors like network dependency, timeout, or rate limiting, so it adds only moderate context beyond annotations.

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 declarative sentence, front-loaded with the verb, and contains no extraneous information. It efficiently conveys the tool's 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 single-parameter tool with an output schema covering return values and annotations covering safety, the description provides sufficient context about the tool's purpose and the URL parameter. The list of performance signals is enough for an agent to understand what to expect. Minor gaps like potential side effects are covered by annotations, so completeness is high.

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

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

The sole parameter 'url' is described in the schema only by format constraints. The description adds minimal semantic context by indicating it is a 'public URL' for a website, which compensates only partially for the 0% schema description coverage. It does not clarify supported schemes or other requirements.

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

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

The description uses the specific verb 'Measure' and lists concrete metrics ('response latency, payload size, compression, caching, and performance signals') for a 'public URL'. This clearly distinguishes from sibling tools like web.links or web.metadata, which cover different aspects.

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 instead of web.full-audit, web.metadata, or other performance-related tools. The description is purely definitional, with no exclusions or context about 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds context that the tool inspects crawl rules and sitemap health/availability/count, which is consistent with a read-only operation. However, it does not disclose details like whether it makes live HTTP requests or how it handles missing robots.txt/sitemap.

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 entire description is a single, front-loaded sentence that efficiently states the tool's purpose without unnecessary 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?

The tool is simple with one parameter and an output schema, so the description covers the core functionality. However, the domain/url ambiguity and vague terms like 'health' leave some gaps, so it's not fully complete.

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

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

The schema defines a single 'url' parameter with format 'uri', but the description says 'domain' without clarifying whether a full URL (e.g., https://example.com) or bare domain (example.com) is expected. With 0% schema description coverage, the description fails to resolve this ambiguity.

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

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

The description uses the specific verb 'Inspect' and identifies the exact resources: 'robots.txt crawl rules and XML sitemap health, availability, and URL count'. This clearly distinguishes it from sibling tools like web.links or web.metadata, which focus on different aspects of a domain.

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

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

The description does not explicitly state when to use this tool versus alternatives. The purpose is clear, so usage is implied (e.g., for SEO/crawlability inspection), but there are no explicit exclusions or alternative tool references.

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

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

The annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds the behavioral detail that it returns a security score with fixes, and it constrains the target to public websites. It does not mention potential side effects like network latency or rate limits, but the safety profile is well covered by annotations, so the bar is lower. The addition of output details and scope is helpful.

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, well-structured sentence that front-loads the action and output. It contains no filler or redundant information, achieving maximum clarity in minimal 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 one-parameter tool with an output schema and safety annotations, the description is sufficiently complete. It specifies the input (public website URL), the activity (TLS and header scanning), and the output (score with fixes). The existence of an output schema relieves the description from detailing return values. Minor gaps like handling of errors or non-public sites are not critical given the simplicity.

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 documents a single URL parameter with format 'uri', but provides no descriptive text. The description compensates by stating the tool scans a 'public website', which clarifies that the URL parameter is the target website to audit. This adds meaning beyond the schema's type and format, though it does not elaborate on URL validation or edge cases.

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 'Scan' and clearly identifies the resource ('public website') and the focus ('TLS and browser security header weaknesses'), and it states the output ('security score with fixes'). This distinguishes it from sibling audit tools like web.seo-audit or web.accessibility-audit, which target different aspects.

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

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

The description provides clear context for when to use the tool: for security auditing of a website's TLS configuration and security headers. However, it does not explicitly name alternatives or exclusions, so it lacks the explicit 'use this instead of X' guidance. It is clear enough that an agent can infer it is for security-focused audits, but not as explicit as a description that names sibling tools.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by revealing that the tool 'scores' the URL and returns 'prioritized' issues, which informs the agent about the output format and ordering—something annotations do not provide.

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

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

The description is a single, front-loaded sentence that directly communicates the tool's purpose and key behavior without any redundant words. It is concise and well-structured, which aids quick comprehension.

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 one simple parameter, read-only annotations, and an output schema (which may explain return values), the description covers the essential context: what the tool audits, the input constraint (public URL), and the nature of the output (prioritized, actionable issues). It does not mention limitations or prerequisites beyond 'public URL', but this is sufficient for the tool's simplicity.

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 one parameter (url) with no description, so schema_description_coverage is 0%. The description compensates slightly by stating 'public URL', implying the url must be publicly accessible, which adds a meaningful constraint. However, it does not explain formatting or additional requirements, leaving the parameter semantics only partially 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?

The description clearly states a specific action ('Audit on-page technical SEO') and the resource ('a public URL'), with a clear outcome ('return prioritized, actionable issues'). It distinguishes itself from sibling audit tools (e.g., web.security-audit, web.accessibility-audit) by focusing on SEO, so there is no ambiguity about what this tool does.

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

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

The description implies usage for SEO analysis ('for search optimization') but does not explicitly state when to use this tool versus alternatives like web.full-audit or web.security-audit. There are no exclusions or comparative guidance, so it relies on the tool's name and context, making it 'implied usage' rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that it works from 'public response signals', suggesting network requests, but does not disclose potential rate limits or other behavioral details. Since annotations cover the main concerns, this is adequate but not rich.

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

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

The description is a single, concise sentence that is front-loaded with the action and key details. It contains no fluff or redundancy, making it highly efficient.

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

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

Given the tool's simplicity (one parameter), existing output schema, and strong annotations, the description provides enough context to understand what it does. It could explicitly mention usage scenarios or expected return types, but the output schema presumably covers return values. Overall, it is complete for its 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?

There is one required parameter, 'url', with 0% schema description coverage. The tool description does not explicitly describe the parameter, but the parameter name and the tool's purpose make its meaning obvious. This provides minimal added value beyond the schema, but it is sufficient for such a simple 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 clearly states the verb 'identify' and specifies the resources (frameworks, analytics, CDNs, servers), while also noting the data source ('public response signals'). This distinguishes it from sibling web tools like web.extract or web.metadata, which focus on different aspects of a website.

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

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

The description implies usage when you need to identify a website's technology stack, but it does not explicitly state when to use this tool versus alternatives like web.security-audit or web.full-audit. No exclusions or alternative tool references are provided, leaving the usage context only implied.

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