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

Annotations are present (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false) and the description does not contradict them. Beyond the annotations it adds real context: pages must be public, capture runs in a headless browser, output may be a link or an inline image depending on size. It omits any mention of rate limits or failure modes for unreachable pages.

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 the mechanism and output, then the use case. No filler, and the return behavior is stated before the softer suitability note. Tight and readable.

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

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

For a 14-parameter tool with no output schema, the description covers the essentials: public-page constraint, headless-browser execution, supported formats, and the dual return shape (link vs inline image). The PDF-specific and viewport parameters are left entirely to the schema, which is acceptable given 100% coverage.

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% across all 14 parameters, so the schema already documents url, format, delay, dimensions, and the PDF-only fields in detail. The description only restates the format choices (JPEG/PNG/WebP/PDF) already enumerated in the schema, adding no meaning beyond it. 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?

States a specific verb and resource: loads a public web page in a headless browser and captures it as an image or PDF. Clear enough to act on, but it never differentiates itself from closely related siblings like render_html, read_webpage, convert_html_to_markdown, or preview_link, which an agent must disambiguate among.

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?

"Suited to checking how a page renders or keeping a visual record of it" implies the use case but gives no explicit when-to-use-vs-alternative guidance. With render_html and read_webpage as siblings, the agent is left to infer which tool applies to a given page-inspection task.

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 and openWorldHint, so safety is partly covered, but the description adds genuinely new behavioral facts: it reports both daily and monthly quota remaining, and 'Costs nothing' tells the agent the call consumes no quota. It stops short of covering invalid/missing-key behavior or return shape.

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

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

Two tight sentences with the returned information front-loaded and the zero-cost caveat last. No filler or restatement of the title.

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

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

With no output schema, the description does the work of naming the returned fields (plan, daily quota, monthly quota) and the cost profile. It omits edge-case behavior such as unconfigured or invalid keys, which is a minor gap for a single-parameter read 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% with a single enum-constrained 'product' parameter that is fully documented in the schema. The description adds nothing beyond the schema for this parameter, so the baseline 3 applies.

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

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

States a specific verb ('Reports') and resource (plan of a configured Zactonz API key plus its quota for today and the month). No sibling tool inspects API keys, so the agent can distinguish it without opening the schema.

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

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

The description implies a pre-flight use case via 'Costs nothing' (safe to call freely), but never states when to call it versus alternatives or what happens when no key is configured. Usage is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and network-access profile is covered. The description adds scope (which records are inspected) but no additional behavioral traits such as rate limits, auth requirements, or latency from the probe option.

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

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

A single front-loaded sentence that packs the record coverage, provider classification, and return contents with zero filler. Nothing is wasted.

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

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

With no output schema, the description usefully signals the return shape (score out of 100 and a list of findings) and the audit scope. It is nearly complete, only missing guidance on the probe/selectors trade-offs already handled by the schema.

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

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

Schema description coverage is 100%, with probe, domain, and selectors all documented in the schema itself. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

States a specific verb ('Audits') and resource ('domain email configuration') and enumerates the exact record types checked (MX, SPF, DKIM, DMARC, MTA-STS, TLS-RPT, BIMI) plus the disposable/free-provider detection. This clearly separates it from the generic lookup_dns, though it never names a sibling outright.

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

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

The description explains what is audited but gives no when-to-use context, no prerequisites, and no indication of when to prefer this over lookup_dns or verify_emails. The agent must infer the routing on its own.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe/read-only profile is covered. The description usefully adds that no fetching occurs (a pure local transform), but says nothing about error behavior or output shape, so this is an incremental addition over 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?

Two short, front-loaded sentences with no filler; the core purpose comes first and the scoping clarification second. It is lean, though it could carry a bit more operational detail without bloating.

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?

This is a low-complexity pure transform with full schema coverage, and the description covers the essential 'no network fetch' point. It omits anything about the returned Markdown or error/limit handling, which for a converter tool would be nice but is not strictly required.

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 all five parameters (including the enum and the 2 MB limit) are already documented in the schema. The description adds no parameter-level detail, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Converts HTML ... to Markdown') and adds the scoping phrase 'HTML you already hold,' which separates it from fetch-oriented siblings like render_html and read_webpage. It does not name a sibling outright, but the purpose is unambiguous.

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

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

'Nothing is fetched' implies the use case is HTML already in hand, guiding the agent away from network tools. However, it never states when-not to use this or names the alternative, so usage is only implied rather than explicit.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true and destructiveHint=false, so the safety profile is largely covered. The description nonetheless adds real behavioral context beyond the annotations: the output link expires after 24 hours, the response includes source and output details, and the image itself is only returned when small enough. It omits any statement about auth or rate limits, keeping it short of a 5.

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

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

Two tightly packed clauses with zero filler: the conversion/transformation capabilities come first, followed by the return-value contract. Nothing is redundant with the schema and the most decision-relevant information is front-loaded.

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

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

For a 12-parameter tool with no output schema, the description covers both the operation surface and the return contract (24-hour link, source/output details, conditional image body). Nothing an agent needs in order to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents every parameter including enum meanings, ranges and defaults. The description only restates the operations in prose without adding syntax, format or interaction detail beyond what the schema provides. Baseline 3 applies.

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

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

States a specific verb (converts) and resource (an image at a public URL), enumerates the supported output formats and the transformation operations, so an agent can distinguish it from inspect_image and generate_social_image without opening the schema.

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

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

The requirement of a public source URL implicitly scopes usage, but the description never states when to prefer this tool over siblings like inspect_image, generate_social_image or capture_screenshot, and gives no exclusions or prerequisites. Usage is inferable rather than stated.

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

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

Annotations already declare openWorldHint=true, non-read-only, non-idempotent and non-destructive. The description adds genuinely non-obvious behavior: the returned link expires in 24 hours and the response includes dimensions plus the image itself. That expiry detail meaningfully affects how an agent should handle the result.

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 clauses, zero filler, and the core action is front-loaded before the supported types. Nothing would be lost by keeping it exactly as written.

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

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

For a 7-parameter tool with no output schema, the description covers the action, the full symbology set, and the return shape (link with expiry, dimensions, image). The only gap is the absence of any when-to-use guidance relative to generate_qr_code.

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% and every parameter (type alphabets, color, scale, format, height, bgcolor, content) is fully documented in the schema. The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Renders) and resource (a barcode) and enumerates all nine supported symbologies, which implicitly separates it from the sibling generate_qr_code. It never names that sibling or explicitly contrasts the two, but the symbology list makes the scope 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?

There is no guidance on when to choose this tool over generate_qr_code or when a barcode is inappropriate. The only orienting statement is the 24-hour link lifetime, which is output behavior rather than usage context.

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

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

With annotations only covering safety/idempotency hints, the description carries useful extra weight by disclosing the return shape: a link to the image, the image itself, or a 0/1 row matrix in text format. It does not mention determinism or any rate/size limits, but the output disclosure is genuinely valuable given there is no output schema.

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

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

Three short sentences with zero filler, and the core purpose is front-loaded before the return-value detail. Every sentence earns its place.

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

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

For a simple generation tool with full schema coverage and no output schema, the description supplies the essential return-value information an agent needs. The main omission is any routing guidance relative to sibling generation tools.

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

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

Schema description coverage is 100%, so all seven parameters (size, color, bgcolor, padding, accuracy, format, content) are fully documented in the schema itself. The description only echoes the text-format behavior already stated in the format enum, adding little beyond the baseline.

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

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

States a specific verb and resource ("Encodes text or a URL as a QR code") and specifies the two output shapes, which clearly separates it from read_qr_code and is distinguishable from generate_barcode by name. It never names a sibling explicitly, so it falls short of the top band.

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

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

No guidance on when to choose this over generate_barcode or read_qr_code, and no mention of prerequisites or limits beyond the schema. Usage must be inferred entirely from the name and parameter set.

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 a non-read-only, open-world, non-idempotent write, and the description is consistent with that by describing creation. It adds genuinely new behavioral context the annotations cannot convey: the returned link is valid for only seven days, and the image itself is returned alongside it.

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

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

Two sentences, zero waste, with the core identity ('Open Graph image') front-loaded before the inputs and the return contract. Every clause earns its place.

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

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

With no output schema, the description carries the return-value burden and does so adequately by stating both the link (with its seven-day validity) and the image. It stops short of clarifying the image's form (binary vs URL) or any size/rate limits, minor gaps for an otherwise complete definition.

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

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

Schema description coverage is 100% with enums for font, size, theme, format and template, so the schema already documents every parameter in detail. The description names title, subtitle, site and logo but adds no syntax or constraint beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb and resource ('Creates an Open Graph image') and immediately glosses the concept as 'the card shown when a link is shared', which no sibling tool produces. An agent can tell it apart from capture_screenshot, render_html or generate_qr_code without opening the schema.

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

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

The description contextualises when the output is useful ('shown when a link is shared'), implying the use case, but gives no explicit when-to-use or when-not-to-use guidance and never names an alternative. With no exclusions, an agent must infer this over render_html or preview_link itself.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and network profile is covered. The description adds only the input-to-output transformation and omits meaningful behavior for this tool, such as what happens with invalid or non-publicly-shared links and whether the file is validated before a link is returned.

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

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

One sentence, front-loaded with the verb and resource, with zero filler. Nothing could be removed without losing information.

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

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

For a single-parameter, read-only conversion tool with no output schema, the description conveys what goes in and what comes out. It falls short only on edge-case behavior (invalid links, permission-restricted files), which is a minor gap at this complexity.

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

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

Schema description coverage is 100% for the single 'url' parameter, and the description adds no format detail (e.g. accepted share-link patterns) beyond the schema's 'The Google Drive share link.' Baseline 3 applies when the schema carries the parameter burden.

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

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

The description gives a specific verb (converts) and both the input and output resources (a Google Drive share link into a direct-download URL), so the transformation is unambiguous. It does not explicitly contrast with siblings, but the siblings are unrelated network utilities, so no differentiation is needed.

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

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

Usage is only implied: an agent can infer it should be called when it has a Drive share link and needs a direct download URL. There is no statement of when not to use it, no prerequisites (e.g. the file must be publicly shared), and no named alternative.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that by enumerating exactly which attributes are reported (dimensions, format, size, orientation, transparency, dominant colours), telling the agent what it will receive without an output schema. It doesn't cover failure modes such as unreachable or non-image URLs.

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

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

One sentence, front-loaded with the verb and resource, and every listed attribute earns its place. Nothing is redundant or padded.

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

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

With no output schema, the description usefully compensates by listing the returned fields, and the read-only annotation covers the safety dimension. It would be complete with a note on error behavior for invalid or non-public URLs, but as a simple one-parameter read tool it is nearly 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 description coverage is 100% for the single url parameter, so the schema already documents it fully, and the description adds only the qualifier 'public'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description uses a specific verb ('Reports') on a specific resource ('an image at a public URL') and enumerates the exact attributes returned, so an agent knows immediately this is a metadata-inspection tool rather than a transformation tool. It never names the closest sibling, convert_image, so it falls short of full sibling differentiation.

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

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

There is no when-to-use guidance, no statement of when this is preferable to convert_image or capture_screenshot, and no mention of prerequisites beyond the URL being public. The agent must infer the use case entirely from the purpose statement.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuine behavioral context by disclosing that it opens a live network connection to the host and evaluates chain trust and hostname match, which is more than the annotations convey. It does not mention timeouts, connectivity failure behavior, or caching semantics beyond what the 'fresh' parameter implies.

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

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

A single front-loaded sentence that delivers the connection behavior first and the reported fields second, with no filler or repetition of the title.

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

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

With no output schema present, the description usefully enumerates the returned fields, and annotations cover the read-only/open-world safety profile. The only gap is the absence of any usage or failure-mode context, which is minor for a straightforward inspection 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 host, port (with enum) and fresh are all fully documented in the schema. The description adds no parameter-level meaning beyond that, which is the expected baseline when the schema does the work.

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 names a specific verb ('connects... and reports') and resource ('TLS certificate'), then enumerates exactly what is returned: issuer, subject, validity dates, days remaining, trust, name match, protocol and cipher. It is unmistakable against siblings like lookup_dns or lookup_whois, which serve different purposes.

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

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

No guidance on when to choose this tool over neighbors such as lookup_dns, lookup_whois, or check_email_domain, and no stated prerequisites (e.g. network reachability, need for open ports). Usage is only implied by the tool's subject matter.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and external-network profile is covered. The description usefully adds that DNSSEC status is included alongside the records, but says nothing about timeout, rate limits, or behavior for non-existent domains — modest added value over the structured fields.

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

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

A single sentence that front-loads the return value and packs the record enumeration and DNSSEC note with no filler. Every clause earns its place.

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

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

With no output schema, the description carries the burden of indicating what is returned, and it does so by naming the record types and DNSSEC status. Given a two-parameter read-only tool, this is nearly complete; only error/empty-result behavior is left implicit.

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% and both parameters are documented in the schema, so the baseline is 3. The description restates the record-type list but adds no syntax or format details beyond what the schema already provides; note the description mentions SRV while the schema default list omits it.

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

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

The description gives a specific verb ('Returns') plus resource ('DNS records of a host or domain') and enumerates the record types covered, so the agent knows exactly what comes back. It stops short of differentiating itself from near-neighbors like lookup_whois or check_email_domain, which also probe domain 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?

There is no statement of when to reach for this tool versus alternatives such as inspect_ssl_certificate, lookup_whois, or check_email_domain. Usage is only weakly implied by the record types listed.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety and external-call behavior are covered. The description does add the upstream sources (RDAP with a WHOIS fallback), which is meaningful context, but it says nothing about rate limits, failure modes for unregistered domains, or latency.

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

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

A single front-loaded sentence that names the sources first and then the returned fields. No redundancy, no filler, and the most decision-relevant information leads.

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

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

With no output schema, the description usefully enumerates the returned fields and the data sources, and annotations carry the read-only/open-world profile. It stops short of describing error behavior (e.g., domain not registered) or which source was used in a given response, which would complete the picture.

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 both 'domain' (host/URL reduced to registrable domain) and 'raw' (includes raw WHOIS text on fallback) are already fully documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Returns the registration record of a domain') and enumerates exactly what the record contains (registrar, dates, status codes, nameservers, abuse contact). The RDAP/WHOIS framing cleanly separates it from siblings such as lookup_dns or inspect_ssl_certificate without needing to name them.

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

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

There is no when-to-use versus when-not-to-use guidance and no alternative tool is named. An agent must infer from the sibling list whether registration data is what it wants. Nothing about prerequisites or fallback conditions is stated.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds the useful framing that it never fetches page content, but it omits the one-hour caching behavior and the existence of the fresh/render/verify_image bypasses, leaving those solely to the schema. Adds some value, but not rich 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?

Two sentences with no waste: the first front-loads verb plus resource plus return surface, the second earns its place by supplying the usage context. Nothing is padded or repeated.

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

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

There is no output schema, and the description compensates by enumerating the returned fields (title, description, image, favicon, site name, author, date, language, feeds), so the agent knows what to expect. Combined with annotations covering the read-only/open-world profile, nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so every parameter including fresh, render and verify_image is already documented in the schema. The description adds nothing about parameter syntax or defaults, which is the correct baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Reads the metadata of a public URL') and enumerates exactly which metadata fields come back. The closing clause ('without reading the page') implicitly contrasts it with the sibling read_webpage, but never names that alternative, so the differentiation is inferential rather than explicit.

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?

'A quick way to learn what a link points to without reading the page' implies the selection criterion versus read_webpage, but no tool is named and no exclusions or prerequisites are stated. Usage is implied rather than spelled out.

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=true and openWorldHint=true, covering safety and network access. The description adds that the result is the decoded text, which is useful since there is no output schema, but it does not mention failure cases, multiple codes, or rate limits. With annotations carrying the safety profile, this is a 3.

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

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

One sentence, front-loaded with the action and result. Every word earns its place; no redundancy.

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

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

For a simple two-parameter read tool with full schema coverage and annotations for safety/open-world, the definition is nearly complete. The description covers the return value in the absence of an output schema, though it omits error behavior for invalid or QR-less images.

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%: both image and format are fully described in the schema, including the base64 alternative and default. The description adds no parameter-level detail, so baseline 3 applies.

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

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

The description names a specific verb ('Decodes') and resource ('QR code in an image'), and states the output ('returns the text it holds'). This clearly separates it from generate_qr_code and other image tools without needing to name siblings.

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

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

The description implies usage by stating the action, but gives no explicit when-to-use, when-not, or alternatives (e.g., generate_qr_code or inspect_image). An agent must infer that it applies only when an image contains a QR code.

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 openWorldHint. The description adds real behavioral context beyond that: it strips navigation/adverts/scripts, and it explains the JS-rendering path. It stops short of noting caching behavior or rate limits, but covers the 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?

Two sentences, zero filler, with the core purpose and output format front-loaded and the conditional tip second. Every clause earns its place.

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

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

There is no output schema, so the description carries the return-value burden, and it does state the output is Markdown main content with truncation signaled. For a read-only 7-param tool with full schema coverage, this is essentially complete, though it could confirm the public-only/no-auth boundary.

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 3 baseline applies, and the description earns above it by tying the render parameter to a concrete condition (JavaScript-built content). The other six parameters are left entirely to the schema, which is 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 a specific verb (fetches) and resource (public web page) plus the output format (main content as Markdown with navigation, adverts and scripts stripped). It is clearly distinct from siblings like read_qr_code or capture_screenshot, though it does not name any sibling directly for differentiation.

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

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

The only explicit guidance is conditional on the render flag (JS-built pages). There is no statement of when to prefer this over render_html, preview_link or convert_html_to_markdown, so usage is only implied by the 'public web page' framing.

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

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

Annotations already declare the non-read-only, open-world, non-idempotent safety profile, so the bar is lower; the description still adds real value by disclosing the return shape (a link to the file, plus the image inline when small enough) and the external-resource constraint. It does not cover link lifetime, failure modes, or rendering latency.

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

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

Two sentences, zero filler. Output formats and use cases come first, then the return behavior and the absolute-URL constraint, so the most decision-relevant information is front-loaded.

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

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

With no output schema, the description carries the return-value burden and does so ('returns a link to the file, and the image itself when it is small enough'). Combined with the 100%-covered schema and existing annotations, an agent has everything needed to select and call the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the format list and the 2 MB limit that the schema already documents, and adds no new meaning for width, height, or quality parameters.

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

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

States a specific verb and resource ('Renders an HTML document you provide') plus the concrete output surface (JPEG, PNG, WebP, PDF), so an agent can tell it apart from markdown converters in the sibling set. It never names an alternative such as capture_screenshot, though the 'HTML you provide' phrasing implicitly separates it from URL-based capture 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?

Gives concrete use cases (invoice, report, certificate) and a hard prerequisite for correct use: referenced images, fonts and stylesheets must use absolute URLs. There is no explicit when-not guidance or named alternative, but the context and constraint are clear enough to invoke correctly.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered externally. The description adds one genuinely useful behavioral constraint — 46 supported languages — but says nothing about rate limits, text length limits, or failure modes for unsupported language codes.

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

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

Two short sentences, zero redundancy, with the core operation front-loaded before the scope fact. Every sentence earns its place.

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

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

For a simple 3-parameter read-only utility with a fully documented schema and annotations covering read-only/open-world behavior, the definition is nearly sufficient. It could mention the return value (translated text) or constraints on input length, but nothing critical for correct invocation is missing.

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

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

Schema description coverage is 100%, so all three parameters are documented in the schema itself, including the English default for `from` and example codes for `to`. The description's only added parameter-relevant information is the total language count, which does not clarify code formatting or enum membership.

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

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

States a specific verb (Translates) and resource (text) with the scope of the operation (one language to another). Sibling tools are unrelated utilities (DNS, QR codes, screenshots), so there is no competing translation tool to distinguish from, but the purpose is unambiguous.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance beyond the obvious implication of the name. No prerequisites, no note about the default source language being English in prose, and no indication of when another sibling might be preferred.

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=false, openWorldHint=true, and idempotentHint=false, so the agent already knows this performs an external, non-idempotent operation. The description adds valuable context: no message is sent, results can take up to a minute, and output is valid/invalid per address. It doesn't mention rate limits, authentication, or failure modes, but it meaningfully extends the annotated behavior.

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

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

Three tight sentences: what it does, what it returns, and the latency caveat. The latency warning is front-loaded enough to set expectations and nothing is wasted.

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

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

For a single-parameter tool with no output schema and full annotation coverage, the description covers mechanism, return values, and latency. It does not explain error handling (e.g., what happens for malformed addresses) or the distinction from check_email_domain, so it is not fully complete.

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

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

Schema coverage is 100% and the schema itself documents the emails array and its ten-address cap. The description adds no per-parameter syntax, format, or validation detail beyond what the schema already provides, so the baseline of 3 applies.

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

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

States a specific verb (checks/verify) and resource (email addresses) and clarifies the mechanism: querying the receiving mail server without sending a message. It could be confused with the sibling check_email_domain, which validates domains rather than individual addresses, but the description does not distinguish between them.

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

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

Usage is implied by the purpose but there is no explicit when-to-use guidance, no mention of alternatives like check_email_domain, and no prerequisites stated. An agent can infer the context but must reason about it.

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