1cent Web Intelligence for AI Agents

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

Annotations already indicate readOnly and idempotent behavior. The description adds that it returns up to five results with specific fields (purpose, price, path) and confirms no payment or URL fetching is required, enhancing 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?

Two concise sentences, front-loaded with the critical usage hint. Every sentence provides essential information without 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?

Given the tool's simplicity, the description fully explains its purpose, output, and constraints. An output schema exists (though not shown) and annotations cover safety, so no additional context is needed.

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 covers the single parameter with a clear description and examples. The tool description adds no new parameter info beyond that, but schema coverage is 100%, so baseline score of 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 title and description clearly state this tool searches the catalog for tools and their current price, with a strong "Start here" directive. It distinguishes itself from sibling URL-centric tools by focusing on catalog search.

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

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

Explicitly advises using this tool before paid operations, implying it's free and exploratory. Does not explicitly list alternatives but the context makes it clear it's for discovery, not for fetching actual URL data.

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 readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context: SSRF protection, fixed target, rate-limiting per client, and preservation of cache/audit behavior. No contradictions.

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 consists of two concise sentences that front-load the key information (purpose, target, payment, rate-limiting, cache/audit). Every sentence adds value without 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?

For a simple tool with no parameters, an existing output schema, and comprehensive annotations, the description covers all important aspects: what it does, constraints (fixed target, rate-limiting), and behavioral traits (SSRF protection, cache/audit preservation). No 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?

With 0 parameters and 100% schema coverage, the schema already fully documents the input. The description adds value by explaining that no URL is accepted and the target is fixed, which is important context beyond the empty schema.

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

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

The description clearly states the tool runs the SSRF-protected URL Pulse service against a fixed target (https://example.com/) without payment. It distinguishes from siblings like demo.url.pulse and web.url.pulse by noting it accepts no URL and is a free demo.

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 use for testing/demo purposes without payment, and mentions rate-limiting per client. However, it does not explicitly state when to use this tool vs. the full web.url.pulse tools or when not to use it (e.g., for actual URL scanning).

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?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds that no network request or database access occurs, and it's a fixed precomputed output. This fully clarifies the tool's behavior.

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

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

Two sentences, no unnecessary words, front-loaded with the main action. Every sentence 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?

For a 0-parameter demo tool with an output schema, the description is complete: explains purpose, constraints, and behavior. All relevant context is provided.

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 is empty with 100% coverage, so baseline is 4. The description adds meaning by explaining the absence of parameters (never accepts a URL), reinforcing why no params exist.

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 it returns a precomputed example of 1cent URL Pulse output without any external interaction. It uses specific verbs and resources ('Return a precomputed example') and implicitly distinguishes from real URL Pulse tools by noting it never accepts a URL.

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 this is a fixed demonstration without external dependencies, but it does not explicitly mention when to use it versus other sibling tools like demo.live.pulse or web.url.pulse.

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?

While annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, the description adds valuable behavioral specifics: pricing is quoted before work, processing is sequential and order-preserving, partial failures use safe error codes. These details go well beyond the annotation hints and inform the agent of important execution semantics.

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 three concise sentences, front-loaded with the core purpose, then pricing, then execution behavior. Every sentence contributes unique, non-redundant information without fluff, achieving high clarity in minimal space.

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 batch status tool with a rich input schema and an output schema available, the description covers all necessary aspects: the action, the input constraints (public, 1-5, distinct), the cost model, execution order, and error handling. It does not explain return values, but the output schema handles that, so completeness is strong.

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

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

The schema covers both parameters fully (urls and fresh), so the baseline is 3. However, the description adds extra meaning not present in the schema: the pricing formula (per-URL unit price multiplied by URL count) and the processing order guarantee, which relate to the urls parameter's behavior. This supplemental context justifies a 4.

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 'Check HTTP status for one to five distinct public URLs,' using a specific verb and resource while clearly distinguishing itself from the sibling web.url.status tool by highlighting the batch capability. It also imposes clear scope (1-5 URLs) and eligibility (public, distinct), making the purpose immediately unambiguous.

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

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

The description provides clear context for when to use the tool: when checking 1-5 public URLs and when a quote is needed. It states constraints (public, sequential, bounded) but does not explicitly name alternative tools or state when not to use it (e.g., for a single URL, prefer web.url.status, or for content inspection use other tools). This is clear context but lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety. The description adds behavioral context beyond annotations: 'it does not execute JavaScript or bypass access controls' and the cache/fresh semantics. This gives the agent a clear picture of side effects and limitations. 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 three sentences, front-loaded with the core purpose, followed by clear usage constraints and parameter guidance. No wasted words; every sentence earns its place.

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

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

Given the moderate complexity (checking multiple discovery files), the description covers the essential context: what it does, when to use it, limitations, and parameter guidance. An output schema exists, so return format description is not required. It could mention that coherence is evaluated only among 'declared' discovery files, but this is a minor gap.

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

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

Schema description coverage is 100%: url is documented as an absolute public HTTP(S) URL with SSRF protections, and fresh has a default of false with a description. The description largely repeats these facts, though it phrases the fresh guidance more actionably ('Keep fresh=false to allow cache reuse'). Schema carries the semantic weight, so baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Check declared robots, sitemap, feed, OpenAPI and llms.txt discovery coherence.' This clearly distinguishes it from sibling tools that check individual files (e.g., web.site.robots, web.site.sitemaps). The resource scope is well-defined.

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

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

The description gives explicit usage constraints: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' It also advises on the fresh flag: 'Keep fresh=false to allow cache reuse; set fresh=true only when a new upstream fetch is required.' However, it does not name alternative tools for single-resource checks, so it falls short of the highest bar.

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, non-destructive behavior. The description adds context about not executing JavaScript or bypassing access controls, and clarifies caching behavior with the 'fresh' parameter.

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

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

Three concise sentences, front-loaded with purpose, no redundant information. Every sentence 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?

For a tool with two parameters and an output schema, the description covers purpose, constraints, parameter usage, and cache behavior sufficiently. No gaps remain.

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

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

Schema description coverage is 100%. The description adds practical nuance: 'Pass url as an absolute public HTTP(S) URL' reinforces the schema, and the cache guidance for 'fresh' enhances usability beyond the schema 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 clearly states the tool's purpose: 'Discover declared RSS and Atom feeds.' It uses a specific verb-resource pair and naturally differentiates from sibling tools like web.url.* extractors.

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

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

Explicitly states when to use (public HTTP/S resources only) and provides guidance on the 'fresh' parameter (default false for cache reuse). While it doesn't name alternative tools, the usage 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 provide readOnlyHint and idempotentHint. The description adds behavioral context: the tool is bounded (cached), does not execute JS, does not bypass access controls, and explains cache reuse with fresh parameter. This goes beyond annotations, though some annotation info is redundant.

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 four sentences with no redundancy. It front-loads the purpose and efficiently covers usage, limitations, and parameter guidance. Every sentence 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?

Given the tool's simplicity (2 params, no nested objects) and the presence of an output schema, the description covers all key aspects: what it does, when to use, how to use, and behavioral constraints. It is fully sufficient for an agent to invoke the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the fresh parameter's cache behavior and emphasizing 'fresh=false' for reuse, which is not fully covered in schema. The url parameter's public constraint is reinforced.

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 returns 'bounded llms.txt text' for public HTTP(S) resources, specifying the exact resource and action. It also differentiates from other web.site tools by stating it does not execute JavaScript or bypass access controls.

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 guidance on when to use (public HTTP(S) URLs), what it does not do (no JS, no access control bypass), and how to use (absolute URL, fresh parameter usage). It effectively distinguishes from siblings handling other file types like robots.txt.

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, non-destructive behavior. The description adds meaningful behavioral context by noting the tool does not execute JavaScript or bypass access controls, and that results are 'bounded' (likely cached). 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 concise and front-loaded with the purpose, followed by usage constraints and parameter guidance. Four sentences, no fluff. Minor redundancy with schema details prevents a perfect score.

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 exists), the description covers the main use case, constraints, and caching behavior. It lacks a precise definition of 'bounded' but this is minor. Overall complete enough for an agent to invoke correctly.

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

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

Schema coverage is 100% and the schema already thoroughly describes both parameters, including SSRF protections for url and cache semantics for fresh. The description largely reiterates this information ('Pass url as an absolute public HTTP(S) URL', 'Keep fresh=false to allow cache reuse'), adding no significant new meaning.

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

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

The description uses a specific verb ('Discover') with a clear resource ('bounded OpenAPI candidate links') and scope ('declared by the requested page'). This distinguishes it from sibling tools like web.site.sitemaps or web.site.robots, which target different link types.

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

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

Provides explicit usage constraints: 'Use only for public HTTP(S) resources' and clarifies it 'does not execute JavaScript or bypass access controls.' Also gives guidance on the fresh parameter (cache reuse vs. new fetch). However, it does not explicitly mention alternative tools for cases where JavaScript execution is required.

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

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

With annotations already marking readOnlyHint and idempotentHint, the description adds valuable context: it notes the tool does not execute JavaScript or bypass access controls, and explains cache behavior with the fresh flag. 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?

Three short sentences immediately lead with the purpose and then cover constraints and parameter usage. There is no redundant fluff; every clause adds information.

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

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

For a simple two-parameter read tool with rich annotations and an output schema, the description covers the core behavior, safety guarantees, and parameter usage. It doesn't need to explain return values because an output schema exists.

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 already documents all parameters with high coverage, so the baseline is 3. The description reinforces the schema by stating 'Pass url as an absolute public HTTP(S) URL' and adds practical advice on when to set fresh=true versus false, slightly elevating its contribution.

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 'Report the robots.txt policy decision applied to the requested URL,' specifying a clear verb and resource (robots.txt policy) and distinguishing it from sibling site tools like web.site.sitemaps. This makes the tool's purpose unambiguous.

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

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

It explicitly limits usage to public HTTP(S) resources and notes it does not execute JavaScript or bypass access controls, which helps an agent choose it only for appropriate URLs. It provides parameter-level guidance with the fresh flag, though it doesn't name specific alternative 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?

Even with annotations (readOnly, idempotent, etc.), the description adds significant behavioral detail: the result is 'bounded,' contacts are not followed, JavaScript is not executed, and caching behavior is explained. This goes well beyond the annotations and gives the agent a clear model of side effects and limits.

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

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

The description is very compact: three sentences, front-loaded with the core action, then constraints and parameter guidance. No filler or redundancy. Every sentence contributes.

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, the presence of an output schema, and strong annotations, this description is fully complete. It covers purpose, constraints, and both parameters' intended usage with no gaps.

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

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

Schema coverage is 100%, providing baseline 3. The description adds value by explaining the semantic difference of 'fresh=false' (cache reuse) vs 'fresh=true' (new upstream fetch), which is not obvious from the schema's type/default. This nudges the score to 4.

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 resource ('public security.txt text'), and includes a key differentiator: 'without following contacts.' This clearly distinguishes it from sibling tools like web.site.robots or web.site.sitemaps.

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

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

Explicitly states constraints: 'Use only for public HTTP(S) resources' and lists two limitations (no JavaScript, no access control bypass). Also provides clear guidance on the 'fresh' parameter. However, it does not name an alternative tool, so it stops short of a full 5.

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

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

Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds valuable context beyond those: it does not execute JavaScript, does not bypass access controls, returns a bounded cached result, and caps output at five links. These behavioral traits are not derivable from annotations alone and help set accurate expectations.

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

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

Three concise sentences carry the full message without fluff. The main purpose is front-loaded, and every sentence adds distinct value: function, constraints, and cache guidance. No redundant information.

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

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

The tool has a simple 2-parameter surface, a rich schema, comprehensive annotations, and an output schema. The description covers all necessary operational context: what it does, URL constraints, JS/access control limitations, cache behavior, and the optional fresh flag. Nothing essential is missing.

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

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

Schema coverage is 100% and parameter descriptions are already detailed, which gives a baseline of 3. The description adds a bit of extra meaning by explaining that 'up to five sitemap links declared by the requested page' and reinforcing the public URL requirement. However, most of the fresh parameter semantics are mirrored from the schema, so it only slightly exceeds the baseline.

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

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

The description opens with a specific verb and resource: 'Discover up to five sitemap links declared by the requested page.' This clearly states the tool's function, scope, and output limit. It differentiates from sibling tools like web.site.robots or web.site.feeds by focusing exclusively on sitemap discovery, while also noting the public HTTP(S) requirement.

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

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

It explicitly instructs to use only for public HTTP(S) resources and states limitations: 'does not execute JavaScript or bypass access controls.' It also provides clear guidance on the fresh parameter: 'Keep fresh=false to allow cache reuse; set fresh=true only when a new upstream fetch is required.' This tells the agent when and how to use the tool versus alternatives.

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

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

Annotations already declare read-only, idempotent, and non-destructive traits. The description adds that results are heuristic, no JS execution or access bypass, and cache behavior—adding value 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?

Three sentences, each providing essential information. No wasted words, purpose is front-loaded.

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

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

With two parameters and an existing output schema, the description covers all necessary aspects: purpose, constraints, parameter guidance, and behavioral notes.

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

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

Schema description coverage is 100%, but the description adds practical usage: 'Pass url as an absolute public HTTP(S) URL' and explains the fresh parameter's cache behavior beyond the schema's description.

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

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

The description opens with 'Report heuristic authentication, paywall and JavaScript access flags,' clearly stating the verb and resource. It differentiates from numerous URL-related siblings by focusing on access flags.

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

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

Explicitly instructs to use only for public HTTP(S) resources, notes it does not execute JavaScript or bypass access controls, and provides guidance on the fresh parameter. No explicit alternatives to sibling tools, 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?

Beyond annotations (readOnly, idempotent, non-destructive), the description discloses behavioral traits: bounded static checks, no JavaScript execution, no access control bypass, and cache reuse behavior via the fresh parameter. This adds meaningful context regarding what the tool does and doesn't do.

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

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

Three sentences, front-loaded with purpose, then constraints, then parameter usage. Every sentence provides necessary information with no repetition 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?

With an output schema present, return values need no explanation. The description covers purpose, usage constraints, and parameter behavior sufficiently. It doesn't specify what specific accessibility checks are performed, but that is likely detailed in the output schema or result, so the context 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?

Schema coverage is 100%, so the baseline is 3. The description's parameter guidance ('Pass url as an absolute public HTTP(S) URL', 'Keep fresh=false to allow cache reuse') largely reiterates what the schema already states, adding minimal extra semantic value.

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

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

The description opens with a specific verb+resource: 'Run bounded static HTML accessibility checks without a browser.' It clearly distinguishes the tool from siblings like web.url.extract or web.url.performance by emphasizing static HTML, no browser, and public HTTP(S) scope.

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

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

It provides clear usage context: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' This sets boundaries but does not explicitly name alternative tools for dynamic or protected content, though it implies them.

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

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

Beyond the comprehensive annotations (readOnlyHint, idempotentHint, openWorldHint, destructiveHint), the description adds important behavioral details: does not execute JavaScript, restricts to public URLs, rejects SSRF-sensitive destinations, and clarifies cache behavior with 'fresh'. No contradictions.

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

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

Three concise sentences, no wasted words. First sentence states core purpose, second clarifies scope, third gives parameter guidance. Information is front-loaded and easy to parse.

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

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

Given the tool's low complexity (2 params, no nested objects), rich annotations, and existence of output schema, the description completely covers all usage aspects: input constraints, cache behavior, and limitations. No gaps remain.

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

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

Schema description coverage is 100% with both parameters documented. The description adds value by explaining the 'fresh' parameter's cost implications ('cheaper for the origin') and reiterating URL requirements, which improves agent understanding beyond the schema.

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

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

The description clearly states 'Resolve requested, final and declared canonical URLs with evidence', specifying the exact verb and resource. The title 'Url Canonical' and the unique function among siblings (canonicalization vs other URL features) make purpose unambiguous.

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

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

The description provides explicit usage instructions: 'Use only for public HTTP(S) resources', notes limitations (no JavaScript, no access control bypass), and explains when to set 'fresh' parameter. It lacks explicit references to sibling alternatives but sufficiently guides correct invocation.

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

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

Given annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false), the description adds significant value by explaining the baseline creation, caching behavior, and that JS is not executed. It thoroughly discloses side effects and state changes.

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

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

Three sentences with no fluff: first sentence defines purpose, second clarifies JS and url requirements, third gives caching advice. Every sentence earns its place and is front-loaded with key information.

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

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

With an output schema present, return values are covered. The description covers main functionality, parameter usage, and behavioral notes. Minor gaps include not mentioning SSRF rejection or error cases, but these are in the schema.

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

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

Schema coverage is 100% with descriptions for both parameters. The description reinforces the schema by clarifying url requirements and the caching role of fresh. It provides contextual guidance beyond what the schema alone offers.

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 it compares a URL with a stored hash to detect changes, creates a baseline on first use, and returns hashes with timestamps. This specific verb+resource distinguishes it from sibling tools like web.url.hash or web.url.diff.

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

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

The description explains when to use fresh=false (reuse cache) and fresh=true (new fetch), and notes that JavaScript is not executed. It lacks explicit comparison to alternatives but provides clear parameter 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 readOnly, idempotent, and non-destructive, so the description's addition of 'does not execute JavaScript or bypass access controls' and cache-related behavior ('Keep fresh=false to allow cache reuse') exceeds the annotation baseline. This gives the agent useful constraints beyond the structured fields.

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 three short sentences, each earning its place: the first defines the action, the second sets boundary conditions, the third explains parameter usage. No filler 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?

With 2 parameters, full schema documentation, and an output schema present, the description sufficiently covers purpose, constraints, and parameter behavior. It does not need to explain return values because the output schema exists, and it gives enough context to distinguish this from sibling URL tools.

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

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

Schema coverage is 100% and already describes both 'url' and 'fresh' in detail. The description restates these constraints rather than adding new meaning, though it subtly reinforces the 'public' and 'new upstream fetch' concepts. Baseline 3 is appropriate when the schema carries the burden.

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 'Extract bounded citation and reference links with visible labels,' which is a specific verb-resource pairing that clearly differentiates this tool from siblings like web.url.links or web.url.extract. The qualifiers 'bounded' and 'with visible labels' add distinctive scope.

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

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

It provides clear operational context: 'Use only for public HTTP(S) resources' and 'does not execute JavaScript or bypass access controls,' plus explicit guidance on the fresh parameter. However, it does not name alternative tools or state when not to use this tool, stopping short of a full 5.

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

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

Beyond the read-only/idempotent annotations, the description discloses that the tool is 'deterministic', does not execute JavaScript, does not bypass access controls, and uses caching controlled by the 'fresh' parameter. These are valuable behavioral traits that inform the agent's expectations and usage, exceeding the basic 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 three sentences, front-loaded with the core purpose, followed by limitations and parameter guidance. Every sentence adds value without redundancy or unnecessary detail, achieving excellent conciseness and logical structure.

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 two simple parameters, full schema coverage, and an output schema, the description covers the essential context: purpose, usage constraints, behavioral caveats, and parameter usage. It is complete enough for an agent to select and call the tool correctly without needing additional information.

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 already fully describes both parameters ('url' with format, length, and SSRF rejection; 'fresh' with default and explanation). The description largely restates these details ('Pass url as an absolute public HTTP(S) URL' and 'Keep fresh=false...'), adding no new semantic meaning beyond what the schema provides.

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

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

The description explicitly states the tool 'Return deterministic thin-content and page-structure quality signals', clearly identifying the specific resource and output. This distinguishes it from sibling tools like web.url.extract or web.url.text, which focus on content extraction rather than quality analysis.

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

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

The description gives clear usage context: 'Use only for public HTTP(S) resources' and 'does not execute JavaScript or bypass access controls', which helps the agent know when not to use it. It also provides guidance on the 'fresh' parameter (set false for cache reuse, true only for new fetch). However, it does not explicitly name alternative tools for JavaScript-dependent or restricted resources, so it falls short of a 5.

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

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

Annotations already indicate read-only, idempotent, safe behavior. The description adds: 'it does not execute JavaScript or bypass access controls' and explains caching with the fresh parameter, providing additional 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?

Two concise sentences. The main purpose is front-loaded, and every sentence adds essential information without 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 fully covers the tool's purpose, usage restrictions, parameter behavior, and is complete given the low complexity and presence of output schema.

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

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

Schema coverage is 100%, with each parameter described. The description adds value by clarifying the fresh parameter's default behavior and caching implications, but the schema already covers the basics.

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

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

The description clearly states the tool's purpose: 'Classify MIME type, charset and bounded content length.' It also distinguishes itself from sibling tools by specifying it works only on public HTTP(S) resources and does not execute JavaScript or bypass access controls.

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?

Explicit usage guidelines: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls. Pass url as an absolute public HTTP(S) URL. Keep fresh=false to allow cache reuse; set fresh=true only when a new upstream fetch is required.' This covers when to use, when not, and parameter-specific advice.

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?

This description discloses several behavioral traits beyond the annotations: it reveals the existence of a stored snapshot (state), explains caching behavior ('allow cache reuse'), and states a clear limitation ('does not execute JavaScript or bypass access controls'). With annotations that only hint at side effects and external calls, the description adds substantial context about how the tool operates.

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

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

The description is concise at four sentences, with the main purpose front-loaded and no filler. Every sentence contributes either core purpose, constraints, or parameter guidance. It is efficient 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?

Given the tool's moderate complexity (2 params, 1 required) and the presence of an output schema, the description is complete. It covers purpose, constraints, and parameter usage. The output schema handles return value details, so nothing additional is needed.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's parameter guidance ('Pass url as an absolute public HTTP(S) URL' and 'Keep fresh=false to allow cache reuse') largely repeats what the schema already says (pattern and descriptions). It adds minimal value beyond the schema, so a 3 is appropriate.

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

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

The description clearly states a specific action and resource: 'Compare the normalized content hash with the previous stored snapshot.' This unambiguously distinguishes the tool from related siblings like web.url.hash (which likely just computes a hash) or web.url.changed (which may detect changes differently). The verb 'compare' and the reference to a 'stored snapshot' make the purpose fully understandable.

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

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

The description provides explicit when-not guidance: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' It also gives parameter usage advice (fresh=false vs true). However, it does not name alternative tools or explicitly state 'use X when you need Y,' so it falls just short of a 5.

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

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

The description adds significant behavioral context beyond annotations: JavaScript is not executed, output size and fetch time are bounded, and returns specific fields like title, author, publication time, language, content hash, truncation and cache state. No contradiction with annotations (readOnlyHint, idempotentHint, etc.).

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

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

Four sentences, front-loaded with purpose, followed by return value summary and concise parameter guidance. Every sentence serves a clear purpose without redundancy or verbosity.

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 comprehensive annotations, the description covers all essential aspects: what the tool does, its constraints (no JS, bounded output), and parameter behavior. It is fully adequate for correct tool selection and invocation.

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

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

Schema description coverage is 100%, baseline 3. Description adds value by clarifying usage of include_links ('only when needed') and fresh ('reuse cache'). While url is well-documented, the extra nuance for boolean parameters lifts the score above baseline.

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 extracts normalized main text and optional links from public HTTP/HTTPS documents. It uses specific verb and resource, and distinguishes from sibling tools like web.url.text (raw text) or web.url.links (just links) by mentioning 'normalized main text' and optional links.

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

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

The description gives specific guidance on parameter usage ('Set include_links=true only when normalized links are needed', 'Keep fresh=false to reuse cache'), but does not explicitly state when to use this tool over alternatives or when not to use it. It lacks explicit differentiation from similar 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 readOnly, idempotent, and non-destructive behavior. The description reinforces this and adds value by clarifying that JavaScript is not executed and access controls are not bypassed. No contradictions.

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?

Extremely concise: two sentences that convey purpose, constraints, and parameter usage. No redundant words. Front-loaded with the core action.

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 comprehensive annotations, the description provides sufficient context for a hash computation tool. The term 'versioned' is not elaborated, but that detail is likely covered in the output.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds practical usage context: for url, emphasizes it must be an absolute public HTTP(S) URL; for fresh, explains cost implications. This goes beyond 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 starts with 'Compute a versioned SHA-256 of normalized content,' providing a specific verb and resource. It clearly distinguishes itself from sibling tools like web.url.extract or web.url.content_type by focusing on hashing.

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

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

Explicitly states when to use ('only for public HTTP(S) resources') and when not ('does not execute JavaScript or bypass access controls'). Provides clear guidance on the fresh parameter, recommending false for cache reuse and true only when required.

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, non-destructive. Description adds valuable context: it does not execute JavaScript or bypass access controls, and it returns only allowlisted headers, implying some filtering. No contradictions 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?

Three concise sentences: one for purpose, one for usage constraints, one for fresh parameter. Every sentence adds value with no 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?

Given the tool's simplicity, output schema existence, and annotation coverage, the description provides all necessary information (purpose, constraints, parameter guidance). No gaps identified.

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 covers both parameters (100%). Description adds meaningful usage guidance for the 'fresh' parameter, explaining cache reuse and cost implications, which goes beyond the schema's technical description.

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

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

The description clearly states the tool returns allowlisted response headers for public URLs. It distinguishes itself from many sibling url tools by specifying it returns only headers and is limited to public resources, but does not explicitly compare with similar tools like web.url.security_headers.

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

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

Provides guidance on using for public HTTP(S) resources only, not executing JS or bypassing access controls. Explains when to set fresh=true versus false. However, it does not explicitly tell when to choose this tool over other url header-related siblings.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds critical behavioral context: 'it does not execute JavaScript or bypass access controls' and explains caching behavior with 'bounded cached result' and 'cheaper for the origin.' 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?

Two sentences: first states primary function, second covers usage constraints and parameter guidance. No wasted words; every sentence earns its place.

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

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

Given the tool's simplicity (2 params, output schema present), the description covers purpose, usage constraints, parameter semantics, and behavioral notes. There is no gap; it is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100% with descriptions. The tool description adds further value: for url, it clarifies restrictions on private/SSRF-sensitive destinations; for fresh, it explains caching trade-offs. This goes beyond the 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 'Return the bounded heading hierarchy from h1 through h6' which is a specific verb+resource. It distinguishes from sibling tools like web.url.text or web.url.links by focusing solely on headings.

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

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

The description gives explicit usage constraints: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' It also guides parameter usage with 'Keep fresh=false to allow cache reuse; set fresh=true only when a new upstream fetch is required.' It does not list alternatives but the purpose is clear enough.

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

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

Discloses limit of 100 references, no-download behavior, no JS execution, and caching policy; all consistent with annotations (readOnlyHint, idempotentHint) and adds useful context beyond 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?

Two sentences, each earning its place: first states core purpose, second adds usage restrictions and parameter guidance. No wasted words.

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

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

Fully covers purpose, usage, parameter behavior, and constraints for a simple tool; no output schema needed per rules, and all key aspects are addressed.

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 100% schema coverage, description adds value by providing concrete caching advice ('fresh=false to allow cache reuse') and confirming URL must be absolute public HTTP(S) URL, complementing the schema's pattern and examples.

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 it lists image references (up to 100) without downloading them, distinguishing it from other URL inspection tools like web.url.links or web.url.extract.

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

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

Explicitly restricts usage to public HTTP(S) resources, states it does not execute JavaScript or bypass access controls, and provides guidance on caching behavior with fresh parameter.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds that no JavaScript is executed and no access controls are bypassed, providing specific behavioral 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 two sentences, no wordiness, and front-loads the core action. Every sentence provides essential information, earning its place.

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

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

With an output schema present, return value explanation is unnecessary. The description covers purpose, usage guidelines, and parameter semantics adequately. Minor omission: could mention that JSON-LD blocks are typically in script tags, but still complete.

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

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

Schema coverage is 100%, and the description enriches the schema by clarifying that url must be an absolute public HTTP(S) URL and explaining the caching behavior of the fresh parameter, adding value beyond the 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 extracts bounded JSON-LD blocks without executing scripts, which is a specific verb and resource. This distinguishes it from sibling tools like web.url.text or web.url.links that extract other content types.

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 specifies the tool is for public HTTP(S) resources only and notes it does not execute JavaScript or bypass access controls. It also advises on the fresh parameter, but does not explicitly compare to alternatives like web.url.extract for general extraction.

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, etc. Description adds meaningful context: no JavaScript execution, no access control bypass, and cache reuse behavior. No contradictions 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?

Two concise sentences. First sentence states purpose. Second covers constraints and parameter guidance. No extraneous information. Front-loaded with key action.

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 output schema exists, return values need no explanation. Tool has only two parameters, both fully addressed. Description covers purpose, usage constraints, parameter semantics comprehensively 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?

Schema describes both parameters fully (100% coverage). Description adds practical semantics: instructs to pass absolute public HTTP(S) URL, and explains when to use fresh=true/false. This goes beyond 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 it reports both declared and heuristically detected document language. The verb 'report' and resource 'document language' are specific. Among siblings like web.url.content_type and web.url.metadata, this tool's focus on language detection is distinctly conveyed.

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

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

Explicitly says 'Use only for public HTTP(S) resources' and clarifies it does not execute JavaScript or bypass access controls. Provides guidance on fresh parameter (cache behavior). Does not explicitly mention alternative tools for language detection, but 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?

The description adds behavioral details beyond annotations: normalization, safe link extraction, no JavaScript execution, cache behavior ('fresh=false to allow cache reuse'). It aligns with all annotations (readOnly, idempotent, non-destructive).

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

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

Two concise sentences that front-load the primary action and essential constraints. No redundant or unnecessary information.

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

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

Given the simple tool (2 parameters, robust annotations, output schema exists), the description covers the core functionality, constraints, and parameter usage adequately.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying the 'url' must be absolute public HTTP(S) and explaining 'fresh' trade-offs ('cheaper for the origin').

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 'Extract' and the resource 'links from a URL', specifying the limit 'up to 200 normalized safe links'. It distinguishes from siblings by focusing on link extraction.

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

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

Provides explicit usage constraints: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' Also advises on the 'fresh' parameter. However, it does not explicitly name alternative tools for other purposes.

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. The description adds meaningful behavioral disclosure beyond annotations: it does not execute JavaScript or bypass access controls, and it explains cache behavior with the fresh flag. This provides context that annotations do not cover.

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 three concise sentences, front-loaded with the core purpose, followed by constraints and parameter guidance. Every sentence adds value; there is no fluff or repetition beyond reinforcing the schema, which is acceptable for emphasis.

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, an output schema exists (covering return values), and annotations cover safety properties, the description is complete. It covers usage scope, constraints, and the freshness parameter. It could have explicitly mentioned that SSRF-sensitive destinations are rejected, but the schema already includes that, so it's not a gap in description 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 100%, so the baseline is 3. The description repeats the url requirement (absolute public HTTP(S) URL) and the fresh parameter semantics, but adds little beyond what the schema already documents. It reinforces key usage but doesn't introduce new semantic 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 clearly states the tool inspects hreflang, canonical, and declared-language coherence on a given URL. This specific verb+resource+scope distinguishes it from sibling tools like web.url.language or web.url.canonical, which focus on individual aspects rather than coherence.

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

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

The description explicitly restricts usage to public HTTP(S) resources and notes that it does not execute JavaScript or bypass access controls, giving clear exclusions. It also provides guidance on the fresh parameter (keep false for cache reuse, true only for new upstream fetch). It doesn't explicitly mention alternative tools, but the constraints and freshness instructions provide solid usage context.

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

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

Annotations already indicate read-only and idempotent behavior. Description adds 'does not execute JavaScript or bypass access controls' and mentions 'bounded' result, providing context beyond annotations without 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?

Three concise sentences: purpose, constraint, parameter guidance. No unnecessary words or repetition. Efficient and front-loaded.

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

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

With output schema present, return values are not needed. Description covers purpose, constraints, and parameter advice. Could elaborate on 'bounded' but lacking detail does not hinder basic usage.

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

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

Schema coverage is 100%, so parameters are fully documented. Description repeats the fresh parameter usage but adds no new meaning; baseline score 3 applies.

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

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

The description clearly states the tool converts HTML to bounded Markdown, with specific verb 'Convert' and resource 'readable HTML content'. It distinguishes from sibling tools like web.url.text or web.url.extract by emphasizing Markdown output.

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

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

Provides clear constraints: only for public HTTP(S) resources, no JavaScript, no access control bypass. Also advises on using fresh parameter for caching. Lacks explicit comparison to siblings, but purpose is sufficiently specific.

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?

Discloses non-execution of JS, no access control bypass, and caching behavior. Annotations already indicate read-only, idempotent, and non-destructive; description adds useful contextual limits without 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?

Three concise sentences, front-loaded with the tool's output and key constraints. No wasted words.

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

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

Given the output schema exists, the description need not detail return values. It sufficiently covers usage constraints and parameter guidance for a tool with many siblings.

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

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

Schema provides full descriptions for both parameters (url pattern, fresh default). Description only reiterates cache behavior for fresh, adding minimal value beyond what the schema already states.

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

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

Description clearly lists extracted fields (title, description, author, dates, canonical) and states the tool is for public HTTP(S) resources, distinguishing it from siblings that extract other types of content.

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

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

Explicitly states to use only for public HTTP(S) resources and notes it does not execute JavaScript or bypass access controls. Provides guidance on the fresh parameter (cache reuse vs. new fetch). Lacks explicit comparison to siblings but 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 indicate read-only, idempotent, open-world behavior. The description adds valuable details beyond annotations: a bound of eight external HTTP requests, no JavaScript execution, and caching behavior. It also integrates SSRF protection from the schema. No contradictions.

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 two sentences: first defines purpose and contents, second explains constraints and caching. No fluff, information-dense, and front-loaded. Every sentence 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?

Given rich annotations, an output schema, and clear listing of included features, the description is nearly complete. It covers purpose, behavioral constraints, caching, and SSRF. The only minor gap is the lack of explicit guidance for selecting this tool over siblings, but that is already accounted in usage_guidelines.

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?

Both parameters have descriptive schema comments covering meaning and constraints. The description restates the fresh parameter's caching advice but adds no new semantic information beyond the schema. Baseline 3 is appropriate given 100% schema coverage.

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

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

The description clearly states the tool's purpose: inspect a public HTTP/HTTPS URL and return a structured site passport. It lists specific content types (pulse fields, registrable domain, robots, sitemap, feeds, OpenAPI hints, page metadata), distinguishing it from siblings that focus on individual 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?

While the description gives usage tips for the 'fresh' parameter and mentions efficiency (8 requests, no JS), it does not explicitly guide when to use this tool versus its many siblings (e.g., web.url.pulse, web.site.robots). A sentence like 'Use for a comprehensive site overview; for specific data see related tools' would improve it.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavioral context beyond that: it explicitly states the tool is safe, does not execute JS, does not bypass access controls, and explains cache-reuse behavior and the fresh parameter's impact. 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?

Three sentences, information-dense and front-loaded with the core purpose, followed by constraints and parameter guidance. No filler or redundant repetition of schema content; every sentence earns its place.

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

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

For a two-parameter tool with a comprehensive schema and rich annotations, the description covers the essential operational context: what it returns, safety constraints, and parameter usage. An output schema exists, so return format details are not required here. The description is sufficient for correct selection and invocation.

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

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

Schema coverage is 100%, with descriptions for both `url` and `fresh`, so baseline is 3. The description adds extra nuance by reinforcing that `url` must be an absolute public HTTP(S) URL and by explaining the trade-off for `fresh` (cache reuse vs. new upstream fetch), which enhances understanding beyond schema 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 opens with a specific verb ('Return') and resource ('network timing, payload and cacheability diagnostics'), clearly stating what the tool does. It distinguishes itself from siblings like web.url.timing by emphasizing cacheability and payload diagnostics, making its unique scope evident.

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

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

It gives explicit usage constraints: 'Use only for public HTTP(S) resources' and states the tool 'does not execute JavaScript or bypass access controls.' It also provides direct guidance on the `fresh` parameter, specifying when to set it true vs. false, which is actionable and 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 convey read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral context beyond annotations: it does not execute JavaScript or bypass access controls, and it explains the caching behavior tied to the 'fresh' parameter. These details help the agent understand real-world side effects and 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 three sentences, front-loaded with the core purpose. Every sentence adds distinct value: what it assesses, usage constraints/limitations, and parameter-specific caching advice. 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?

Given that an output schema exists, the description covers the essentials: what the tool does, when it can be used (public HTTP(S) only), key behavioral limitations, and caching semantics. This is sufficient for an agent to decide when to invoke the tool and what to expect. No critical information is missing.

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

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

Schema description coverage is 100%, so the description is not required to explain parameters. It does restate the 'url' and 'fresh' guidance, but largely repeats what the schema already says. The only marginal addition is the rationale that fresh=false is 'cheaper for the origin,' but this is also present in the schema's fresh description. Thus the baseline 3 applies.

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

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

The description clearly states the tool assesses CSP, CORS, cross-origin policy, and mixed-content signals, which is a specific verb+resource pairing. This distinguishes it from sibling tools like web.url.headers or web.url.security_headers, and the limitation clause ('does not execute JavaScript or bypass access controls') further disambiguates its scope.

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

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

It provides explicit usage conditions: 'Use only for public HTTP(S) resources' and caching guidance ('Keep fresh=false... set fresh=true only when a new upstream fetch is required'). However, it does not explicitly name alternative tools or state when to prefer this over a sibling, so it lacks the full when/when-not structure of a 5.

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

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

The description adds behavioral context beyond annotations, such as 'Does not execute JavaScript' and mentions cache state and robots policy. It does not contradict 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 efficiently written in three sentences, front-loading the purpose and key behaviors before parameter-specific advice. No extraneous 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 tool's complexity and the presence of an output schema, the description adequately summarizes key return fields and constraints, though it could mention the output schema's structure briefly.

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 100% schema coverage, the description adds value by reinforcing usage patterns for both 'url' and 'fresh', e.g., 'Pass url as an absolute public HTTP(S) URL' and 'Keep fresh=false to reuse cache; set fresh=true only when a new upstream fetch is required.'

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

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

The description clearly states the verb 'check' and resource 'public HTTP or HTTPS URL', and lists the returned information (availability, redirects, content type, etc.), distinguishing it from siblings that focus on specific 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?

It explicitly recommends using this tool 'before expensive browsing or AI processing' and gives practical guidance on the 'fresh' parameter ('Keep fresh=false... set fresh=true only when...'). However, it does not directly compare with sibling tools to help select among them.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. Description adds valuable context: does not execute JavaScript, does not bypass access controls, and uses caching. No contradictions.

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

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

Three sentences, each essential: first defines tool purpose, second specifies constraints, third gives parameter usage. No redundant information, front-loaded with key action.

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 output schema present, description need not detail return format. It explains caching and constraints. Could mention that chunks are deterministic and bounded, but otherwise covers essential context for a read-only, idempotent tool with two parameters.

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

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

Schema coverage is 100%, so baseline is 3. Description adds meaning beyond schema: url must be absolute public HTTP(S) (no private/SSRF), fresh default false encourages cache reuse, fresh=true only when new upstream fetch required. This clarifies usage beyond 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?

Description clearly states the tool splits readable text into deterministic bounded RAG chunks, specifying the resource type (public HTTP/S) and distinguishing it from other url tools that extract markdown or text without chunking.

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

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

Provides clear constraints: use only for public HTTP(S) resources, no JS or access control bypass. Offers guidance on fresh parameter (cache reuse vs forced fetch). Lacks explicit alternatives to differentiate from sibling tools like web.url.text or web.url.markdown, but context from sibling names implies this is for RAG chunking.

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, non-destructive behavior. The description adds safety validation and clarifies that JavaScript is not executed and access controls are not bypassed, providing behavioral 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 concise with three sentences, each adding value: first states core purpose, second gives constraints, third provides parameter guidance. No wasted words.

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

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

Given the tool's simplicity (2 params, no nested objects), output schema exists, and annotations are complete, the description adequately covers all necessary context for an agent to use the tool correctly.

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

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

Schema covers both parameters with detailed descriptions (e.g., url includes SSRF rejection). The description reiterates parameter usage (absolute URL, fresh default) but adds minor contextual advice on when to set fresh=true, which is slightly beyond schema.

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

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

The description clearly states the tool returns the safely validated redirect chain for public HTTP(S) resources. It distinguishes from sibling tools like web.url.status or web.url.headers by specifying redirect chain validation, and mentions it does not execute JavaScript or bypass access controls.

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

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

Explicitly states usage for public HTTP(S) resources only, warns against private or SSRF-sensitive URLs, and provides clear guidance on the fresh parameter (cache reuse vs. new fetch). This helps the agent decide when and how to use the tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond these: the tool does not execute JavaScript, does not bypass access controls, and has a bounded cache mechanism influenced by the fresh parameter. No contradictions exist.

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

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

Three sentences cover purpose, constraints, and parameter usage with zero waste. The description is front-loaded with the core action (validate JSON-LD) and then adds necessary caveats about public access and fresh, each sentence earning its place.

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

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

With annotations, full schema descriptions, an output schema present, and only two parameters, the tool is simple. The description covers key operational nuances (SSRF privacy restrictions implied, cache behavior, no JavaScript execution), making it complete for an agent to decide when and how to invoke 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?

Schema description coverage is 100% for both url and fresh, so the baseline is 3. The description largely mirrors the schema's parameter descriptions (e.g., absolute public URL, fresh cache behavior) without adding substantial new meaning beyond what the schema already provides, so it does not elevate above the baseline.

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

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

The description clearly states the tool validates embedded JSON-LD syntax and required Schema.org identifiers, which is a specific verb and resource. It distinguishes itself from sibling tools like web.url.jsonld (which likely extracts JSON-LD) by emphasizing validation, and the scope is unambiguous.

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

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

Explicit guidance is provided: use only for public HTTP(S) resources, with explicit note that it does not execute JavaScript or bypass access controls. The description also instructs on the fresh parameter (keep fresh=false for cache reuse, fresh=true only when necessary), giving clear context for when and how to use the tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint. Description adds 'does not execute JavaScript or bypass access controls' and 'static evidence', enriching behavioral 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?

Four concise, front-loaded sentences: purpose, usage constraint, parameter advice. Every sentence earns its place; no 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?

Given annotations cover safety, schema covers parameters, and an output schema exists, description is nearly complete. Could list typical headers checked (e.g., CSP, HSTS) but not essential with output schema.

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

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

Schema description coverage is 100%, so baseline is 3. Description essentially restates parameter guidance ('absolute public HTTP(S) URL', 'fresh=false for cache reuse') without adding new meaning beyond schema examples and patterns.

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

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

Description clearly states it assesses common response security headers as static evidence. Distinct from sibling web.url.headers which returns all headers, but does not explicitly name alternatives.

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

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

Provides clear constraints: only for public HTTP(S) resources, no JavaScript execution, no access control bypass. Gives caching advice for fresh parameter. Does not contrast with sibling tools but covers when to use cache vs fresh.

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?

Description adds context beyond annotations: it does not execute JavaScript or bypass access controls, and clarifies cache behavior. Annotations (readOnlyHint, idempotentHint, etc.) already indicate safety, but the description elaborates on specific behaviors that matter for selection.

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

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

Three sentences, each serving a distinct purpose: purpose/scope, constraints, parameter guidance. No fluff. Front-loaded with the main function.

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

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

Given the tool's complexity (simple extraction with two parameters) and presence of output schema, the description sufficiently covers purpose, constraints, and usage. No need to describe return values since output schema exists.

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

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

Schema coverage is 100% with descriptions for both parameters. Description adds extra context: url must be absolute public HTTP(S) and rejects private destinations; fresh=false allows cache reuse while fresh=true forces new fetch. This adds meaning beyond the 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?

Description clearly states it extracts bounded Open Graph and Twitter Card fields. The verb 'Extract bounded' and specific resource 'Open Graph and Twitter Card fields' distinguishes it from sibling tools like web.url.metadata which may extract all metadata. No ambiguity.

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

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

Explicitly states to use only for public HTTP(S) resources and provides conditions for the 'fresh' parameter. Implicitly advises against using for internal resources. No explicit sibling alternatives but given the context of many sibling tools, the bounded nature makes usage 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 indicate readOnly, openWorld, idempotent, and non-destructive. The description adds behavioral context: no JavaScript execution, no access control bypass, caching behavior via 'fresh' parameter, and that it returns the final URL. This adds value 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 three sentences, front-loaded with purpose. Every sentence is informative without redundancy. No filler or 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 description covers key behavioral aspects (caching, restrictions) and the output schema exists, so return values are documented elsewhere. Missing details like error handling or rate limits, but the tool is simple enough that it's adequate.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description largely repeats schema info (e.g., url must be public, fresh caching). It adds little new meaning beyond what the schema provides.

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 ('Check') and clearly identifies the resource ('HTTP reachability, status and final URL'). It distinguishes from sibling tools like web.url.text or web.url.content_type by focusing on basic reachability and status, not detailed content extraction.

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

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

The description provides explicit usage constraints ('Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls') and guidance on the 'fresh' parameter. However, it does not explicitly name alternative sibling tools for different use cases.

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

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

Beyond annotations (readOnlyHint=true, idempotentHint=true), the description adds behavioral context: it does not execute JavaScript, does not bypass access controls, and explains cache reuse behavior via the fresh parameter. This enriches the agent's understanding of side-effect-free behavior and limits.

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

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

Three sentences cover function, usage constraints, and parameter guidance without filler. The most important information is front-loaded, making it efficient for an agent to parse.

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

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

For a two-parameter, read-only tool with an output schema, the description sufficiently covers purpose, constraints, and parameter behavior. It does not need to explain return values since the output schema exists.

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

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

Schema coverage is 100% and both url and fresh are already thoroughly documented in the input schema (including SSRF rejection and cache semantics). The description adds minimal new meaning beyond restating the same guidance for fresh, so it meets the baseline rather than exceeding it.

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

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

The description clearly states the tool extracts bounded HTML tables into machine-readable rows, using a specific verb and resource. It distinguishes itself from sibling URL content extractors (markdown, text, headings) by its focus on tables.

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

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

It explicitly states to use only for public HTTP(S) resources, notes that JavaScript is not executed and access controls are not bypassed, and gives concrete guidance on the fresh parameter (when to set true vs false). This provides clear selection and usage context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds the crucial behavioral limitation that it does not execute JavaScript or bypass access controls, which is not inferable from annotations. This gives concrete operational context beyond the schema.

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

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

Three sentences, each earning its place: purpose, usage constraint, and parameter guidance. No fluff, front-loaded verb, and the key operational detail about JavaScript is placed early. Excellent concise structure.

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 output schema present and only two simple parameters, the description covers purpose, boundaries, and parameter behavior. The read-only, idempotent nature is already captured by annotations, so no additional disclosure is needed. The tool is fully specified 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 coverage is 100%, so baseline is 3. The description repeats the schema's 'absolute public HTTP(S) URL' and fresh/cache guidance, adding no new meaning beyond what the schema already specifies. It does reinforce the public/resource constraint, but the marginal value 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 opens with a specific verb and resource: 'Report evidence-backed framework, CMS and generator signals.' This clearly distinguishes it from sibling tools like web.url.headers or web.url.links, which address different signals. The scope is unambiguous.

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

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

Usage guidance is explicit: 'Use only for public HTTP(S) resources' and 'does not execute JavaScript or bypass access controls' sets a clear boundary. The fresh parameter behavior is explained, though it does not explicitly compare to alternative tools. Still, the context is sufficient for selection.

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