Cofferdock

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

The description discloses that the call costs 1 credit and returns a temporary download link valid for 15 minutes—information not present in annotations. It also states the stamping behavior and the format constraint. Annotations already indicate idempotentHint=true and readOnlyHint=false, which align with the description; the added cost and link expiry provide useful behavioral context beyond annotations.

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

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

The description is three concise sentences, front-loaded with the primary purpose. Every sentence adds value: the action, the format constraint, and the cost/link expiry. No filler or redundancy.

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

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

The description covers the return value (temporary download link with expiry), the cost, and the format requirement. It does not mention error conditions or prerequisites beyond the base64 encoding (which is in the schema). For a tool with no output schema, this is reasonably complete; a small gap is the lack of explicit mention that a new PDF is returned rather than modifying the input, though the link implies this.

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 all parameters described, so the baseline is 3. The description adds a critical constraint on the `format` parameter: it must contain {n} and may use {total}. This is not explicitly stated in the schema (which only gives an example). This added semantic value raises the score.

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 'Add' and resource 'page numbers to a PDF', and elaborates with 'Stamps a page number on every page'. This distinguishes it from siblings like watermark_pdf (which adds watermarks) and extract_pdf_text (which extracts). The purpose is unambiguous 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 implies usage for adding page numbers to PDFs, and clarifies that it can target specific pages via the `pages` parameter. It does not explicitly name alternatives or exclusions, but the context is clear enough that an agent would know when to select this tool over siblings like watermark_pdf. A slight gap is the lack of 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?

Beyond annotations, the description discloses the output format (zip binary), a temporary download link valid 15 minutes, and a cost of 1 credit per call. These are valuable operational details not present in annotations. No contradiction with annotations.

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

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

The description is two concise sentences plus a cost and return note, front-loaded with the purpose. Every sentence provides necessary context with zero 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 tool with one parameter and no output schema, the description covers return value, validity, cost, and constraints. An agent has everything needed to invoke it correctly.

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

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

The schema already fully documents both parameters (name and content) with descriptions and contentEncoding. The description's mention of folders and base64 merely repeats the schema. It adds no new meaning, 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 states a specific verb ('Create') and resource ('zip'), and clarifies scope ('up to 50 files', 'any type'). It clearly differentiates from sibling PDF and other tools, which are unrelated. 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 implies when to use this tool (when you need to pack files into a zip), and its purpose is distinct from siblings. It doesn't explicitly list exclusions or alternatives, but the context is clear enough for an agent to select it.

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

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

Annotations only indicate idempotency and non-destructiveness. The description adds valuable operational details: a 1-credit cost, return of a temporary download link valid for 15 minutes, and no-browser execution. This goes beyond what annotations provide without contradicting them.

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

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

Four compact sentences cover purpose, browser independence, a key series constraint, cost, and link expiry. Every sentence carries necessary information with 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 appropriately explains the return behavior (temporary link, 15-minute validity) and cost. Required parameters are fully documented in the schema. Minor edge cases like error behavior are not mentioned, but the core information an agent needs to call the tool is present.

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 describes all 7 parameters with full detail, so the baseline is 3. The description's note that pie and doughnut accept only 1 series is already present in the schema's series description, adding no additional semantic value.

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

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

The description states a specific verb ('Turns'), a resource ('labels and numeric series'), and a concrete output ('chart image'). It also explicitly lists supported chart types, making the tool's function unambiguous and easily differentiated from 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 provides clear context: chart generation from data without a browser, and the pie/doughnut one-series limitation guides correct usage. However, it does not explicitly name alternative tools or state when not to use this tool, so it stops short of full explicit 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 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?

Annotations already mark the tool as idempotent and non-destructive, but the description adds genuinely useful behavior beyond that: the credit cost, the temporary download link with a 15-minute validity, and the effect of `flatten=true` making the result non-editable. This gives an agent practical expectations for side effects and outputs.

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 a one-line summary first and practical details (credit cost, link expiry) after. The first sentence partially duplicates the title and the second sentence, but the overall structure is tight and every remaining sentence contributes useful information.

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

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

Given there is no output schema, the description adequately explains the two main return behaviors: a list of fields when inspecting, and a temporary download link when filling. It also covers cost and link validity. It could mention failure modes or how the field list is structured, but for a moderate-complexity tool the essential calling context is present.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description reinforces the role of `data`, `inspect`, and `flatten`, and adds the meaningful nuance that omitting `data` triggers field listing. However, it does not add substantial syntax or formatting details 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 states a specific action, 'Fill a PDF form', and names the exact resource (an existing AcroForm PDF) plus the input `data`. It also clearly separates the secondary inspection mode ('or list its fields'), which distinguishes it from sibling PDF tools that merge, split, rotate, or watermark.

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: fill a PDF form with values, or list form fields when no `data` is provided / `inspect=true`. It does not explicitly name alternative sibling tools or state when not to use it, but the unique function and clear mode conditions are enough for an agent to route 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 indicate the operation is idempotent and non-destructive. The description adds valuable behavioral context beyond annotations: each call costs 1 credit and the result is a temporary download link valid for 15 minutes. This helps the agent set expectations about side effects and output lifetime.

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 function. The first sentence repeats the tool title, which is slightly redundant, but the following sentences about character limit, cost, and link expiry are all useful and keep the description lean.

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 no output schema, the description adequately explains the return value (a temporary download link) and its validity period. It also covers cost, which is important for agent decision-making. Minor gaps like error behavior or format-specific caveats are not critical for this simple 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 all seven parameters are already documented in the input schema. The description does not add parameter-level meaning beyond the schema, which is acceptable given the baseline of 3 for full schema coverage.

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

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

The description clearly states the tool converts a link or any text into a QR code, with a max length and output formats implied by the title. This is a specific verb+resource that distinguishes it from all 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 implies usage: use this when you need a QR code from a link or text. However, it gives no explicit guidance on when not to use it or which alternative tool to prefer, and there are no exclusions or prerequisites 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?

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?

The description discloses critical non-obvious behaviors: JavaScript is not executed, external fonts/images are allowed, each call costs 1 credit, and the result is a temporary download link valid for 15 minutes. These details go well beyond the sparse annotations and materially affect how an agent should invoke and handle the tool.

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?

Every sentence earns its place: capability, rendering constraints, use cases, mode selection, cost, and output lifetime. It stays compact despite the tool's 10-parameter surface and front-loads the core purpose.

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

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

With no output schema and a complex 10-parameter tool, the description supplies the missing integration-level facts: what the call returns, how long the link lasts, the credit cost, and rendering caveats. Combined with the fully described schema, it gives an agent enough to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds cross-parameter guidance by explaining the html-or-template+data decision and linking to the template catalog. It avoids repeating field-level details, which the schema already covers well.

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

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

The title and opening line state exactly what the tool does: render HTML into an image in PNG, JPEG, or WebP. It distinguishes itself from siblings like html_to_pdf and screenshot_url by emphasizing HTML input, inline CSS, no JavaScript execution, and image output.

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

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

It gives explicit ideal use cases ('social cards, certificates, tickets, OG images') and explains the two invocation modes: raw html or template + data. It does not explicitly name sibling alternatives or when to choose html_to_pdf or screenshot_url instead, so it misses clear 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?

The description discloses important behavioral traits beyond annotations: no JavaScript support, inline CSS/web fonts/images allowed, cost of 1 credit per call, and a temporary download link valid for 15 minutes. The idempotentHint annotation is consistent with the description's stateless rendering behavior. It doesn't mention failure modes or rate limits, but the disclosed constraints are valuable for an agent.

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 purpose first, then constraints, then usage modes, then cost and output. Every sentence earns its place, and the structure guides the agent from what to how to what to expect.

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 9 parameters, 100% schema coverage, and no output schema, the description covers the key contextual gaps: rendering limitations, cost, and download link expiry. It doesn't explain the return format in detail, but the 'temporary download link' statement is sufficient for an agent to know what to expect. The template URL is also provided for the template parameter.

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 all 9 parameters. The description adds a few useful semantics: the 'invoice' template works well as a PDF, and the data parameter is plain text with escaping. However, it doesn't add much beyond the schema's parameter descriptions, 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?

The description clearly states the tool converts HTML to PDF, lists concrete use cases (invoices, reports, tickets, contracts), and distinguishes it from the sibling html_to_image by noting the same rendering engine as /capture. The verb 'renders' plus the resource 'HTML into a PDF' makes the purpose unambiguous.

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

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

The description gives clear context on when to use it (rendering HTML to PDF) and mentions the alternative template mode. It doesn't explicitly name sibling alternatives like html_to_image or images_to_pdf, but the use cases and rendering constraints imply when this tool is appropriate. It also notes the 'invoice' template works well as a PDF, which is a helpful usage hint.

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, it discloses an operational cost ('Costs 1 credit per call'), the return behavior ('temporary download link valid 15 minutes'), and the page-size behavior ('auto' vs fixed sizes). These are non-obvious behavioral details that an agent needs and that annotations do not encode.

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 definition is short, front-loaded with the core behavior, and uses line breaks to separate the page-size explanation, credit cost, and return link. The opening phrase repeats the title, so it is not perfectly economical, but no filler remains.

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

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

Given the high schema coverage and annotations, the description covers what an agent needs to call it safely: input format/count, page-size options, cost, and download-link expiry. Without an output schema, the explicit return description closes the main gap.

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

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

Schema coverage is 100%, so the schema already documents both parameters, including the base64 encoding, image count, and page_size enum values. The description restates the count and page-size behavior but adds little semantic value beyond the schema.

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

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

The description uses a specific verb-resource framing ('Turns 1 to 20 PNG/JPEG images into a PDF') and explicitly states one image per page, which distinguishes it from siblings like merge_pdfs and pdf_to_images. It also covers page sizing, input count, formats, credit cost, and returned artifact.

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 applicable scenario clear: when a user has PNG/JPEG images and wants a PDF with one image per page. It does not explicitly name alternatives or say when not to use it, but the input format and output behavior are 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 cover idempotency and non-destructiveness. The description adds genuinely useful operational behavior beyond those annotations: it costs one credit per call and returns a temporary download link valid for 15 minutes. It does not mention file-size or processing limits, but no contradiction exists.

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. However, 'One credit regardless of how many files' and 'Costs 1 credit per call' are redundant, so not 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 one-parameter tool, the description covers purpose, ordering, pricing, and output link expiry. The min/max count is already in the schema, and there is no output schema requiring explanation, so no major contextual gap remains.

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

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

Schema coverage is 100%, and the schema already documents that files are base64-encoded PDFs in order. The description reinforces the order requirement, but does not add substantial new meaning beyond the schema.

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

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

The description clearly states it merges 2 to 20 PDF files into one with a specific verb and resource. However, it does not explicitly contrast itself with sibling PDF tools such as split_pdf or images_to_pdf, though its uniqueness is fairly evident.

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

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

Usage is implied: call this when several PDFs need to be joined in order. It does not explicitly state when to prefer an alternative or when not to use this tool, but the core use case is reasonably clear 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?

Annotations already indicate this is a mutating, idempotent, non-destructive operation. The description adds valuable behavioral detail beyond the annotations: it costs 1 credit per call, and responses are temporary download links valid for 15 minutes. It 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 front-loaded: the core purpose is stated first, the read/write mode switch follows, and cost/return details are separate and brief. Every sentence earns its place with 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?

Given the rich schema and annotations, the description covers the main operational details: mode selection, credit cost, and the temporary download link. A small gap remains: it is not entirely explicit whether the read mode returns metadata values directly or also returns a download link, since the return-link sentence could be read as applying only to the written PDF.

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 all parameters. The description adds the key behavioral distinction that omitting metadata fields triggers a read while supplying any field triggers a write, but it does not add substantial per-parameter meaning beyond the schema.

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

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

The description clearly states the operation: read or write PDF metadata, and enumerates the exact fields involved (title, author, subject, keywords, creator, producer, dates). It does not explicitly contrast itself with sibling PDF tools like extract_pdf_text, but the 'metadata' scope makes the purpose unambiguous.

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

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

The description gives clear conditional usage: with no metadata fields supplied it reads; with any field supplied it writes. It provides clear context for when each mode applies, though it does not explicitly state when to prefer another sibling tool over this one.

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

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

The description adds valuable behavior beyond the annotations by disclosing a hard cost ('1 credit per call') and a temporary 15-minute download link. It also translates `scale` into DPI values, which is useful operational context not captured by 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?

Four short sentences, each earning its place: purpose, page/scale behavior, cost, and return artifact. Key details are front-loaded, and there is no redundant restating of schema fields.

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 no output schema, the description adequately explains the return artifact and its expiry. A minor gap is that it does not clarify whether rendering multiple pages produces one link or multiple links, which could affect how an agent consumes the result.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by explaining the `scale` parameter in terms of DPI (1 = 72 dpi, 2 = 144 dpi) and clarifying that `pages` overrides the all-pages default.

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 ('PDF pages') with output format PNG, and clarifies the optional `pages` scope. This makes it immediately distinguishable from siblings like `images_to_pdf` and `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?

Usage is implied by the title and operation: an agent can infer this is the tool to use when PDF pages need to become PNG images. However, it does not explicitly state when to prefer this over alternatives such as `screenshot_url` or `html_to_image`, nor provide exclusion conditions.

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

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

The annotations declare idempotentHint=true, but the description says 'The PDF must not be protected already.' After a successful call, a repeated identical call would fail because the PDF is now protected, which contradicts idempotency. Per the rubric, a description that contradicts annotations receives a score of 1.

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 well-structured: it states the core action first, then the encryption behavior, a precondition, cost, and return value. Every sentence contributes essential information with no redundancy or filler.

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

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

For a simple two-parameter tool with no output schema, the description covers the input, a key precondition, the credit cost, and the nature of the return value (temporary download link with 15-minute validity). It is mostly complete, though it does not describe the error behavior if the PDF is already protected.

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 parameters are already documented in the input schema. The description adds no extra meaning about file format, password constraints, or parameter relationships beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Add a password to a PDF' and 'Encrypts the PDF so it asks for the password when opened.' This clearly identifies the operation and distinguishes it from the sibling unprotect_pdf 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 gives a precondition ('The PDF must not be protected already') but provides no guidance on when to use this tool versus alternatives. It does not mention unprotect_pdf or any condition under which another sibling tool would be more appropriate, so an agent gets no routing help.

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 useful behavioral context beyond the annotations: rotation is added to existing page rotation, each call costs 1 credit, and the result is a temporary download link valid for 15 minutes. This meaningfully informs the agent about side effects and output behavior without contradicting 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 three sentences with no filler. It front-loads the core purpose, then adds cost and return-link details, each sentence earning its place.

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

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

For a simple three-parameter tool with no output schema, the description covers the essential context: what it does, how parameters behave, cost, and return value. It could mention error cases or file size limits, but nothing critical 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%, so the baseline is 3. The description adds extra semantic value by explaining that the angle is added to each page's existing rotation, which clarifies how the `angle` parameter behaves beyond the schema's enum and default.

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 it specifies that it can act on all pages or a subset. It is distinct from sibling PDF tools by naming the rotation operation, though it does not explicitly contrast itself with any sibling.

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

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

The description implies when to use the tool: whenever pages of a PDF need rotating. It does not explicitly state when not to use it or mention alternative tools, so usage guidance is present only by implication rather than by explicit 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?

The description adds meaningful behavior beyond annotations: it costs 1 credit per call, returns a temporary link valid for 15 minutes, uses a real browser, and blocks private networks. These details help the agent understand side effects, constraints, and output handling.

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 well-organized into behavior, constraints, cost, and return value. It loses a point because the opening phrase largely repeats the tool title, though the remaining content 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 all 7 parameters fully documented in the schema, the description covers the essential operational context: how the URL is loaded, cost, network restrictions, and the temporary-link return behavior. No critical gap prevents 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% and each parameter already has clear descriptions, ranges, defaults, and format details. The description adds only the general public-URL and network-blocking context, not new per-parameter meaning.

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

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

The description clearly states the tool loads a public URL in a real browser with JavaScript enabled and takes a screenshot. It names a specific resource ('public web page') and action, and the phrase 'public URL' distinguishes it from tools that convert local/HTML input.

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

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

The description implies usage for publicly accessible web pages by explicitly blocking private networks and internal addresses. However, it does not name alternatives like html_to_image or transform_image, nor does it state when to prefer this tool over them.

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

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

Annotations 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 (readOnlyHint=false, idempotentHint=true), the description adds meaningful context: credit cost per call, that cost is independent of output count, and that the result is a temporary download link valid for 15 minutes. This helps manage agent expectations around side effects and output lifetime, and nothing contradicts 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 front-loaded with purpose, then examples, then cost, then output details. The only flaw is redundancy: 'One credit regardless of how many files come out' and 'Costs 1 credit per call' say nearly the same thing twice.

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

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

Given there is no output schema, the description appropriately explains the return is a temporary download link and its validity. It covers purpose, input format, indexing, output count, cost, and link expiration. A minor gap is not specifying whether multiple output PDFs are delivered as a zip or list through the link.

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 both parameters and their examples, so the baseline is 3. The description adds value by clarifying that pages are 1-indexed and introducing the per-page enumeration pattern ('1,2,3'), which is not explicitly in the schema.

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

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

The description leads with a specific verb and resource: 'Split a PDF by page ranges.' It immediately states the output ('Creates one PDF per range') and clearly distinguishes itself from sibling tools like merge_pdfs by the essential opposite 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 provides concrete examples of valid range inputs ('1-3,5,7-9'), explains 1-indexed pages, and gives a pattern for one-file-per-page. While it doesn't explicitly name alternatives or exclusions, the usage context is clear enough for an agent to select this tool for splitting.

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 the 1-credit cost and the temporary download link validity (15 minutes). These are non-obvious behavioral facts critical for an agent's decision-making and not available from the schema or annotations. No contradiction with annotations exists.

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 crisp sentences, each providing essential info: core operation, requirement, input formats, cost, and output behavior. No filler, front-loaded with the primary purpose, and structured for quick comprehension.

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

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

Given schema covers parameters fully, annotations cover idempotency/destructiveness, and description covers cost, output link expiry, and input formats, nothing an agent needs to correctly invoke the tool is missing. The absence of an output schema is mitigated by the explicit return 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%, so baseline is 3. The description adds valuable cross-parameter constraints ('Provide at least one of width, height, format or quality') and lists accepted input formats, both of which go beyond the schema. It does not repeat schema descriptions, 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 states specific operations (resize, convert, compress) on a clear resource (ONE image), and explicitly lists conversion formats and input formats. It is readily distinguished from all sibling tools, which target PDFs, HTML, QR codes, etc., making the tool's unique purpose unambiguous.

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

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

It gives clear context: the tool handles a single image and requires at least one of width, height, format, or quality. It does not explicitly name alternative tools for exclusion, but the operation space is so distinct from siblings (PDF manipulation, HTML conversion, ZIP creation) that an agent is unlikely to confuse them. No explicit when-not-to-use guidance is provided.

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 destructiveHint false, but the description adds valuable operational details: it costs 1 credit per call, returns a temporary download link valid for 15 minutes, and produces an unencrypted copy (implying the original is untouched). These go beyond the structured fields and set accurate expectations for 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 three sentences with zero fluff. It front-loads the core action and condition, then adds the essential operational constraints (cost, result, link validity). Every sentence earns its place; no redundant text.

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 only two parameters and no output schema, the description fully covers what an agent needs to know: the action, the input requirements, the cost, the return type, and the result's validity period. 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% — both 'file' and 'password' are fully described in the schema. The description does not add extra parameter-specific details beyond the schema, but it doesn't need to because the schema already conveys the meaning. Baseline 3 is appropriate when the schema carries the load.

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

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

The description clearly states the action ('Remove the password of a PDF'), the resource (a PDF), and the key condition (you must know it). It explicitly distinguishes itself from password-cracking by saying 'It does not crack passwords', which differentiates it from any hypothetical brute-force tool and clarifies its scope among PDF 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 provides clear usage guidance by stating the prerequisite ('you must know it') and the non-capability ('does not crack passwords'). This tells an agent when NOT to use it (if the password is unknown). It doesn't explicitly name the alternative protect_pdf, but the sibling list makes the reverse operation obvious, so the guidance is sufficient.

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

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

The description 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 adds valuable behavioral details beyond the annotations: cost per call (1 credit), temporary download link validity (15 minutes), and the JSON body requirement for image watermarks. It also clarifies the default overlay behavior (every page). This goes beyond readOnlyHint/idempotentHint/destructiveHint and is not contradictory.

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 (three sentences) and front-loaded with the action. It efficiently includes cost, link validity, and the JSON body note without unnecessary elaboration. Slightly dense but well-structured 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?

Given the tool's complexity (10 parameters), the description covers the key operational aspects: cost, return format (download link), and the JSON body constraint for images. It does not explicitly state that the output is a PDF, but that is implied. The schema handles parameter details, so the description is adequate 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?

The input schema provides descriptions for all 10 parameters (100% coverage), including max text length, image format, scale, opacity, and position. The description repeats some of these (e.g., max 200 characters, PNG/JPEG), but adds no extra parameter semantics. The baseline score of 3 is appropriate because the schema carries the parameter documentation.

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

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

The description clearly states the action: 'Add a text or image watermark to a PDF.' It specifies the resource (PDF) and the two watermark types, and notes the overlay behavior (every page or specified pages). This distinguishes it from siblings like pdf_to_images or merge_pdfs, which have different purposes.

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

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

The description provides useful context: image watermarks require a JSON body, the call costs 1 credit, and it returns a temporary link. However, it does not explicitly contrast this tool with alternatives or state when not to use it. The tool name and role carry most of the load for selecting it.

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