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

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds that the tool does not fetch a URL or require payment, and returns up to five results, adding valuable behavioral context.

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

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

The description is two sentences with no wasted words, front-loaded with the critical usage instruction 'Start here', making it efficient and clear.

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

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

Given the simple single-parameter tool and existence of an output schema, the description fully covers purpose, usage, behavior, and return summary, making it 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% with a well-described query parameter including examples and a length constraint. The description also explains what the tool returns, adding meaning 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 verb 'search' and resource 'local 1cent catalog', and distinguishes this tool from the many URL-specific sibling tools by positioning it as a starting point before paid operations.

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

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

Explicitly says 'Start here before choosing a paid operation' and 'without fetching a URL or requiring payment', providing clear when-to-use guidance and implying not to use for direct URL checks.

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. Description adds SSRF-protected, rate-limited, preserves cache/audit behavior. 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?

Two sentences, front-loaded with purpose, no waste. Each 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 output schema exists and annotations are rich, description covers purpose, constraints, and behavior adequately for a simple demo 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?

No parameters; schema coverage 100%. Description clarifies 'accepts no URL', adding meaning beyond schema. Baseline for 0 params is 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?

Clear verb 'run' and specific resource 'fixed https://example.com/ target'. Distinguishes from sibling tools like url_pulse and demo_url_pulse by noting it's a free demo against a fixed target.

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

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

States 'free demo' and 'no payment', implying use for testing. Mentions rate limiting. Does not explicitly state when not to use, but context implies not for arbitrary URLs.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds that it is a 'fixed demonstration' that 'never fetches an external resource', 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?

Two sentences, no wasted words. The first sentence states the purpose, the second clarifies key constraints. Optimal length for the tool's simplicity.

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 demo tool with no parameters and an output schema, the description completely explains what it does and its limitations. No missing 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?

With zero parameters and 100% schema coverage, the baseline is 4. The description adds value by explaining that the tool does not accept any inputs and never accepts a URL, reinforcing the no-parameter behavior.

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

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

The description clearly states this tool returns a 'precomputed example of 1cent URL Pulse output' without payment or network requests, and explicitly says it 'never accepts a URL'. This distinguishes it from siblings like 'url_pulse' and 'demo_live_url_pulse'.

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

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

The description implies usage for previewing a sample result without actual execution, but does not explicitly state when to use vs alternatives or when not to use. The fixed demo nature is clear from 'Free demo' and 'never accepts a URL'.

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 it does not execute JavaScript or bypass access controls, and explains caching behavior, which is useful context beyond the annotations.

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

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

Concise, front-loaded with the primary purpose, and every sentence adds value. No 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?

The description covers purpose, constraints, and usage guidelines adequately for a simple tool with two parameters and an output schema. It is complete enough for an agent to use 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 already provides detailed descriptions for both parameters (100% coverage). The description adds no new parameter semantics beyond what the schema 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 the tool discovers RSS and Atom feeds for public HTTP(S) resources. It differentiates from sibling tools like site_robots or site_sitemaps by its specific focus on feeds.

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 guidance on when to use (public HTTP(S) resources only) and how to use (pass absolute URL, set fresh accordingly). However, it does not explicitly list alternatives or when not to use.

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

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

Discloses key behaviors: no JavaScript execution, no access control bypass, and cache reuse via the 'fresh' parameter. Annotations already indicate read-only and idempotent, but the description adds valuable context about caching and security constraints, exceeding what annotations provide.

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

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

The description is three sentences, each serving a distinct purpose: stating the core function, specifying constraints, and providing parameter usage advice. It is front-loaded with the main action and contains no superfluous 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 parameters, boolean fresh, output schema exists), the description covers all necessary aspects: what it returns, when to use it, parameter semantics, and behavioral constraints. The presence of an output schema removes the need to detail return values.

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 tool description adds practical guidance on how to use the parameters, such as 'Pass url as an absolute public HTTP(S) URL' and when to set 'fresh=true', which adds value 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 returns 'bounded llms.txt text when publicly available,' which is a specific verb-resource pair. It distinguishes itself from sibling tools like url_text or site_robots by targeting a specific file format (llms.txt).

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'), what it does not do ('does not execute JavaScript or bypass access controls'), and provides clear guidance on the 'fresh' parameter (when to set true/false). This helps the agent decide between this tool and 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 readOnlyHint, idempotentHint, and non-destructive. The description adds critical behavioral details: no JavaScript execution, no access control bypass, and cache reuse behavior. This complements annotations well.

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 purpose and include necessary usage constraints. Every sentence adds value, 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 presence of an output schema and full parameter description coverage, the description is complete. It clearly defines the tool's scope and constraints, and the sibling context shows specialisation. 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% with descriptions for both parameters. The description adds practical usage advice: 'Pass url as an absolute public HTTP(S) URL' and caching guidance for 'fresh'. This provides more context than 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 states the tool discovers and summarizes bounded public OpenAPI documents, clearly distinguishing it from sibling URL tools that handle general web content. The verb 'discover and summarize' and resource 'OpenAPI documents' are specific.

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 use to public HTTP(S) resources, notes that it doesn't execute JavaScript or bypass access controls, and provides guidance on the 'fresh' parameter. It does not directly name alternatives but the context of OpenAPI documents implies when not to use this tool (e.g., non-OpenAPI content).

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, destructiveHint. Description adds valuable context: no JavaScript execution, no access control bypass, and caching behavior with fresh parameter. 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?

Two concise sentences with front-loaded key information. Every sentence adds value with no redundancy or fluff.

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

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

Given output schema exists, parameters are fully documented, and annotations cover safety traits, the description provides sufficient additional context (caching, restrictions, no JS) for complete understanding.

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

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

Schema coverage is 100% with descriptions for both parameters. The description reinforces url requirement and adds guidance on fresh parameter usage, enhancing 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?

Description clearly states 'Fetch and parse the origin robots.txt policy', specifying the resource and action. This is distinct from sibling tools like site_sitemaps or url_status, making the 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?

Provides explicit context: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' Also advises on fresh parameter usage. However, it does not explicitly mention when not to use this tool or name alternative tools for other 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?

Annotations already indicate readOnly, idempotent, openWorld, and non-destructive traits. The description adds valuable transparency: it does not follow contacts, does not execute JS, and uses a bounded cache when fresh=false. This goes beyond the 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?

Two sentences, no wasted words. First sentence states core purpose and limitation. Second sentence covers usage for both parameters. The call to action and rationale are front-loaded, making it immediately scannable.

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

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

Given an existing output schema, the description covers all necessary aspects: purpose, usage constraints, parameter semantics, and behavioral traits. No gaps for a straightforward parse tool. Fresh parameter guidance adds operational 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 covers 100% of parameters. The description adds meaning: for 'url', it reinforces 'absolute public HTTP(S)' and implies validation (SSRF rejection is in schema but not restated). For 'fresh', it explains the caching trade-off more clearly than the schema's description, elevating from baseline 3.

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

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

The description uses the verb 'Parse' with resource 'public security.txt fields', clearly distinguishing this tool from siblings like site_robots or url_metadata. It also adds a key constraint ('without following contacts'), making the 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 context for use: 'Use only for public HTTP(S) resources' and clarifies limitations (no JS, no access control bypass). It offers guidance on the fresh parameter with concrete cache reuse advice. However, it does not contrast with sibling tools for when not to use.

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

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

Beyond annotations declaring readOnly and idempotent, the description reveals limits (up to five sitemaps, bounded), no JavaScript execution, and caching behavior, adding significant context.

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

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

Two well-structured 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?

Covers scope, caching, and access limitations; given output schema exists, return details are not needed. Could mention empty result behavior but not critical.

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 reinforces and adds usage guidance for the fresh parameter (cache reuse vs new fetch), providing extra meaning beyond schema defaults.

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 discovers up to five bounded sitemap resources for public HTTP(S) only, distinguishing it from siblings that may handle private resources or execute JavaScript.

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 instructions to use only for public HTTP(S) resources and when to set fresh=true vs false, but does not explicitly suggest alternative tools for other 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?

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds context about non-execution of JavaScript, no bypass of access controls, and caching behavior, which goes beyond the annotations. No contradiction.

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

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

The description is four sentences, each serving a purpose: what it does, constraints, how to pass url, and parameter guidance. Front-loaded with the core purpose. 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?

The description covers the tool's purpose, usage constraints, parameter details, and behavior. The output schema exists, so explaining return values is unnecessary. Given the tool's simplicity (2 parameters, no nested objects), the description is fully complete.

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

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

Schema coverage is 100% with detailed descriptions for both parameters. The description adds emphasis on 'public' URLs and provides usage guidance on caching, which adds value beyond the schema. Baseline 3 due to high schema coverage, but the extra guidance 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 clearly states the tool reports 'heuristic authentication, paywall and JavaScript access flags', which is a specific verb and resource. It distinguishes itself from sibling tools like url_status or url_headers 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?

The description explicitly states when to use ('public HTTP(S) resources'), what not to do ('does not execute JavaScript or bypass access controls'), and gives clear guidance on the 'fresh' parameter ('Keep fresh=false to allow cache reuse; set fresh=true only when a new upstream fetch 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds that it does not execute JavaScript, does not bypass access controls, and explains caching behavior with the fresh parameter. 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?

The description is three sentences, front-loaded with the main purpose, then usage constraints and parameter guidance. Every sentence adds value; 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 existence of an output schema (not shown but mentioned), the description fully covers the tool's behavior, constraints, parameter usage, and caching. It adequately informs an AI agent without 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% with descriptions for both parameters. The description adds value by specifying that the URL must be absolute public HTTP(S) and explaining the caching behavior for the fresh parameter, going beyond the schema's information.

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

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

The description states it 'Resolve requested, final and declared canonical URLs with evidence', clearly specifying the action and resource. It also distinguishes from siblings by focusing on canonical URL resolution, which is unique among the listed sibling tools.

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

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

The description provides explicit guidelines: use only for public HTTP(S) resources, does not execute JS or bypass access controls, and explains the fresh parameter usage with cache reuse. It lacks explicit mention of when not to use versus siblings, but the context 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?

The description discloses side effects (creates a baseline on first use), caching behavior, and that JavaScript is not executed. It also notes SSRF-sensitive destinations are rejected, which aligns with annotations and provides additional safety context. Annotations indicate readOnlyHint=false, consistent with the described stateful behavior.

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

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

The description is concise, with the main purpose front-loaded. Every sentence adds value, with no redundancy 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?

Given the tool's simplicity (2 parameters) and the existence of an output schema, the description fully covers purpose, behavior, usage guidance, parameter semantics, and safety considerations. 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 coverage is 100%, and the description adds meaningful context beyond the schema: explicitly stating the URL must be absolute and public, and explaining the fresh flag's effect on caching and origin load.

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

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

The description clearly states the tool compares a URL's content hash against a previously stored baseline, creating a baseline on first use. It reports whether content changed and returns hashes with timestamps. This distinguishes it from siblings like url_diff (which compares two URLs) and other url_* tools.

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

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

The description provides clear guidance on when to use the tool (to detect changes) and explicit instructions for the fresh parameter ('Keep fresh=false to reuse cache; set fresh=true only for a new fetch'). It does not explicitly state when not to use it, but the context 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 readOnlyHint, idempotentHint, and destructiveHint=false. The description adds that no JavaScript is executed, no access controls bypassed, and that caching is used (fresh=false). It also notes that private/internal URLs are rejected, providing safety 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 three concise sentences with no fluff. It front-loads the purpose and immediately provides usage constraints. Every sentence adds necessary 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 two parameters, full annotations, and an output schema present, the description covers all necessary aspects: input constraints, caching semantics, and boundaries (public only, no JS). The output schema handles return structure, so no further details 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 has 100% coverage with descriptions for both parameters. The description adds significant value: for url it details the rejection of SSRF-sensitive destinations, and for fresh it explains caching behavior and cost implications, going well 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 classifies MIME type, charset, and bounded content length. It specifies the resource (public HTTP(S) URLs) and the action (classify), distinguishing it from sibling tools that handle other aspects like headers, status, or 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 explicitly restricts usage to public HTTP(S) resources and clarifies it does not execute JavaScript or bypass access controls. It also provides guidance on the fresh parameter for cache reuse. While it does not name alternative tools, the context of sibling tools makes the purpose 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 context beyond annotations: no JavaScript execution, no access control bypass, caching behavior with fresh parameter. Annotations already indicate non-read-only and non-destructive, and the description clarifies the caching side effect.

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-loading the purpose, then usage constraints, then parameter guidance. No 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 purpose, parameter usage, and constraints. It assumes understanding of 'bounded normalized diff' and does not explain behavior when no previous snapshot exists, but output schema provides return value details.

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

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

Schema coverage is 100% with detailed descriptions. The tool description largely paraphrases the schema—e.g., 'Pass url as an absolute public HTTP(S) URL' mirrors the schema's description. It adds no new semantic value beyond emphasis.

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 a bounded normalized diff against the previous snapshot,' specifying the verb and resource. Among many URL tools, this one is uniquely about diffing, so it stands out.

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' and guidance on the fresh parameter. However, it does not explicitly compare to siblings like url_changed to help decide when to use this 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 indicate read-only, idempotent, non-destructive. The description adds valuable context: bounded output size and fetch time, no JavaScript execution, and cache reuse behavior, enhancing transparency 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: first clearly states purpose and outputs, second gives parameter guidance, third addresses caching. Every sentence is essential and 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?

Given output schema exists and annotations cover safety, the description covers constraints (public URL, bounded output), usage hints, and cache behavior. It could mention error handling or retry behavior, but overall sufficient for a simple extraction 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?

All parameters have schema descriptions (100% coverage). The description adds extra meaning: url must be absolute public HTTP(S), include_links only when needed, and fresh=false for cache, which aids correct usage.

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(S) documents, listing return fields. However, it does not explicitly distinguish from sibling tools like url_text or url_links, which overlap in functionality.

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 parameter usage tips: require absolute public URL, recommendation to set include_links only when needed, and use fresh=false for cache reuse. But it lacks guidance on when to choose this tool over related sibling tools.

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

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

The description adds behavioral context beyond annotations: it notes that the tool does not execute JavaScript or bypass access controls, and mentions caching behavior and SSRF rejection, complementing the readOnlyHint and idempotentHint.

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

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

The description is extremely concise: two sentences, front-loaded with core purpose, 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?

Given the presence of an output schema and comprehensive annotations, the description fully covers input constraints, caching behavior, and usage context, leaving no ambiguity.

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%, but the description adds extra value: it specifies the url parameter must be an absolute public HTTP(S) URL and explains the caching semantics of the fresh parameter.

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

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

The description clearly states 'Compute a versioned SHA-256 of normalized content' with a specific verb and resource, and the purpose is distinct from sibling tools like url_extract or url_metadata.

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

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

The description explicitly says 'Use only for public HTTP(S) resources' and provides guidance on the fresh parameter: 'Keep fresh=false to allow cache reuse; set fresh=true only when a new upstream fetch 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?

Beyond annotations (readOnlyHint, idempotentHint, etc.), description adds caching semantics and security constraints (no JS execution, no bypassing access controls). 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 concise sentences covering purpose, usage, and parameters with no redundant information. Front-loaded with core purpose.

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

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

With an output schema present, description covers all necessary aspects: purpose, constraints, parameter behavior, and caching. No missing elements.

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, baseline is 3. Description adds value by emphasizing 'absolute public HTTP(S) URL' and providing clear guidance on fresh parameter (cache reuse vs. new fetch).

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 'Return allowlisted response headers only', specifying a concrete verb and resource. This distinguishes it from sibling tools like url_security_headers, which focus on specific header subsets.

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 limits use to public HTTP(S) resources, notes that JavaScript is not executed, and clarifies caching behavior with fresh=true/false. Does not name alternative tools but provides sufficient context for correct selection.

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

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

Annotations indicate read-only, idempotent, non-destructive. Description adds critical behavioral details: no JS execution, no access control bypass, cache reuse behavior via fresh parameter. This complements annotations well.

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?

Concise three sentences: first states purpose, second clarifies constraints, third explains parameter usage. 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?

Tool is simple with 2 parameters, output schema present. Description covers usage, constraints, caching, and distinguishes from other URL tools. No significant 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 already describes both parameters with high coverage. Description restates similar guidance without adding new semantics beyond what schema provides. Adequate but not additive.

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

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

States it returns heading hierarchy (h1-h6), specific verb 'Return' and resource 'heading hierarchy'. Distinguishes from sibling tools like url_headers (headers only) and url_text (full text).

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 usage context: public HTTP(S) only, no JS execution, cache control with fresh parameter. Does not explicitly name alternative tools for other use cases, but gives enough guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds that it does not download images, does not execute JavaScript or bypass access controls, and caches results (fresh parameter). All consistent 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, no superfluous words, front-loaded with core purpose. Each sentence adds essential 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 output schema exists (not shown but indicated), description covers all needed aspects: what it does, constraints, parameter guidance, and behavioral traits. 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 description coverage is 100%, but description adds contextual value: explains cache reuse benefit and trade-off for 'fresh', and re-emphasizes that 'url' must be absolute public HTTP(S). Goes beyond mere schema comments.

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

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

Clearly states 'List up to 100 image references without downloading images', a specific verb and resource. Differentiates from sibling tools (e.g., url_text, url_links) by focusing on images, and explicitly limits to public HTTP(S) resources.

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 context: use for public HTTP(S) URLs, no JS execution, no access control bypass. Offers guidance on the 'fresh' parameter (keep false for cache reuse, set true only when needed). Does not explicitly name alternatives, but the sibling list implies other 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?

The description adds significant behavioral context beyond annotations, such as not executing scripts, no access control bypass, and cache reuse policy. This fully informs the agent of important traits.

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

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

Four concise sentences front-loaded with the main purpose. Every sentence adds value with no redundancy or 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 presence of an output schema, the description covers purpose, usage, parameters, and behavioral traits completely. No gaps remain for an agent to interpret.

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 adds practical usage guidance for both parameters (url must be absolute HTTP(S), fresh parameter cache policy). This adds value 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 extracts bounded JSON-LD blocks without executing scripts, which is specific and distinguishes it from sibling tools that may execute JavaScript or extract other data.

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: use only for public HTTP(S) resources, does not execute JavaScript or bypass access controls, and guidance on fresh parameter. However, it does not explicitly name alternative tools for other use cases, leaving some room for ambiguity.

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. The description adds value by noting no JavaScript execution, no access control bypass, and caching behavior via the fresh parameter. 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 serving a purpose: function, constraints, and parameter guidance. No redundant words. Front-loaded with the main 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 (not shown but context says 'Has output schema: true'), the description need not explain return values. It covers purpose, usage, behavior, and parameters adequately for a simple read-only 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%, so baseline is 3. The description adds minimal extra meaning beyond the schema; the `fresh` parameter description in the description is nearly identical to the schema's description. The `url` parameter requirements are already well-documented in the schema.

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

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

The description clearly states what the tool does: 'Report declared and heuristically detected document language.' It specifies the resource type (public HTTP(S) resources) and distinguishes it from sibling tools that analyze other aspects of URLs.

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 when-to-use and when-not-to: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' Also advises on the `fresh` parameter, guiding the agent to keep false for cache reuse and set true only when needed.

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 the tool as read-only, open-world, idempotent, and non-destructive. The description adds behavioral context: it extracts up to 200 normalized safe links, does not execute JavaScript, and describes cache behavior. This goes beyond annotations, providing useful practical constraints.

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

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

The description is three sentences with no wasted words. It front-loads the main purpose in the first sentence, then provides usage constraints and parameter guidance. Perfectly concise and well-structured.

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

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

Given the rich annotations and presence of an output schema, the description covers the key points: function, constraints, and parameter advice. It could be slightly more complete by mentioning which sibling tools to use for other extraction needs, but overall it is sufficient.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining when to use fresh=true vs false ('only when a new upstream fetch is required') and reinforces that url must be an absolute public HTTP(S) URL. This advice is not present in 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 'Extract up to 200 normalized safe links', specifying the action (extract), resource (links from a URL), and key constraints (max 200, normalized, safe). While it doesn't explicitly differentiate from siblings like url_extract, the purpose is specific and 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 gives explicit usage guidance: 'Use only for public HTTP(S) resources; it does not execute JavaScript or bypass access controls.' It also advises on the fresh parameter. However, it does not mention when to use this tool over other link-related siblings, leaving some ambiguity.

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 value by disclosing that the tool does not execute JavaScript, does not bypass access controls, rejects SSRF-sensitive destinations, and uses caching. It does not contradict any annotation.

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 well-structured sentences, front-loaded with the core action. Every sentence provides necessary information without redundancy, making it highly efficient.

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

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

For a tool with good annotations, complete parameter schema, and an output schema (not shown but present), the description covers all necessary behavioral context: public URLs only, no script execution, caching advice, and SSRF protection. 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 coverage for parameters is 100% with descriptions for both 'url' and 'fresh'. The description largely repeats the schema's content (e.g., 'absolute public HTTP(S) URL', 'set fresh=true only when a new upstream fetch is required'). It adds minor context about cache reuse but does not significantly extend the schema's 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 clearly states the verb 'Convert', the resource 'readable HTML content', and the output 'bounded Markdown'. It distinguishes from sibling URL tools by noting it only works on public HTTP(S) and does not execute JavaScript, aligning with its specific function.

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

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

The description provides explicit usage constraints: only public HTTP(S) URLs, no JavaScript execution, no access control bypass. It also gives advice on the 'fresh' parameter. However, it does not explicitly state when not to use this tool or mention alternatives among the many sibling tools, so it's slightly less than perfect.

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. The description adds valuable behavioral context: no JavaScript execution, no access control bypass, SSRF rejection, and caching behavior. This exceeds what annotations provide.

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

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

The description is three sentences with no filler. Each sentence serves a distinct purpose: purpose, usage guidance, and parameter advice. Highly concise and well-structured.

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

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

Given the existence of an output schema, the description does not need to explain return values. It covers usage boundaries, limitations, and parameter semantics comprehensively. Complete for this 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 coverage is 100% with detailed descriptions for both parameters (url and fresh). The description reinforces the schema but does not add new semantic meaning. Baseline 3 is appropriate.

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

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

The description states it extracts title, description, author, dates and canonical metadata from public HTTP(S) URLs, providing a clear verb and resource. However, it does not explicitly differentiate from sibling tools like url_extract or url_canonical, which reduces clarity.

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

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

Explicitly states when to use (public HTTP(S) resources), what it does not do (execute JavaScript or bypass access controls), and provides clear guidance on the fresh parameter. This fully satisfies usage guidelines.

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, openWorld, idempotent, non-destructive), description reveals concrete behaviors: uses at most eight external HTTP requests, does not execute JavaScript, caches results with fresh=false, and rejects SSRF-sensitive destinations. 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?

Four sentences, front-loaded with purpose, then key constraints and parameter guidance. No extraneous words; 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 two parameters and presence of an output schema, description covers all essential aspects: what tool does, what it finds, constraints (HTTP requests, no JS), caching policy, and security filter. Output schema already describes return values.

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 descriptions (100% coverage). Description adds practical usage advice: url must be absolute public HTTP(S) and fresh usage guidance. This extends schema details, justifying above baseline 3.

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

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

Description clearly states 'Inspect a public HTTP or HTTPS URL and return a structured site passport' and enumerates included fields (pulse, domain, robots, sitemap, feeds, OpenAPI, metadata). This distinctively sets it apart from sibling tools that focus on individual aspects (e.g., url_pulse, site_robots).

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 context: url must be absolute public HTTP(S), cache guidance with fresh parameter, and limits (max 8 requests, no JavaScript). However, it lacks explicit when-not-to-use or direct comparisons to siblings, relying on sibling names for differentiation.

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, destructiveHint, covering safety and idempotency. The description adds valuable behavioral traits: no JavaScript execution and caching behavior, which are not in 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?

Description is only 5 sentences, each adding distinct information: purpose, returned data, behavioral note, parameter guidance. No redundancy, and critical details are 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?

Given the tool's 2 parameters, existing output schema, and annotations, the description covers all key aspects: use case, output highlights, parameter constraints, and behavioral note. 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%, so baseline is 3. Description adds specific examples for url (private, loopback, etc.) and explains caching rationale for fresh (cheaper for origin), providing extra context 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?

Description clearly states the tool checks a URL before expensive browsing/AI processing and lists returned information. However, it does not explicitly differentiate from sibling tools like url_status or url_passport, though the broad scope of returned data distinguishes it.

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

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

The description specifies when to use (before expensive browsing/AI processing) and notes that JavaScript is not executed, implying limited use for JS-heavy pages. It also provides caching guidance for the fresh parameter, but does not name alternative tools for specific needs.

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?

Disclosures beyond annotations: confirms no JavaScript execution, no access control bypass, deterministic bounded chunks, and caching behavior. No contradiction with readOnlyHint, idempotentHint, or destructiveHint.

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, no waste. First sentence states purpose, second adds constraints, third explains parameter usage. Front-loaded and efficient.

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

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

Covers purpose, constraints, parameter usage. Output schema exists, so return values documented elsewhere. Complete for a simple tool with good annotations.

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%, but description adds value by reinforcing 'absolute public URL' for url and explaining caching rationale for fresh. Baseline 3, plus extra context.

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

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

Description clearly states the tool splits readable text into deterministic bounded RAG chunks, specifying the verb and resource. It is distinct from sibling URL tools by focusing on RAG 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 context: use only for public HTTP(S) resources, and explains when to set fresh=true/false. Does not explicitly contrast with siblings but adequate for usage.

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, idempotentHint, and destructiveHint. The description adds beyond this: 'it does not execute JavaScript or bypass access controls', and implies safety validation through SSRF rejection. 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 sentences, each carrying distinct information: purpose, constraints, and caching guidance. Front-loaded with the core action. No fluff.

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

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

The description fully covers the tool's behavior: input requirements (public HTTP only, absolute URL), safety validation, caching semantics, and what it does not do. With an output schema present, the description is complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds marginal value: for url it restates the absolute public URL requirement, and for fresh it adds 'cheaper for the origin' context. This is helpful but not a significant extension 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 safely validated redirect chain', specifying a concrete verb and resource. It also distinguishes from sibling URL tools by emphasizing that it only handles redirects and does not execute JavaScript, making the tool's unique purpose obvious.

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

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

The description explicitly says 'Use only for public HTTP(S) resources' and instructs on when to set fresh=true vs false. While it doesn't name specific sibling alternatives, the constraints effectively guide when to use this tool versus other URL inspection tools.

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

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

The description adds significant behavioral context beyond the annotations (readOnlyHint, idempotentHint, etc.). It clarifies that the tool returns static evidence, does not execute JS, rejects SSRF-sensitive destinations, and explains caching behavior. 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 two sentences long. The first sentence states the purpose and key constraints; the second addresses parameter usage. Every sentence is informative and front-loaded, with 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 complexity (security headers assessment) and the presence of an output schema, the description covers all necessary aspects: purpose, constraints, caching behavior, and parameter usage. It is comprehensive for an agent to use 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?

With 100% schema description coverage, the baseline is 3. The description adds value by specifying that 'url' must be an absolute public HTTP(S) URL and that SSRF-sensitive destinations are rejected, and by providing clear guidance on the 'fresh' parameter (cache reuse vs new fetch). 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 states a specific verb ('Assess') and resource ('common response security headers') and clearly distinguishes from siblings by specifying it is static evidence, does not execute JavaScript or bypass access controls. This sets it apart from tools like url_headers or url_status.

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 limits usage to 'public HTTP(S) resources' and clarifies that it does not execute JavaScript or bypass access controls. It also provides guidance on the 'fresh' parameter, explaining when to use true vs false. However, it does not directly compare against sibling tools for when to use 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 readOnlyHint and idempotentHint, so the bar is lower. The description adds valuable context: no JavaScript execution, no access control bypass, bounded extraction, and caching 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?

Three sentences, each carrying distinct and essential information: purpose, constraints, and parameter behavior. No extraneous details. Front-loaded with purpose.

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

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

The tool is simple with 2 parameters, schema covers all, annotations present, output schema exists. The description covers purpose, constraints, caching, and parameter usage adequately. No gaps for efficient agent 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 adds value by explaining the caching logic ('fresh=false to allow cache reuse; fresh=true only when a new upstream fetch is required') and reinforcing that url must be a public HTTP(S) URL, which is not fully detailed in the schema description 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 'Extract bounded Open Graph and Twitter Card fields,' using a specific verb and resource. Among siblings like url_metadata and url_jsonld, this tool is distinct for OG and Twitter cards, avoiding 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?

The description explicitly says 'Use only for public HTTP(S) resources' and clarifies that it does not execute JavaScript or bypass access controls. It also explains when to use fresh=true vs fresh=false. However, it does not explicitly name alternative tools for when to not use this one.

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 beyond annotations: does not execute JS, does not bypass access controls, rejects private/SSRF-sensitive URLs. This aligns with readOnlyHint, idempotentHint, and destructiveHint 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?

Two concise sentences with no waste. Each sentence adds essential information: purpose, constraints, and parameter guidance. 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 only two parameters, an output schema exists, and comprehensive annotations, the description fully covers usage, constraints, and parameter semantics without 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% with each parameter described. The description adds value: clarifies url must be absolute public HTTP(S), and explains the fresh parameter's caching behavior, enhancing schema info.

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 checks HTTP reachability, status, and final URL. It specifies use for public HTTP(S) resources, distinguishing it from sibling tools that focus on other aspects like headers, redirects, or security.

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 public HTTP(S)) and when not (no JavaScript, no access controls). Provides guidance on cache usage with the fresh parameter, suggesting default false for reuse.

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 (read-only, idempotent), the description adds that it does not execute JavaScript, respects cache, and rejects private/SSRF-sensitive URLs. This provides useful behavioral context, though 'bounded' and 'normalized' are not elaborated.

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 only 4 sentences, front-loaded with the core purpose, then constraints and parameter usage. Every sentence is essential and 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?

With output schema present, the description covers purpose, constraints, and parameter usage adequately. It is slightly vague on the meaning of 'bounded normalized readable text', but the output schema likely fills in the details.

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

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

Schema coverage is 100% with descriptions for both parameters. The tool description reinforces the schema's guidance on 'fresh' and 'url', but does not add significant new meaning beyond what the schema already 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 clearly states it returns 'bounded normalized readable text' from a URL, indicating text extraction. However, the phrasing 'bounded normalized readable text' is somewhat vague and doesn't explicitly differentiate from sibling tools like url_extract or url_markdown.

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

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

The description explicitly states when to use (public HTTP(S) resources only) and when not to (no JavaScript, no access control bypass). It also gives clear guidance on the 'fresh' parameter: keep false for cache reuse, set true only when needed. However, it does not compare to sibling tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds critical behavioral details: no JavaScript execution, no access control bypass, rejection of SSRF-sensitive URLs, and cache reuse behavior. This fully complements the 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?

The description is concise with three sentences, each adding essential information. No redundant or vague language. Front-loaded with the core purpose, then usage constraints, then parameter guidance.

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

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

Given the tool has an output schema (not shown but present), only 2 parameters with clear descriptions, and annotations covering safety and idempotency, the description is complete. It covers purpose, usage constraints, parameter behavior, and context without 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%, so baseline is 3. The description adds significant value by explaining the 'url' must be an absolute public HTTP(S) URL and elaborates on the 'fresh' parameter's semantics for cache behavior, going beyond the schema's brief 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 returns measured end-to-end fetch timing for HTTP(S) resources. It distinguishes itself from sibling tools by focusing specifically on timing measurement, not other URL properties.

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 use only for public HTTP(S) resources, clarifies it does not execute JavaScript or bypass access controls, and provides guidance on the 'fresh' parameter: keep false for cache reuse, set true only when necessary. This helps the agent decide when to use this 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?

Discloses that the tool inspects certificates, does not execute JS, and has caching behavior. Annotations already provide read-only and idempotent hints; description adds behavioral context 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?

Compact, front-loaded with purpose, no unnecessary words. 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 presence of an output schema and annotations, the description covers purpose, parameter guidance, constraints, and caching behavior sufficiently for an agent.

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 reinforces parameter usage: url must be absolute public HTTP(S), fresh controls caching. Adds value by clarifying when to use fresh=true.

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 public HTTPS certificates on port 443, using a specific verb and resource. It distinguishes itself from sibling tools that focus on other URL aspects like status, headers, or redirects.

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 context: use only for public HTTP(S) resources, does not execute JavaScript or bypass access controls, and explains when to set fresh=true vs false. However, lacks explicit alternatives or when-not-to-use compared to 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 already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds that it does not execute JavaScript and does not bypass access controls, which provides safety reassurance beyond annotations. The use of 'Estimate' indicates approximate results.

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 wasted words: first sentence states purpose and outputs, second gives constraints and capabilities, third gives parameter-specific guidance. Maximum information density.

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 (two parameters, one required), the description covers essential aspects: what it does, when to use it, limitations, and parameter usage. Since an output schema exists, no need to describe return values. Slightly incomplete on error scenarios or rate limits, but adequate for the tool's simplicity.

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

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

Both parameters are fully described in the schema (100% coverage). The description reiterates usage for 'url' ('absolute public HTTP(S) URL') and adds operational guidance for 'fresh' ('allow cache reuse' vs 'require new upstream fetch'), adding practical context without redundancy.

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

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

The description starts with a clear, specific verb ('Estimate') and lists the exact outputs (words, characters, sentences, reading time). It immediately distinguishes itself from sibling URL analysis tools like url_text or url_extract by focusing on estimation metrics.

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 the tool is for public HTTP(S) resources only, does not execute JavaScript or bypass access controls, and provides clear caching guidance ('keep fresh=false to allow cache reuse; set fresh=true only when a new upstream fetch is required'). While it doesn't explicitly compare to alternatives, the context is well-defined.

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