Cofferdock

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

Annotations already cover idempotency and non-destructiveness, and the description adds meaningful behavioral details: a 1-credit cost per call, a 15-minute valid download link, and the requirement to include that link in replies. It also discloses the format placeholder constraint. 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 compact and front-loaded with the core purpose. Each sentence earns its place: purpose, scope, format constraint, cost, and output handling. There is no fluff, and the most important information (what it does) appears first.

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 8 parameters (all documented in schema) and no output schema, the description provides all necessary behavioral context: cost, link validity, and the instruction to always include the link. It also covers the format placeholder rule. An agent has enough to call it correctly without 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?

The input schema has 100% description coverage for all 8 parameters, so the baseline is 3. The description adds value by clarifying that the `format` must contain {n} and can use {total}, and by explaining that `pages` controls which pages get stamped. These are semantic nuances not fully captured in 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 ('Add'), a specific resource ('page numbers to a PDF'), and the action ('Stamps a page number on every page'). It clearly distinguishes this from sibling tools like merge_pdfs or watermark_pdf by focusing on page-number placement. The mention of the `pages` parameter further clarifies scope.

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

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

The description gives clear context on how to use the tool (format constraints, cost, and output link) but does not explicitly state when not to use it or list alternatives. The purpose is unambiguous enough that an agent can infer when to select it, but it lacks explicit exclusions or comparisons 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?

Beyond the annotations (readOnly=false, idempotent=true, destructive=false), the description discloses a per-call credit cost, a temporary download link with a 15-minute validity, and instructs the agent to always include the link in its reply. This is valuable operational context not present in the schema or 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 compact and front-loaded: purpose first, then constraints, cost, and return behavior. Each sentence adds operational value, and the agent instruction about including the link is a necessary addition.

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

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

For a one-parameter tool with no output schema, the description explains the return format (temporary link, 15-minute validity) and the required agent action. The phrase 'Default output is the zip binary' is slightly ambiguous next to the link-return statement, but the overall picture 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?

The schema already documents the single `files` parameter and its nested `name`/`content` fields with 100% coverage. The description adds the 'any type' clarification and a folder-name example, but these are marginal beyond the schema, so the 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 clear action ('Create a zip') with a bounded resource ('up to 50 files') and clarifies it packs any file type into a .zip. This is distinct from the sibling PDF/image/validation tools, even though no sibling is named.

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 makes the use case obvious: bundle arbitrary files into a zip. It doesn't explicitly name alternatives or exclusions, but no sibling tool offers zip creation, so the context is clear enough. A 4 reflects clear context without explicit when-not-to-use guidance.

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

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

Annotations declare idempotentHint=true and readOnlyHint=false, so the safety profile is already known. The description adds valuable non-obvious facts: the 1-credit cost, the temporary download link with a 15-minute validity, and the instruction to include the link in the reply. 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 brief and front-loaded, with the purpose stated in the first sentence. The opening phrase repeats the title's chart-type list, a minor redundancy, but every subsequent sentence adds essential operational detail (constraint, cost, link, reply instruction).

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 most important runtime behavior: return format (temporary link), link validity, and the required action for the agent. Error handling and authorization are not mentioned, but the description is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the schema fully documents all 7 parameters. The only parameter-related note in the description ('Pie and doughnut accept 1 series only') duplicates what the schema already says, adding no new semantic 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 states a specific verb ('Turns labels and numeric series into a chart image') and a clear resource, with the chart types enumerated. The phrase 'without a browser' differentiates this from sibling tools like screenshot_url or html_to_image, making its role 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 implies the use case (generating a chart image from data) and adds a constraint ('Pie and doughnut accept 1 series only'), but it does not explicitly state when to use this tool versus alternatives or mention sibling tools. Guidance 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 indicate idempotent and non-destructive behavior. The description adds the no-OCR limitation, the optional pages behavior, and the credit cost, which are not captured elsewhere. 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 pack the core purpose, a key limitation, optional behavior, and cost. No fluff; the most critical info (no OCR) 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 simple extraction tool with two parameters and no output schema, the description tells the agent everything needed to decide and invoke: what it returns, the limitation, the optional flag, and the cost.

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 fully (100% coverage). The description adds a brief note about pages=true returning page-by-page text, but this is a minor elaboration beyond the schema's own 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?

Clearly states the verb 'extract' and resource 'text of a PDF', and explicitly distinguishes from scanned images via 'not scanned images: there is no OCR'. This sets it apart from sibling PDF tools like pdf_to_images or merge_pdfs without requiring schema inspection.

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

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

Provides a clear exclusion condition (no OCR for scanned images), telling the agent when NOT to use this tool. It doesn't name a specific alternative, but the limitation is explicit and actionable.

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

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

Beyond the annotations, the description discloses the credit cost ('Costs 1 credit per call'), the temporary download link behavior ('valid 15 minutes'), and the flatten side effect ('make the result non-editable'). These are meaningful operational details not present in the annotations or 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?

The description is compact and front-loaded with the core behavior, followed by cost and output-link instructions. The first sentence slightly repeats the title, but every other sentence adds necessary information without padding.

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

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

With no output schema, the description compensates by specifying the return value ('temporary download link valid 15 minutes') and instructing the agent to include it in the reply. It covers the main behavioral modes and cost, leaving little ambiguity for a tool of this complexity.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds value by explaining the relationship between `data` and `inspect` ('Without `data` (or with inspect=true) it returns the list of fields') and by clarifying the purpose of `flatten` ('make the result non-editable'). This goes beyond the schema's individual parameter descriptions.

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

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

The description states a specific verb and resource: it 'Fills the fields of an existing PDF form (AcroForm) with the values in `data`.' It also clearly distinguishes the field-listing mode ('Without `data` (or with inspect=true) it returns the list of fields'), which separates it from sibling PDF tools like merge_pdfs or extract_pdf_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?

The description gives clear context on when to use the tool and how to switch modes: pass `data` to fill, omit it or set `inspect=true` to list fields. It does not explicitly name alternative tools or state when not to use it, but the mode guidance is practical and sufficient for an agent.

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

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

Beyond the annotations (idempotent, non-destructive), the description discloses two critical behaviors: 'Costs 1 credit per call' and 'Returns a temporary download link (valid 15 minutes).' It also tells the agent to include the link in the reply. These add significant behavioral context not present 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?

Four sentences with no redundancy. The first sentence states the core purpose and the format options, the second covers cost, the third the link validity, and the fourth the required action for the agent. Each sentence earns its place, and the purpose is front-loaded.

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

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

The description is complete for an agent to call this tool correctly. It covers the input (text/link with max length), the behavior (cost, temporary link), and the required follow-up action (include link in reply). No output schema exists, and the parameters are fully documented in the schema. Nothing an agent needs 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?

The schema covers 100% of parameters with descriptions, so the baseline is 3. The description reinforces the max length (1500) and mentions the output format (PNG/SVG), but does not add new parameter-level semantics beyond what the schema already provides. It does not compensate for any schema gaps because there are none.

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 and resource: 'Turns a link or any text (max 1500 characters) into a QR code.' It also mentions the output formats (PNG or SVG) and the maximum length. This clearly distinguishes it from the sibling tools, none of which generate QR codes.

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 tells the agent what the tool does (converts text/link to QR code) and provides an explicit post-call instruction: 'Always include that link in your reply so the user can open or download the file.' It does not mention alternatives, but no alternatives exist among siblings, so the usage context is clear.

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

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

All annotations are false, so the description carries the burden of behavioral disclosure. It adds the cost information ('One credit per call regardless of count') and implies non-determinism ('random UUIDs'). This goes beyond the schema and provides useful context, though it could be more explicit about return format or side effects.

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

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

The description is short but contains redundancy: 'One credit per call regardless of count' and 'Costs 1 credit per call' say the same thing. This duplication wastes space and could be streamlined. The core information is front-loaded, but the repeated cost statement reduces conciseness.

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

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

For a simple tool with one optional parameter, the description covers the essential details: range, cost, and randomness. However, it does not specify the return format (e.g., whether it returns an array of strings or a single string when count=1). Given there is no output schema, this omission leaves some ambiguity for the 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 description coverage is 100%, so the schema already fully documents the 'count' parameter. The description repeats the range ('1 to 100') without adding new semantic details beyond what the schema provides. The baseline of 3 applies here as the schema handles parameter explanation adequately.

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 generates UUIDs (v4) and returns 1 to 100 random UUIDs. The verb 'Generate' and resource 'UUIDs (v4)' are specific, and it distinguishes itself from all sibling tools, none of which handle UUIDs. This is a precise and unambiguous purpose.

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

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

The description provides clear context that it generates random UUIDs and specifies the count range. There are no similar sibling tools, so explicit alternatives are unnecessary. However, it doesn't explicitly state when not to use it (e.g., if deterministic IDs are needed), but given its uniqueness, 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 declare readOnlyHint=true and openWorldHint=false, so the description's job is to add context. It adds that the call is free (does not cost a credit) and enumerates the returned data, which goes beyond the annotations and gives the agent useful operational knowledge.

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, front-loaded with purpose, then results, then cost and usage. Every clause earns its place; no redundant information 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?

For a no-parameter, no-output-schema tool, the description fully covers what the agent needs: what it returns, that it's free, and when to call it. 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?

With zero parameters, the schema coverage is trivially 100% and there is nothing to document. The description does not need to explain parameters; instead it explains the output, which is appropriate given there is no output schema. Baseline 4 is correct.

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 the plan and remaining credits, listing specific return fields (plan, monthly limit, used and remaining credits). It is a distinct resource not covered by any sibling tool, so it stands alone clearly.

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

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

It provides explicit guidance to use it at the start of a workflow to decide whether to continue, which is useful context. Since no sibling tool performs a similar function, it does not need to differentiate, but it lacks an explicit 'when not to use' 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?

Beyond the annotations, the description discloses the 1-credit cost, the 25 MB file limit, and the differing return forms for text (JSON) versus file (raw bytes). These are useful behavioral details not present in the schema or annotations. The file mode is slightly ambiguous because the input schema only exposes a text parameter, but the description does not contradict the annotations.

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

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

The description is compact and mostly front-loaded, but the first sentence duplicates the title verbatim, adding no new information. The remaining sentences about return formats and credit costs earn their place, so the overall structure is adequate though not tight.

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 three-parameter tool with full schema coverage, the description covers the essential output behavior and size limit. However, the advertised file-hashing branch is not represented in the input schema, and there is no output schema, so an agent cannot confidently determine how to invoke the file path.

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

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

The input schema already documents all three parameters with descriptions and enums, so the description does not need to repeat them. However, it adds some confusion by advertising file hashing without explaining how a file maps to the single 'text' parameter, and the stated 25 MB limit does not align with text.maxLength=1000000.

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

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

The description opens with a specific verb and resource, 'Hash a text or a file', and precisely enumerates the supported algorithms (md5, sha1, sha256, sha512). This makes the tool's purpose unambiguous and clearly distinguishes it from sibling utilities like slugify, validate_email, or generate_uuid.

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 intended use cases: 'Useful for checksums and deduplication.' It also notes the credit cost per call, which is relevant to invocation decisions. It does not name alternatives or exclusions, but no sibling tool is a close substitute for hashing.

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 idempotent and non-destructive hints. The description goes further by disclosing that JavaScript is not executed, that external fonts/images are allowed, the 1-credit cost, and the 15-minute link expiry. These are valuable behavioral constraints not captured 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?

The description is compact and front-loaded: it opens with the exact output format, then efficiency notes, use cases, and mode selection. Every sentence adds value—including the credit cost and link instruction—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?

For a tool with 10 parameters and no output schema, the description adequately covers core workflow (html vs template+data), returns a temporary link, and instructs the agent to include it in replies. The schema fills parameter details; the description adds the credit cost and link behavior. Minor missing info on error handling but not essential for successful invocation.

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

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

Schema coverage is 100% with detailed parameter descriptions. The tool description adds context beyond the schema: it clarifies that CSS must be inline or in a style tag, that JavaScript won't run, and explains the html-vs-template+data relationship. This enriches the agent's understanding without repeating schema text.

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 renders HTML into an image (PNG, JPEG, WebP) and lists concrete use cases (social cards, certificates, tickets, OG images). It distinguishes from siblings like html_to_pdf (PDF) and screenshot_url (URL) by specifying input is raw HTML.

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

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

It explains when to use it ('Ideal for social cards, certificates, tickets...') and describes the two modes of use (html vs template+data). However, it doesn't explicitly contrast with sibling tools or state when not to use it, leaving some inference to the agent.

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 (idempotent, non-destructive), the description discloses additional behaviors: 'Costs 1 credit per call', 'Returns a temporary download link (valid 15 minutes)', and instructs the agent to always include the link in the reply. It also specifies rendering constraints (no JavaScript, inline CSS, web fonts, images allowed) and template fallback behavior. This is substantively more than annotations cover.

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

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

The description is three sentences: purpose, rendering engine limitations, template option, cost, and output link instructions. It is concise, front-loads the core function, and every sentence serves a purpose without fluff.

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

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

With 9 parameters, no output schema, and nested objects, the description is comprehensive: it explains how to choose between html and template, mentions the templates.json link for details, states the credit cost, and clarifies the response format (temporary link with validity). It ensures an agent can call the tool correctly end-to-end.

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 descriptions cover 100% of the 9 parameters, so the baseline is 3. The description adds value by clarifying the data parameter escaping ('Plain text only: everything is escaped'), template field fallback ('Fields you leave out keep the example text'), and scale usage ('use a value below 1 to fit more on each page'). These enrich the schema 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 clearly states the verb 'renders' and resource 'HTML into PDF' with explicit use cases (invoices, reports, tickets, contracts). It distinguishes from siblings like html_to_image or images_to_pdf by mentioning the rendering engine and template option, making the scope precise.

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 options: 'Send either html, or template + data' and highlights the invoice template as suitable for PDF. It also notes the same rendering engine as /capture, but does not explicitly contrast with siblings like html_to_image or images_to_pdf, so some inference is required. It provides clear context but lacks direct 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?

Adds valuable behavior beyond annotations: costs 1 credit per call, returns a temporary download link valid for 15 minutes, and instructs the agent to include the link in the reply. Also explains how page_size affects output. 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 short, focused paragraphs: core behavior first, then cost, then output-link handling. The opening sentence slightly repeats the title, but every other sentence earns its place and important 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 two-parameter tool with no output schema, this is complete: input format/count, page-size behavior, credit cost, download-link validity, and the required user-facing instruction are all described. The schema fills in base64 and item limits, so 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. The description adds meaning beyond the schema by explaining that 'auto' makes each page match its image while other page sizes fit the image inside. This extra semantic detail lifts it above baseline.

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

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

States a specific verb and resource: 'Turns 1 to 20 PNG/JPEG images into a PDF.' The title adds 'one image per page,' which distinguishes this from related tools like merge_pdfs or pdf_to_images. The core behavior is unmistakable.

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 clear context: use for 1–20 PNG/JPEG images and optional page_size control. It does not explicitly name alternatives or when-not-to-use, but the constraints and purpose make the appropriate use case clear.

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

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

Adds meaningful behavior beyond annotations: one credit per call regardless of file count, a temporary download link valid for 15 minutes, and an explicit instruction to include that link in replies. No contradiction with annotations found.

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

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

The description is short and front-loaded with the core purpose. Minor redundancy exists between 'One credit regardless of how many files' and 'Costs 1 credit per call,' but the overall structure is 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 one-parameter tool with no output schema, the description covers input constraints, ordering, cost, return behavior, and user-facing response requirements. Nothing essential is missing for correct invocation.

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

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

Schema coverage is 100% and the single 'files' parameter already documents base64 encoding and order. The description adds the 2–20 constraint and credit context, but does not need to compensate for schema gaps.

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

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

States a specific operation ('Merge'), the resource ('PDFs'), an explicit count range (2 to 20), and the order semantics. This clearly distinguishes it from sibling tools like split_pdf or images_to_pdf.

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: join multiple PDFs in the given order, with a defined credit cost. It does not explicitly name alternatives or exclusion conditions, but the operation boundary is obvious from the description.

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 valuable behavior beyond annotations: 1-credit cost, write mode returns the PDF, temporary download link valid 15 minutes, and an explicit instruction to always include the link. This meaningfully informs the agent's user-facing behavior and does not contradict annotations.

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

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

Three compact sentences, each carrying distinct operational value: mode behavior, cost, and response/link handling. The read/write distinction is front-loaded, and there is no filler.

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

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

For a 9-parameter tool with no output schema, the description covers input mode, affected fields, output delivery mechanism, link expiry, cost, and required agent action. An agent has all call-time information needed to invoke the tool correctly and relay the result to the user.

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 adds key mode semantics: presence or absence of metadata fields switches between read and write. It lists the primary fields but does not add much per-parameter detail 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?

States a clear verb+resource pair: 'Read or write PDF metadata.' It also specifies exactly which fields are affected and the mode-selection rule, distinguishing it from sibling PDF tools like extract_pdf_text or fill_pdf_form.

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 for when to read vs write: no metadata fields means read, any field means write. It does not name alternatives or exclusions, but the tool's unique purpose among siblings makes this sufficient operational 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?

Beyond annotations, the description discloses critical behavioral details: the cost of 1 credit per call, the temporary nature of the download link (15 minutes), and an explicit instruction to always include the link in the reply. These are not present in annotations and significantly help the agent handle the tool's side effects and output appropriately.

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

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

The description is concise and well-structured. It front-loads the core purpose, then provides the scale mapping, cost, and output handling instruction. Every sentence adds value; there is no fluff or repetition. The critical 'Always include that link' instruction is placed last, ensuring it is not missed.

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 adequately explains the return value (a temporary download link) and how to handle it. It covers cost, defaults, and the scale parameter's semantics. All required inputs are clear, and the agent has enough information to invoke the tool correctly and act on the result. No critical 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?

The schema already documents all three parameters (100% coverage), so the baseline is 3. The description adds meaningful semantic detail for 'scale' by mapping values to DPI (1 is 72 dpi, 2 is 144 dpi), which goes beyond the schema's generic 'Resolution multiplier' and helps the agent set appropriate values. This justifies a score above baseline.

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

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

The description opens with a clear verb and resource: 'Renders each page (or the ones in `pages`) as a PNG.' It explicitly states the conversion action and the optional page selection, which distinguishes it from sibling PDF tools like extract_pdf_text or merge_pdfs. The purpose is immediately obvious and 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 conveys the primary use case (converting PDF pages to images) clearly, but does not explicitly name alternatives or state when NOT to use it. However, the context of sibling tools (e.g., images_to_pdf, extract_pdf_text) makes the intended scenario inferable, and the description provides the necessary context without needing explicit exclusions.

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

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

Annotations already flag a non-read-only mutation, but the description adds valuable details beyond them: the credit cost, the 15-minute validity of the returned link, and the instruction to always include the link in the reply. This is useful behavioral context not present in 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?

Three short sentences with no filler: purpose, constraint, cost, and output link handling. The most critical information (what it does) is front-loaded, and every sentence carries functional weight.

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

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

For a tool with two simple parameters, the description covers the precondition, cost, output format (temporary link), and a direct instruction for the agent. Nothing needed for correct invocation is missing, and the lack of an output schema is compensated by the explicit link description.

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

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

Schema coverage is 100% for both parameters (file as base64 PDF, password as required). The description adds a meaningful constraint on the file parameter ('must not be protected already') that is not in the schema, enhancing understanding. It doesn't repeat schema text, so it earns above baseline.

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

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

The description uses a specific verb ('Add a password') and resource ('PDF'), then explains the encryption effect ('asks for the password when opened'). This clearly distinguishes it from the sibling unprotect_pdf and other PDF tools, leaving no ambiguity about the operation.

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

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

It gives a clear precondition ('The PDF must not be protected already') and states the credit cost, which helps an agent decide when to invoke it. However, it does not explicitly mention the alternative unprotect_pdf or provide when-not-to-use guidance, so it stops short of full routing.

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 this is a mutating (readOnlyHint false) and idempotent operation. The description adds valuable behavioral context: it costs 1 credit per call, returns a temporary download link valid for 15 minutes, instructs the agent to include the link in the reply, and clarifies that the angle is additive to existing rotation. This goes beyond annotations and provides practical operational guidance.

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. It front-loads the core purpose, then covers cost and output details. There is no redundant wording; every sentence earns its place. The structure is clean and easily 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?

For a simple PDF rotation tool with three parameters and no output schema, the description covers all essential information: the action, the additive rotation behavior, the credit cost, the temporary link, and the instruction to include the link in the reply. An agent has everything needed to invoke the tool correctly without external reference.

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

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

The input schema fully describes all three parameters (100% coverage), so the baseline is 3. The description adds a crucial semantic that the angle is added to each page's existing rotation, which is not captured in the schema. This enriches understanding of how the 'angle' parameter behaves, justifying a score of 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 verb 'Rotate' and the resource 'pages of a PDF', and further specifies that it rotates all or selected pages by 90/180/270 degrees, with the rotation added to each page's existing rotation. This distinguishes it from other PDF tools like merge or split, leaving no ambiguity about its 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 does not explicitly mention when to use this tool versus alternatives, nor does it name any sibling tools or provide exclusion criteria. Usage is implied by the clear purpose, but without explicit guidance on when not to use it or which alternative to prefer, the score is limited to 3.

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

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

Beyond the annotations, the description adds several operationally important behaviors: JavaScript is enabled, private/internal addresses are blocked, the call costs 1 credit, and the result is a temporary download link valid for 15 minutes that must be relayed to the user. This goes well beyond what the annotations alone convey and does not contradict them.

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

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

The description is compact and front-loaded with the core behavior before additional constraints. The first sentence repeats the tool title almost verbatim, which is mildly redundant, but every remaining sentence adds useful information (blocked networks, cost, link handling).

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 seven fully documented parameters and no output schema, the description covers the missing operational context: the execution environment, network restrictions, credit cost, output link format and validity, and the required agent behavior of including the link in the reply. Nothing important appears 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 is already documented in the schema. The description adds no parameter-specific semantics beyond confirming the URL must be public, so the schema does the heavy lifting and the baseline of 3 is appropriate.

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

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

The description states a clear action: 'Loads a public URL in a real browser (JavaScript enabled) and takes a screenshot.' This is specific about verb and resource and adds the public-URL constraint. It doesn't explicitly distinguish the tool from the sibling html_to_image, but the public/web-page framing makes the intended use recognizable.

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

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

The description clearly says the tool is for public web pages and explicitly states that 'Private networks and internal addresses are blocked,' which tells the agent when not to use it. It doesn't name alternative tools or provide explicit when-to-use versus sibling guidance, so it falls short of a 5.

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

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

Annotations indicate idempotentHint=true, and the description aligns by showing deterministic behavior. Beyond that, it adds a specific behavioral detail: 'removes accents', which is not in the schema, and the cost note (1 credit per call) is a unique behavioral disclosure 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?

The description is concise, with the core purpose in the first sentence, an illustrative example, and a separate cost note. Every sentence earns its place; it is 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?

For a simple pure transformation tool with 2 parameters and no output schema, the description covers the transformation rules, example, and cost. It lacks explicit mention of edge cases (e.g., empty text) but this is a minor gap given the clarity.

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 both parameters. The description adds an example for `text` and mentions the separator in the transformation rule, but it doesn't add critical meaning beyond the schema. Baselines at 3 are appropriate.

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

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

The description clearly states the verb 'turns' and the resource ('text' into a URL slug), with a concrete example that demonstrates the transformation. It distinguishes itself from siblings by focusing on slug generation, which none of the sibling tools do.

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

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

The description implies when to use it (when you need a URL-friendly slug) but does not explicitly state when not to use it or provide alternatives. Given the clear purpose, an agent can infer usage, but explicit guidance is lacking.

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

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

Beyond the annotations, the description discloses the credit cost, the one-PDF-per-range output behavior, and the temporary download link with a 15-minute validity. It also instructs the agent to always include the link in the reply, which is actionable and beyond what annotations provide.

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

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

The description is front-loaded with the core purpose, then provides examples, cost, and output-link behavior. There is minor redundancy between 'One credit regardless of how many files come out' and 'Costs 1 credit per call,' but it is not distracting.

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 adequately covers the return value: a temporary download link, its validity period, and the requirement to include it in the reply. Combined with parameter examples and cost disclosure, an agent has enough information to invoke the tool correctly.

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

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

The schema already covers both parameters, and the description adds meaningful semantics for 'ranges': 1-indexed pages, comma-separated groups, and concrete examples. This exceeds the baseline for a fully schema-covered tool.

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 ('Split'), a clear resource ('a PDF'), and the scope ('by page ranges'), and clarifies the output granularity with 'Creates one PDF per range.' This distinguishes it from sibling tools such as merge_pdfs and pdf_to_images.

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

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

The description gives clear context for when to use the tool: splitting a PDF into page-range-based files, with explicit range syntax examples. It does not explicitly name sibling alternatives or exclusions, but the intended use case is unambiguous.

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

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

Annotations already establish readOnly=false, destructive=false, and idempotent=true; the description is consistent with those and adds beyond them: a 1-credit cost, a 15-minute temporary download link, and an explicit instruction to include the link in the reply. It doesn't describe edge cases or failure behavior, but the added cost/return context is meaningful.

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 front-loaded with the core purpose and then adds only decision-relevant details: fit mode, formats, minimum required operation, credit cost, and return-link behavior. Each sentence earns its place, and there is no filler.

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

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

For a single-image transform with rich schema descriptions, this is complete: it covers accepted inputs, what operation is required, cost, and the output delivery mechanism despite no output schema. An agent has what it needs to select parameters and understand the response format.

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

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

The input schema already documents all six parameters with 100% coverage, so the bar is baseline 3. The description adds value by stating the 'at least one of width, height, format or quality' precondition and by revealing that GIF/TIFF are acceptable inputs even though they are not output format options.

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 action set ('Resize, convert or compress') and resource ('ONE image'), and names the supported conversions and input formats. This clearly differentiates it from sibling PDF, validation, and generation tools such as images_to_pdf or html_to_image.

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

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

The description gives clear context for when to call it: transform a single image by resizing, converting, or compressing, with the input formats listed. It does not explicitly name alternative tools or when not to use it, but the 'ONE image' scope and format list provide enough guidance for an agent.

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 substantial behavioral context beyond the annotations: it returns a copy, the link is temporary (15 minutes), each call costs 1 credit, and the agent must include the link in its reply. This is exactly the kind of operational detail an agent needs and is not present in the annotations.

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

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

The description is concise and well-structured, front-loading the core purpose and then adding critical caveats and instructions. Each sentence earns its place, and there is no filler.

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

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

With no output schema, the description fully explains the return value (unencrypted copy via temporary link) and provides the essential agent instruction to include the link in the reply. It also covers cost and the password requirement, making the tool self-sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description reinforces that the password must be the current one, but it does not add new parameter-level semantics beyond what the schema provides.

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

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

The description clearly states the tool removes a PDF's password and returns an unencrypted copy. It also explicitly distinguishes itself from password cracking by requiring the current password, making its purpose unambiguous even among sibling PDF 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 conveys when to use the tool: when you know the current password and need an unencrypted copy. It also implies a key exclusion—this tool is not for cracking passwords—though it does not explicitly name alternative tools like protect_pdf.

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 value beyond annotations by disclosing that an invalid email still results in a successful call with valid=false, and that each call costs 1 credit. This helps the agent predict failure semantics and cost, which annotations alone do not convey.

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

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

The description is compact and front-loaded: the core action is stated first, followed by the key behavioral detail and the cost note. Every sentence earns its place without redundancy.

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

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

For a simple two-parameter validation tool, the description is nearly complete. It covers purpose, the main validation behavior, the invalid-email success case, and cost. The only missing element is explicit return-shape detail, but the mention of valid=false gives enough signal in the absence of an output schema.

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

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

Schema coverage is 100%, so the input schema already documents both 'email' and 'check_mx' parameters. The description adds useful context about the MX check and the default behavior, but it does not materially expand on parameter meaning beyond what the schema already states.

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

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

The description opens with a specific verb and resource: 'Validate an email address.' It clearly distinguishes itself from sibling validation tools like validate_iban and validate_phone by naming the exact object being validated and by specifying exactly what is checked (format and MX records).

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 the tool does but gives no explicit guidance about when to choose it over alternatives such as validate_iban or validate_phone. While the resource type makes the selection fairly obvious, the description does not state any exclusions or conditions for 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?

Annotations already declare idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it checks the ISO 7064 checksum, returns the country and formatted IBAN, and costs 1 credit per call. The credit cost is a behavioral trait not present in annotations, which is useful for an agent deciding whether to call this tool. It doesn't describe error behavior for invalid IBANs, but the core behavioral traits are disclosed.

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 zero waste. The core action is front-loaded, the checksum standard and return values are stated in the second sentence, and the credit cost is a single final sentence. 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 single-parameter validation tool with full schema coverage and idempotent annotations, the description is nearly complete. It covers what the tool does, the checksum standard, return values, and cost. The only minor gap is that it doesn't describe the response format for invalid IBANs (e.g., error vs. false return), but with no output schema, this is a small omission rather than a critical one.

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 the single 'iban' parameter with an example. The description adds the checksum standard (ISO 7064) and the return fields (country, formatted IBAN), which gives context about what the parameter is used for, but it doesn't add syntax or format details beyond the schema. Baseline 3 is appropriate since 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 clearly states the tool validates an IBAN, checks the ISO 7064 checksum, and returns the country and formatted IBAN. This is a specific verb and resource, and it distinguishes itself from sibling validation tools (validate_email, validate_phone) by naming the IBAN-specific checksum standard.

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

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

The description implies when to use it (when you need to validate an IBAN) but does not explicitly state when not to use it or mention alternatives. Sibling tools like validate_email and validate_phone are obvious alternatives for other validation tasks, but the description doesn't explicitly route the agent away from them. The context is clear enough for a single-purpose tool, but explicit exclusions are missing.

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 idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it costs 1 credit per call, which is important for an agent deciding whether to invoke it. It also discloses the return format (E.164, international, country, type), which goes beyond the schema.

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

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

The description is compact and front-loaded: it states the core action first, then the output details, then the parameter guidance, then the cost. Every sentence earns its place, and the credit cost is a valuable operational detail.

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 validation tool with 2 parameters, full schema coverage, and idempotent annotations, the description is nearly complete. It covers the return value, the country parameter's purpose, and the cost. It doesn't describe error behavior (e.g., invalid number), but that's a minor gap for a validation 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 schema already documents both parameters well. The description adds a small but useful semantic detail: the country parameter is for numbers without the + prefix, which clarifies when to supply it. This is a modest addition over the schema, so a 3 is appropriate.

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

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

The description clearly states the tool validates and formats a phone number, and specifies the outputs: E.164 and international formats, country, and type. It distinguishes itself from sibling validation tools (validate_email, validate_iban) by focusing on phone numbers and mentioning the country parameter for numbers without the + prefix.

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

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

The description gives clear context on when to use the tool: for validating international phone numbers, and it explains the country parameter's role for numbers without the + prefix. It doesn't explicitly name alternatives or exclusions, but the sibling list makes the domain clear. The credit cost is a useful operational guideline.

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 several behavioral traits beyond the annotations: 'Costs 1 credit per call,' 'Returns a temporary download link (valid 15 minutes),' and instructs the agent to 'Always include that link in your reply.' It also clarifies the overlay behavior (every page or specified pages) and the text/image constraint. This enriches the agent's understanding of side effects and required follow-up actions, and 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 four sentences, front-loaded with the purpose, then usage scope, cost, and return-link instruction. Every sentence adds distinct value: purpose, operation details, cost, and output handling. No fluff or repetition; it is compact and well-ordered.

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 10 parameters but a fully described schema and no output schema, the description covers the essential operational aspects: what it does, the cost, the temporary link, and the instruction to include it in replies. It also notes the page-scoping option. Given the schema already documents all parameters, the description is sufficient for an agent to invoke the tool correctly and handle the result appropriately.

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

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

The input schema already provides detailed descriptions for all 10 parameters (100% coverage), so the baseline is 3. The description adds little beyond that: it repeats the max 200 characters and the 'OR' constraint, and mentions 'Image watermarks need the JSON body,' which is already implied by the schema's image property. It does not clarify nuances like the interaction between color and font_size (text-only) beyond what the schema states, so it does not significantly elevate parameter understanding.

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

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

The description clearly states the tool's function: 'Add a text or image watermark to a PDF.' It specifies the resource (PDF), the action (watermark), and the two modes (text or image). This is unique among sibling tools, which are all distinct PDF operations like merge, split, rotate, etc., so there is no ambiguity.

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

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

The description gives clear context on what the tool does ('overlays text or image on every page or on pages'), and notes a key requirement ('Image watermarks need the JSON body'). However, it does not explicitly compare to alternatives or state when not to use it. Since the tool's purpose is self-evident and distinct from siblings, the guidance is adequate but lacks explicit exclusions.

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