Wandlix

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds only 'Returns the result file', which implies a new output file rather than in-place mutation — useful but thin; it says nothing about processing time, page limits beyond the schema's 50 MB, or whether the source file is preserved.

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

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

Two short sentences, front-loaded with the action, with zero filler. The customization note follows immediately and the return behavior closes it out.

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 file-transform tool with fully documented parameters and no output schema, the description covers the essentials: accepted input type and that a result file is returned. Only the fate of the input file and any output naming convention are left unstated.

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 echoes three of the five option fields (position, format, start) but omits 'from' and 'size', adding no semantics the schema does not already carry.

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 ('Number the pages of a PDF') plus the customizable dimensions, which is far more concrete than the title alone. No sibling does page numbering, so there is little risk of confusion, but the description never explicitly contrasts itself with related tools like watermark-pdf or text-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?

'position, format and start number are up to you' hints at configurability but gives no when-to-use / when-not-to-use guidance and names no alternative. An agent gets no help deciding between this and, say, watermark-pdf for stamping content onto pages.

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 non-read-only, non-destructive, non-open-world, and the description adds that it 'Returns the result file' – useful since there is no output schema. However it omits the 50 MB / 10-file limits, the fact that a new file artifact is produced, and any mention of the options that materially change output.

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, front-loaded with the core purpose, which is good. But the middle sentence 'Accepts *' is a garbled artifact that wastes a sentence slot and is the most prominent missing piece of information.

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

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

For a tool with encode/decode modes, url vs standard alphabet, wrapping options, and multiple input methods (upload_id vs content_base64), the description covers none of this. With no output schema, the return value is only vaguely described, leaving the agent to read the schema for everything operationally important.

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 would be 3, but the only parameter-related sentence is the broken fragment 'Accepts *', which reads as a truncated copy of the schema text and conveys nothing. The description adds no meaning about mode, wrap, variant, or uri 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 concrete verb+resource pair ('Encode a file as Base64 text, or decode Base64 text back into a file') and covers both directions of the operation. It does not distinguish itself from the sibling convert-encoding, which plausibly overlaps, so it stops short of a 5.

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

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

No guidance on when to choose this over convert-encoding or convert-data, which are the obvious alternatives in the sibling list. The encode/decode framing implies usage but no conditions, prerequisites, or exclusions are given.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false; the description usefully adds that the tool 'returns the result file', implying a new output rather than an in-place overwrite. It says nothing about what compression actually does (lossy/lossy-lossless tradeoffs, how quality 75 affects output, whether the original is preserved), so it adds only modest context above 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?

Three short sentences, front-loaded with the core action and the format list. The second sentence largely restates the first (only adding 'jpeg'), so there is a small amount of redundancy, but nothing bloated.

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 batch file-mutation tool with nested objects and no output schema, 'Returns the result file' is the only return-value signal and it is vague — file objects? URLs? base64? Nothing indicates the output shape or whether files are downloadable, and no mention of size/quality side effects, leaving a meaningful gap for an agent chunking a multi-file workflow.

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 nested file fields (upload_id vs content_base64) and the 50 MB / maxItems limits are already documented structurally. The description adds no meaning for the non-obvious `options.quality` (30–95, default 75) or `maxWidth` (default 0 = presumably no limit) parameters, so the baseline 3 applies.

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

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

States a specific verb+resource ("Make JPG, PNG and WebP files smaller") and names the supported input formats, so an agent can tell it apart from convert-image or edit-image on the basis of intent. It stops short of explicitly contrasting itself with those siblings, which is the only thing separating it from a 5.

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

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

Usage is only implied: 'make files smaller' plus a format restriction that tacitly rules out PDFs (compress-pdf) or conversions (convert-image). There is no explicit when-to-use statement, no exclusion, and no named alternative the agent should consider instead.

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

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

Annotations already declare the non-read-only, non-destructive, closed-world profile, so the safety bar is lower. The description adds that it accepts PDFs and returns a result file, but it says nothing about quality loss from compression, whether the original is preserved, or how output is delivered (file, link, base64) — meaningful gaps for a mutation 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?

Three short sentences, zero padding, with the purpose front-loaded. The staccato 'Accepts pdf. Returns the result file.' is efficient though slightly telegraphic.

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

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

The tool has nested input objects and no output schema, so the description carries the burden of describing the return value; 'Returns the result file' is minimal and doesn't say whether that is a link, an upload id, or base64 content. Adequate but leaves a real gap for a file-producing 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 'files', 'upload_id', 'content_base64' and the size cap. The description adds nothing about the 'level' enum (low/medium/high) or its effect on output quality/size, so baseline 3 is appropriate.

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

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

States a specific verb and resource ('Make PDF files smaller') and implicitly distinguishes itself from compress-image by restricting to PDFs. It is clear what the tool does, though it never names a sibling as the alternative path.

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 phrase 'for e-mail and uploads' gives a motivating use case, but there is no guidance on when to pick this over compress-image, pdf-to-pdfa, or other reduction paths, and no stated exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false. The description adds useful context that it accepts multiple data formats and returns the result file, but does not explain whether source files are preserved, how output files are named, or how multiple input files are handled.

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

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

Two sentences with no wasted text. The conversion direction and accepted formats are front-loaded, and the return behavior is stated compactly.

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 conversion tool with complete schema coverage and no output schema, the description covers the core operation, accepted formats, and return file. The remaining details, such as option semantics and multi-file handling, are adequately delegated to the schema.

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

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

Schema description coverage is 100%, so the schema already documents the file object, upload_id/content_base64 alternatives, and all conversion options. The description adds the accepted file extension list but does not clarify option behavior beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb and resource: convert data files between JSON, CSV, XML and YAML in any direction. The scope is clear and an agent can distinguish it from narrower sibling converters such as csv-to-excel or excel-to-csv, though the description does not explicitly name those alternatives.

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

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

Lists accepted input formats but gives no guidance on when to use this tool instead of sibling converters like csv-to-excel, excel-to-csv, convert-office, or text-to-pdf. The agent must infer applicability from the purpose alone.

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 a non-read-only, non-destructive, non-open-world operation, and the description adds that the result file is returned, which is useful output context. It does not clarify whether the source file is modified, whether conversion is lossy, or how the result is delivered (new upload vs. base64).

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

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

Two sentences are tight and front-loaded, but the middle sentence 'Accepts *.' is a truncated fragment that carries no meaning without the schema and wastes a line. Overall it is short but not fully polished.

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 nested-object tool with multiple enum options and no output schema, the description covers the core action and the fact that a file comes back, which is the minimum viable. It omits the newline normalization capability and any note on how the returned file is presented to the caller.

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 the file input mechanism and the enum-bearing options object are already documented in structured fields. The description contributes nothing about the 'to'/'from'/'newlines' options, and its 'Accepts *.' fragment merely echoes the schema's 'Accepts *; at most 20 MB' note.

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+resource ('Convert a text file') and names the relevant character sets, which clearly separates it from sibling converters like convert-data, convert-image, and convert-office. It stops short of explicitly naming those siblings as alternatives.

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

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

There is no guidance on when to use this versus convert-data or text-to-pdf, and no mention of prerequisites such as supplying either upload_id or content_base64. The agent must infer usage entirely from the name and schema.

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 it is not read-only, not destructive, and closed-world. The description adds one genuinely useful behavioral fact beyond them: it returns a result file rather than inline data. It omits anything about credit cost, batching of up to 20 files, or what happens to the original file.

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, front-loaded sentences with no padding. The accepted-format enumeration duplicates the schema's own files description, which is the only real waste.

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 should explain the return value, but 'Returns the result file' is vague about whether that is a name, a link, or embedded content — and for a multi-file input it's unclear whether one or many files come back. Otherwise adequate for a simple two-parameter tool.

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

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

Schema coverage is 100%, so parameters are already documented, establishing a baseline of 3. The description restates the input format list from the schema and mentions only JPG/PNG/WebP as targets while the schema enum also allows avif, and it never mentions the quality setting — slightly underselling the tool's 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?

Names a specific verb and resource ('Convert between JPG, PNG and WebP') and enumerates the accepted input formats, so the agent knows exactly what the tool does. It doesn't explicitly contrast itself with close siblings like compress-image, edit-image, or pdf-to-image, so differentiation is only partial.

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 format list — an agent can infer this is the tool for changing an image's container format. There is no explicit statement of when to prefer it over compress-image, edit-image, or ocr-image, and no prerequisites are mentioned.

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 this is a non-read-only, non-destructive, closed-world operation, so the safety bar is lower. The description adds only the return behavior ('Returns the result file'), which is vague about shape, and says nothing about failure modes for unsupported conversion pairs, processing latency, or where the result file is stored.

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

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

Two short sentences, front-loaded with the conversion purpose followed by the format inventory and return behavior. No redundant or filler text; the format list is the one place where enumeration is genuinely useful.

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

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

The tool is simple (2 params, high schema coverage) and the format enumeration is adequate, but with nested file objects and no output schema, the description should clarify what 'the result file' means and how upload_id vs content_base64 affects the response. Usable but leaves the agent guessing about the return value.

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, and the baseline applies. The description contributes the accepted input extension list, but it never mentions the options.target field, so an agent gets no help understanding that the output format is chosen there or which pairs are legal.

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 (convert Office files) and enumerates the accepted input formats, which lets an agent separate it from PDF-oriented siblings like word-to-pdf or pdf-to-word. It never names a sibling explicitly, so the differentiation is inferred from the format list rather than stated.

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 phrase 'between Microsoft and OpenDocument formats' implicitly excludes PDF and CSV conversions, so an agent can infer that excel-to-csv or word-to-pdf is the right tool for those. There is no explicit when-to-use, when-not, or prerequisite guidance (e.g., which conversions are actually valid pairs).

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 non-read-only, non-destructive, closed-world write behavior. The description adds two useful traits — immediate validation feedback and a JSON report return — but omits how the generated file is delivered (link, base64, attachment), whether the operation costs credits, and what the JSON report contains.

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

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

Two short, front-loaded sentences with no filler. Slight loss because the 'or ZUGFeRD PDF' phrasing conflates format options already enumerated in the schema and could mislead about XML-only output.

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 input side is thoroughly documented by the schema, but with no output schema and a complex nested payload, the description should say more about the returned JSON report and the generated document artifact. 'Returns a JSON report' is the only return-value information given.

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 nested descriptions (UN/ECE units, VAT category rules, Leitweg-ID, date formats). The description itself contributes no parameter-level meaning, so the baseline 3 applies since the schema does all the work.

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

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

States a concrete outcome: supplying invoice data yields a valid XRechnung or ZUGFeRD document that is validated. This clearly distinguishes it from siblings like validate-einvoice, einvoice-to-pdf, and extract-einvoice-xml, though the phrasing 'get a ... PDF' is slightly inaccurate since the xrechnung format returns XML only.

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

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

No explicit when-to-use or when-not-to-use guidance, and no named alternatives. The agent must infer from sibling names whether to create here versus validate a pre-existing invoice or convert one to PDF; 'checked right away' only hints that validation may be bundled.

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

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

Annotations already declare readOnlyHint=false but destructiveHint=false, and the description adds real behavioral context beyond that: a 60-minute TTL, memory-only holding, and deletion after a successful tool call. It does not mention auth requirements, file size limits, or what happens on expiry/failure, so it is strong but not exhaustive for a resource-creating 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?

Three sentences, zero filler, each carrying distinct information: purpose first, then lifetime/persistence, then return values and how to use them. Front-loaded and appropriately sized.

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

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

There is no output schema, and the description compensates by naming both return fields (upload_url with its HTTP PUT contract, and upload_id) plus their downstream use. For a single-parameter tool this covers everything needed to call and consume 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?

With one parameter at 100% schema description coverage, the schema already documents name (including the extension, with an example). The description only says "one file" and adds no constraint or format detail beyond the schema, 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?

"Reserves a single-use upload link for one file" names a specific verb, resource, and cardinality constraint. None of the sibling tools create upload links, so the agent can immediately tell this is not a file-conversion 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 states how the result is consumed: upload_id can replace content_base64 in the files argument of the file tools, which implicitly routes the agent away from inline base64. It never explicitly says when to prefer this over the base64 sibling or what size/type limits apply, so it falls short of a full when/when-not statement.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds only "Returns the result file" and says nothing about whether the source document is preserved, how the crop margins are measured, or whether pages are selectively processed.

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 the core action front-loaded and no filler. It is efficient, though the choppy fragments ("Accepts pdf.") could have carried more substance at the same length.

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 a nested options object, a free-form page-selection string, and no output schema, the description should explain margin units, page-range syntax, and what the returned file is. None of that is present, so an agent must guess at the core geometry semantics.

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 high, so the baseline is 3. However the four margin integers carry no unit or meaning in either schema or description, and the free-form "pages" string has no documented syntax, so the description does not compensate for those real semantic 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?

"Cut margins off PDF pages" names a specific verb and resource, and the crop operation is distinguishable from siblings like compress-pdf or rotate-pdf by name alone. It stops short of explicitly contrasting with those siblings, but the purpose is unambiguous.

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

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

There is no guidance on when to choose this over compress-pdf, pdf-to-image, or other page-geometry siblings, and no prerequisites or exclusions are stated. "Accepts pdf" is an input constraint, not usage guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the mutation/safety profile is covered structurally. The description adds two useful traits beyond that: the result is a file ('Returns the result file') and separators/numbers are auto-recognised. It does not mention the 50 MB / 10-file limits (left to the schema) or what happens on a malformed row.

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 clauses, zero filler: the conversion action comes first, then the accepted formats, then the return behaviour. Nothing is repeated from the schema and nothing is wasted.

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

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

For a straightforward one-way converter with full schema coverage and no output schema, the description covers input, behaviour and output shape ('result file'). Minor remaining gap: it does not say the output is an .xlsx or how sheets are named, which an agent composing a follow-up call might want.

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 would be 3; the description earns a point because 'separator and numbers are recognised' actually explains the intent of the delimiter and decimal options, whose 'auto' defaults are otherwise opaque enums with no per-value explanation in the schema. It still does not describe the upload_id vs content_base64 trade-off, though the schema does that 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?

States a specific verb and resource pair: 'Turn CSV files into Excel workbooks', with the accepted input formats spelled out. An agent can immediately tell it apart from the many other converters because the direction is explicit. It does not name the reverse sibling (excel-to-csv) or the near-neighbour convert-data, so sibling differentiation relies on the tool name alone.

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?

'Accepts csv, tsv, txt' implies when the tool applies: plain delimited text in, workbook out. However there is no explicit when-not guidance, no mention of when convert-data or numbers-to-excel would be the better choice, and no stated prerequisites about how files must be supplied.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so safety is partly covered, but the description adds only 'Accepts pdf. Returns the result file.' It never says whether the original file is preserved, whether the output is a new file or a download link, or what happens if a requested page index is out of range.

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, front-loaded sentences with the action first. 'Accepts pdf' is largely redundant with the schema's file constraints and item type, so a small amount of space is not 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 one-required-parameter tool with a nested files object and no output schema, the description covers the input kind and that a result file is returned. It is still incomplete on the one thing that determines correctness: how to express which pages to delete.

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 declared schema coverage is 100%, but the critical `pages` option carries only a default of "" and no descriptive text anywhere — the accepted syntax (e.g. "1,3,5-7" vs "2-") is not specified in the schema or the description. Since page selection is the whole point of the tool, the description should have compensated here and does not.

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

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

The description gives a specific verb and resource — remove pages from a PDF — which is clearly distinct from siblings like split-pdf, reorder-pdf and rotate-pdf. It does not explicitly name a sibling to contrast against, but the operation itself is unambiguous.

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

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

There is no guidance on when to use this versus alternatives such as split-pdf (which can also drop pages by selecting a subset) or reorder-pdf. No prerequisites, no constraints on what kinds of PDFs are supported beyond the size limit already in the schema.

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 non-read-only but non-destructive and closed-world, so the safety profile is given. The description adds the format whitelist and 'returns the result file', hinting that the original is not replaced, but it never explains whether the result comes back as a URL, base64, or upload reference.

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

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

Two short sentences, front-loaded with the action and with zero filler. The format list is somewhat redundant with the schema but is cheap and useful up front.

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 a 10-field nested options object, no output schema, and annotations covering safety, the definition is adequate but thin: trim/rotate/aspect interactions and the shape of the returned file are never addressed. An agent could still call it correctly by relying on defaults.

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 reported at 100%, so the baseline of 3 applies. The description adds nothing about the options object, leaving semantics like trimTop/trimLeft units (implied percentages by the 0-45 bound) and quality's effect on output entirely to inference.

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?

Concrete verbs (rotate, flip, crop) plus the resource (images) make the operation unmistakable. However, it draws no boundary against siblings like convert-image, compress-image, or crop-pdf, so an agent must infer that format conversion is out of scope here.

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

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

There is no statement of when to pick this over convert-image or compress-image, and no prerequisites or exclusions. An agent that needs both a format change and a rotation has no guidance on whether this tool covers both.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds that a result file is returned, but says nothing about how the output is delivered (link, base64, temporary storage), whether it persists, or cost/limits beyond what the schema states. 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 short, front-loaded sentences with no filler: purpose first, then input/output summary. The phrase 'Accepts pdf, xml' is slightly telegraphic but does not waste space.

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

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

For a nested-input conversion tool with no output schema, 'Returns the result file' is too thin — the agent cannot tell whether it receives a URL, a base64 blob, or a reference. Input side is adequately covered by the rich schema, but the return contract is left underspecified.

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 meaning of files, name, upload_id, content_base64, and options.language is already fully documented in the schema. The description only reiterates accepted formats, adding no new parameter semantics. Baseline 3 applies.

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

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

States a specific verb and resource (turn XRechnung XML / ZUGFeRD into a PDF) and names the exact input formats, which cleanly separates it from siblings such as validate-einvoice, extract-einvoice-xml, and create-einvoice. An agent can identify this as the rendering/conversion step 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?

There is no statement of when to choose this over alternatives, no prerequisite (e.g. that the file must already be a valid e-invoice), and no exclusions. 'Accepts pdf, xml' is an input constraint, not usage guidance, leaving the routing decision 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?

Annotations already declare readOnly=false, destructive=false, openWorld=false, so the safety profile is covered. The description adds genuine value by clarifying that the output is a newly produced result file rather than an in-place modification of the source, which matters for a non-readOnly tool with no output schema.

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

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

Three short sentences, front-loaded with the action and no redundancy. The phrase 'with the separator you need' is mildly promotional but it does surface the delimiter option, so waste is minimal.

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 full schema coverage and no output schema, the description carries only the return-value burden, which it addresses with 'Returns the result file'. The exact shape of that return (link vs. inline content) remains vague, and multi-sheet behavior is left to the schema.

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

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

Schema coverage is 100%, with file-name, upload_id/content_base64 alternatives and nested option enums all documented in the schema. The description adds only a light hint at the delimiter option ('separator you need') and the format list; it does not explain sheets, decimal, or encoding choices, 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?

States a concrete verb and resource ('Save an Excel sheet as a CSV file') plus the accepted input formats, so an agent can distinguish it from csv-to-excel and convert-data by direction alone. It stops short of explicitly naming the inverse sibling, which keeps it at 4 rather than 5.

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 conversion direction and input formats imply when to use it, but there is no explicit guidance on when to prefer it over csv-to-excel, convert-data, or convert-office, and no stated prerequisites. Usage is inferable rather than directed.

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

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

Annotations already declare a non-read-only, non-destructive, closed-world operation, so the safety profile is covered. The description adds real value with 'Returns the result file' (helpful since there is no output schema), but omits other behavior such as whether output is a download link, batching semantics, or failure 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?

Two short sentences with zero filler, and the core purpose plus accepted formats are front-loaded. The trailing return-value note earns its place; the format list mildly duplicates the schema's own enumeration.

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 sentence 'Returns the result file' fills the most important gap for an agent deciding what to do next. Limits live in the schema, and annotations cover safety, so only minor details (delivery mechanism of the result) are left unstated.

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 files array, name/upload_id/content_base64 alternatives, and the 50 MB / max-5 limits are all documented in the schema. The description only restates the accepted formats, adding no syntax or format detail beyond structured data. Baseline 3 applies.

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

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

States a specific verb+resource pair ('Convert spreadsheets to PDF') and enumerates the accepted input formats, so the agent knows exactly the transformation performed. It does not contrast with near-neighbors like convert-office, excel-to-csv, or numbers-to-excel, but the name-plus-verb combination makes the target format unambiguous.

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

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

Usage is only implied: the agent can infer it should be used when a spreadsheet must become a PDF, and the accepted formats help it decide. There is no explicit when-not guidance or routing to convert-office for other document types.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false and openWorldHint=false; the description adds nothing to reconcile the non-read-only hint for what is conceptually an extraction. It does not say how the case of a non-compliant PDF is handled, nor what the 'result file' actually is (raw .xml, a zip, a link), which is the key behavioral unknown here.

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, front-loaded sentences with no padding. The last two sentences are thin, but they are not verbose.

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 must carry the return behavior, and 'Returns the result file' is too vague for an agent that needs to know whether it receives XML text, a base64 blob or a download reference. The failure mode for non-ZUGFeRD PDFs is also unaddressed.

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 the nested file object documents name, upload_id, content_base64, the 50 MB cap and the 10-file limit. The description only restates format acceptance ('Accepts pdf'), so the baseline 3 applies.

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

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

A specific verb+resource: pull the embedded invoice XML out of a ZUGFeRD/Factur-X PDF. It is clearly distinct from create-einvoice and einvoice-to-pdf by direction (extraction, not generation), though it never names those siblings explicitly.

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

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

No when-to-use guidance: nothing tells the agent to prefer validate-einvoice first, or what happens with a PDF that lacks an embedded XML. The only implied condition is the file being ZUGFeRD/Factur-X, which is stated as fact rather than as a selection rule.

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 the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description usefully adds what is actually returned (daily free allowance plus credits) but says nothing about whether the allowance resets, the units, or auth requirements — modest added value.

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

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

A single front-loaded sentence with no filler. Every clause carries information: the two returned quantities and whose account they belong to.

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

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

With no output schema, the description does the right thing by naming the returned values. It stops short of describing response shape (fields, units, whether allowance and credits are separate objects) or the auth context, which for a zero-parameter account tool would have made it fully self-contained.

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 tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies no inputs are needed.

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 ('Returns') and two concrete resources: the remaining free daily allowance and the account credits. An agent immediately knows this is an account-quota lookup, and no sibling tool touches balance/credits, so no sibling differentiation is needed.

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

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

Usage is only implied — an agent can infer it should call this when it needs to know remaining quota or credit balance, but the description never says so nor mentions prerequisites such as requiring an authenticated Wandlix account. No alternatives exist among siblings, so there is nothing to route against.

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 already establish that this is not read-only, not destructive, and does not reach beyond the sandbox; the description adds "Returns the result file" but does not say what form that takes or what limits apply. The 50 MB total limit and the 1-50 item range already appear in the schema, so the description adds little behavioral context of its own.

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 the core action front-loaded and nothing superfluous. The format enumeration is slightly redundant with the schema, but it takes up little space.

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

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

This file-producing tool has no output schema, and the description only says "Returns the result file" without saying whether the result is a link, an upload_id, or base64. That is the main gap for an agent trying to chain this tool into a pipeline; otherwise, coverage is adequate considering the rich input schema.

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

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

Schema description coverage is 100%, with per-field docs on name, upload_id, content_base64, and the allowed formats and size limit. The description's format list largely repeats the schema's files description and adds nothing about the options object (margin, pageSize), so the baseline 3 is right.

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 and resource ("Combine ... images into one PDF") and states what it returns, so it is clearly distinguishable from merge-pdf (PDFs) and convert-image (single-image format conversion). It never names those siblings explicitly, so differentiation comes from the wording rather than an explicit contrast.

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 offers no when-to-use guidance, no condition for choosing this over convert-image or merge-pdf, and no prerequisites for the file inputs (for example, when to pass upload_id versus content_base64). Usage is only implied by the verb.

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 it is a non-destructive write operation in a closed environment. The description adds that it accepts PDFs and returns a result file, but does not clarify what happens to input files, error behavior, or the exact return format. With annotations covering the safety profile, this minimal additional context merits a 3.

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

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

Two short sentences with zero waste, front-loading the core action before the input/output summary. 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?

The tool is simple and the input schema is fully described, but there is no output schema and the description only vaguely says 'Returns the result file' without specifying the return format (e.g., base64, URL, file object). This is a meaningful gap for an agent consuming 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 description coverage is 100%, so the schema fully documents the 'files' parameter including name, upload_id, and content_base64. The description only restates that it accepts PDFs and adds no parameter-specific details beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb ('Combine') and resource ('PDF files into one document'), making the operation unambiguous. The action is clearly distinct from sibling tools like split-pdf or reorder-pdf, so an agent can identify its role without 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 purpose implies when to use it (when PDFs need to be merged), but there are no explicit guidelines about alternatives, prerequisites, or when not to use it. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one useful behavioral fact — that a result file is returned — which matters because there is no output schema. It says nothing about the batch limit (max 5), the 50 MB cap, or how the output file is delivered, all of which matter for a non-destructive write-style 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?

Three short sentences, front-loaded with the core purpose and no wasted preamble. The middle sentence 'Accepts numbers' is the one weak spot — it is short but underspecified rather than genuinely informative.

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, 'Returns the result file' is a helpful minimum, and the simple one-parameter schema reduces the burden. However, for a file-producing conversion tool the description never says what the result file is (bytes, upload link, filename) or acknowledges the batch/size limits, leaving the agent to discover delivery semantics at call time.

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 the single 'files' parameter documents name, upload_id, content_base64, maxItems and the 50 MB limit inline. The description adds nothing beyond 'Accepts numbers', which reads ambiguously and does not clarify that the input is a Numbers spreadsheet file rather than numeric data. Baseline 3 applies.

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

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

States a specific verb and resource pair ('Turn Apple Numbers spreadsheets into Excel files'), which unambiguously identifies the conversion direction. It doesn't name siblings like csv-to-excel or convert-office, but the source/target formats make the distinction implicit. The filler line 'Accepts numbers' is vague phrasing that slightly muddies an otherwise crisp purpose statement.

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

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

No guidance on when to choose this over csv-to-excel, excel-to-csv, or convert-office, nor any prerequisites (e.g., file size/count caps are only in the schema). The agent must infer usage entirely from the verb and resource.

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 the safety profile (readOnlyHint false, destructiveHint false, openWorldHint false). The description adds useful context: accepted image formats, that it returns a result file, and that it can produce a searchable PDF. It lacks file-count and size limits, but there is no contradiction.

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

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

Two tightly written sentences, front-loaded with the core action and followed by format and return details. Every sentence contributes without redundancy.

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

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

Given the fully documented nested schema and annotations, the description is largely complete for selecting and invoking the tool. It omits details like the 10-file limit, 50 MB total, and output/language defaults, but those are already covered by the schema.

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

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

Schema coverage is 100%, so the schema already documents files, upload_id, content_base64, and options. The description adds little parameter-specific meaning beyond repeating accepted formats and the result-file return.

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: "Read the text from a photo or screenshot" plus the alternative searchable PDF output. The accepted image formats make the image-focused scope clear, but the description does not explicitly name the sibling ocr-pdf alternative.

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 "photo or screenshot" and the image format list, but there is no explicit when-to-use guidance versus ocr-pdf or pdf-to-text, and no stated 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 declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the mutation/safety profile is already covered. The description adds only 'Returns the result file', without saying whether the output is a new OCR'd PDF with a text layer, whether the file size/quality changes, or how long OCR takes on large documents.

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

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

Two short sentences, front-loaded with the purpose and followed by the input constraint. The closing sentence 'Returns the result file' is thin but not wasteful.

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

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

There is no output schema, so the description must carry the return-value burden; 'Returns the result file' is too vague about format and naming. With a nested, required-array input plus an undocumented language option, the definition is adequate but leaves real gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds nothing about the parameters, and notably never mentions the 'options.language' enum (both/deu/eng), which has no per-value documentation 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?

States a specific verb and resource: 'Make scanned PDFs searchable and copyable with text recognition', plus an explicit input constraint ('Accepts pdf'). It is clearly distinct from ocr-image by virtue of the PDF-only scope, though the description never names that sibling to reinforce the boundary.

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?

'Make scanned PDFs searchable' implies the input must be a scanned/image-only PDF, which is useful implied guidance. However, it gives no exclusions (e.g., don't use on already-text PDFs) and no routing toward ocr-image or pdf-to-text for adjacent needs.

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

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

Annotations already declare the operation non-destructive and non-read-only, so the safety profile is covered. The description adds that a result file is returned (valuable since there is no output schema), but it does not say how multi-page PDFs are handled, whether an output file persists, or anything about limits or auth.

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, front-loaded with the core action and output format. 'Accepts pdf' is mildly redundant with the schema but does front-load the input constraint, so almost 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 two-parameter conversion tool this covers the essential contract, and 'Returns the result file' compensates for the missing output schema. However, it leaves open how a multi-page PDF is packaged (one image per page? zip?) and whether page selection is supported, which an agent would need to know.

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 nested files array, upload_id vs content_base64 alternatives, and the options object are already fully documented. The description adds nothing about dpi, pages selection syntax, or format choice, so baseline 3 is appropriate.

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

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

States a specific verb and resource ('Save PDF pages as JPG or PNG images'), so an agent knows exactly what the tool produces. It does not differentiate itself from near-neighbor siblings such as convert-image or ocr-pdf, which keeps it below a 5.

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

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

Usage is only implied by the input/output types ('Accepts pdf', returns images). There is no explicit statement of when to choose this over pdf-to-text, ocr-pdf, or convert-image, and no prerequisites or exclusions are given.

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 destructiveHint=false, openWorldHint=false, and readOnlyHint=false, so safety is covered. The description adds the accepted-format inventory and states 'Returns the result file,' which tells the agent a new artifact is produced. It omits the PDF/A level choice and any note on processing behavior for a batch of up to 10 files.

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

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

Two short sentences: purpose first, then accepted inputs and the return value. Almost no waste, though the format list partially duplicates schema content rather than adding new information.

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

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

For a simple non-destructive converter with no output schema, the description covers what goes in, what comes out, and the archival intent. The main remaining gap is the meaning of the PDF/A level option and file-count/size behavior, which the schema hints at only partially.

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 the file-item structure (name, upload_id, content_base64) is fully documented, so the baseline is 3. The description merely repeats the format list already in the schema and adds nothing about the 'level' enum (1b/2b/3b), which is undocumented in both places — a missed opportunity.

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 first clause names the specific transformation (PDF/A archival conversion) and the accepted input families, so an agent can tell this apart from generic converters like convert-office or excel-to-pdf. It stops short of saying it always outputs a PDF file explicitly, but the title and 'long-term archiving (PDF/A)' make the target format 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 phrase 'ready for long-term archiving' implies the use case, but there is no explicit when-to-use versus alternatives such as convert-office, office-to-pdf, or compress-pdf, and no exclusions. The agent must infer that archival compliance (not mere format conversion) is the selection criterion.

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 declare it is non-destructive and closed-world, so the description must carry the rest. 'Returns the result file' is vague — no indication of whether the result is a URL, a base64 payload, or where the file lands — and there is no output schema to compensate.

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

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

Two short sentences, front-loaded with the verb and resource, with no redundant restatement of the schema. The phrase 'ready for AI tools' is mild marketing but takes little space.

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

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

Inputs are fully specified by the schema, so the main gap is output shape: 'Returns the result file' does not tell the agent whether it gets text inline or a handle to a file. With no output schema, that is a real omission but not a blocking 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 coverage is 100%, including the files array, upload_id/content_base64 alternatives and the 50 MB cap, so baseline 3 applies. The description adds 'Accepts pdf' but nothing about the pages selector or format default beyond what the schema documents.

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 ('Get the text of a PDF') plus the two output formats, so the agent knows exactly what comes back. It doesn't differentiate from close siblings like ocr-pdf or pdf-to-word, which is left to inference from the name.

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

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

No when-to-use or when-not guidance. The agent gets no signal about whether to choose this over ocr-pdf for scanned documents or pdf-to-word when a .docx is needed; only the tagline 'ready for AI tools' hints at intent.

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 cover the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the description's task is to add context. It does add two useful facts: output fidelity is approximate, and the result is returned as a file. It says nothing about failure modes (scanned PDFs, encrypted files) or that this is a non-destructive file-producing operation, which would help an agent set expectations.

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

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

Three short sentences with the core action front-loaded, zero filler, and the caveat placed immediately after the claim it qualifies.

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?

Return behavior is covered without an output schema, which is good, and the approximation caveat sets expectations. But for a conversion tool with a nested file-array input and a mode switch, the description omits what mode actually does and whether the 50 MB / 3-file limits or scanned documents are a problem, leaving meaningful gaps.

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

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

Schema coverage is 100%, so the baseline applies, and "Accepts pdf" only restates what the schema already enforces. The one parameter that genuinely needs explanation, options.mode with its layout/text enum, has no description in either the schema or the tool description, so the distinction between layout preservation and text extraction is left to inference.

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 ("Turn a PDF into an editable Word document") that an agent can distinguish from word-to-pdf and pdf-to-pdfa. It does not explicitly contrast with the nearest sibling pdf-to-text, which also reads a PDF and produces a document, so the differentiation is implied rather than stated.

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

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

No guidance on when to choose this over pdf-to-text or convert-office, and no prerequisites (e.g. the source must be a real PDF, not a scan needing OCR). The only hint of context is the "(approximation)" qualifier.

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 it as a non-read-only, non-destructive, closed-world operation, lowering the bar. The description adds the accepted-format set and that a result file is returned, but says nothing about limits (the 5-file / 50 MB cap lives only in the schema) or failure behavior.

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

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

Two short sentences, zero waste, with the core action and accepted inputs front-loaded. Nothing extraneous.

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, 'Returns the result file' is a minimal but useful return hint. However, for a conversion tool among many overlapping siblings, the description does not do enough to orient the agent on limits or alternatives.

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 the single 'files' parameter is fully documented, including the upload_id vs content_base64 alternative and size limit. The description only restates the accepted formats already present in the schema, so it neither adds nor detracts.

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 (convert) and resource (presentations to PDF), and enumerates accepted input formats (pptx, ppt, odp, key). It does not distinguish itself from the sibling convert-office, which plausibly overlaps, so it falls short of a 5.

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 format list implies when the tool applies, but there is no explicit guidance on when to choose this vs convert-office or the various X-to-PDF siblings (word-to-pdf, excel-to-pdf). No exclusions or prerequisites are given.

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 already cover the safety profile: this is a non-readOnly, non-destructive, closed-world operation. The description adds the accepted input format ('Accepts pdf') and that a result file is returned. However, it says nothing about whether the empty default password makes the output effectively unprotected, or whether the source file is preserved — meaningful behaviors for an encryption 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?

Three short, front-loaded sentences with no filler; the encryption action comes first and the I/O contract follows. 'Returns the result file' is slightly vague but useful given there's no output schema.

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 nested tool with no output schema, the description is adequate but thin: it never explains what happens when the password option is omitted (schema default is an empty string) or how failures/invalid PDFs are reported. The core call can still be made correctly from the schema alone.

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 file object and the password option are fully documented in the schema. The description's 'with a password' maps to options.password but adds no syntax, minimum length, or default-behavior details beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'Encrypt a PDF with a password to open it.' The direction of the operation (encrypt, not decrypt) implicitly separates it from the unlock-pdf sibling, but no sibling is named, so the distinction is left to the agent.

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

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

There is no guidance on when to use this tool versus unlock-pdf or the other PDF siblings, and no prerequisites or exclusions are stated. The usage is only inferable from the tool's name and the encryption phrase.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is largely covered. The description adds one useful fact — 'Returns the result file' — which matters since there is no output schema. However it doesn't say how the file is returned (URL, upload ID, bytes), which is the main behavioral unknown for a generation 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?

Two short sentences, front-loaded with the capability and finishing with the return behavior. 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 a 100%-documented single-parameter schema and no output schema, most of the burden is already handled by structured fields. The only meaningful shortfall is that the returned artifact's form is left vague ('the result file'), which an agent needs in order to chain the output into another 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% and the nested `options` description already explains the type discriminated union, the shared look fields, and gives a concrete wifi example. The tool description adds nothing beyond the schema, 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?

States a specific verb and resource ('Create QR codes') and enumerates the supported payload categories (links, WLAN, contacts, e-mail, events, payments). No sibling tool produces QR codes, so an agent can immediately tell this is the only generator in the set.

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 payload list but there is no explicit when-to-use / when-not-to-use guidance. With no competing QR sibling this is mostly harmless, but nothing tells the agent whether e.g. a link should go here or through another conversion path.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds that a result file is returned and which formats are accepted, but says nothing about whether the original is preserved, how multiple files are returned, or any size/time constraints handling beyond what the schema states.

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

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

Two short sentences with zero filler, formats and return behavior front-loaded in the first and second lines respectively. Nothing to trim.

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

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

The tool is simple and the schema is complete, but "Returns the result file" is ambiguous for a batch-capable tool accepting up to 20 files — it doesn't say whether the response is one file, an array, or an archive. That is the one thing an agent still needs to know.

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 is fully documented, including the upload_id vs content_base64 alternative and the 50 MB limit. The description's format list duplicates rather than extends the schema, 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?

Precise verb ("strip") plus resource ("hidden data") and explicit scope (PDFs and photos, with formats enumerated). An agent can distinguish this from siblings like unlock-pdf or compress-pdf, though no sibling is named as a contrast.

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?

Supported formats are stated, so the agent can infer when the tool applies, but there is no explicit when-to-use guidance and no mention of alternatives for adjacent needs (e.g., unlock-pdf, convert-image). Usage is only implied.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered; the description adds that a result file is returned, which is useful. It does not say whether the source file is left intact, whether the operation fails on out-of-range page indices, or how duplicates ('repeat') are handled.

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

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

Two short sentences with the capability front-loaded and no filler. The second sentence about input/output is minimal but earns its place; slightly more detail on the order format would have been a better use of the same space.

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

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

For a nested-options, file-producing tool with no output schema, the description covers input type and return value but omits the semantics of the custom ordering string and the meaning of 'rest' (append vs drop), which an agent cannot call this tool correctly without.

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 reported at 100% for the top-level properties, so the baseline is 3, and 'move, repeat or reverse' loosely foreshadows the mode/order/rest options. However, the critical 'order' string (default empty) has no syntax documented in either the schema or the description, leaving the most important parameter unexplained.

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 ('Sort the pages of a PDF') plus the concrete operations (move, repeat, reverse), which implicitly separates it from rotate-pdf, crop-pdf, and delete-pdf-pages. It doesn't explicitly name a sibling, so it stays just short of a 5.

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

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

No guidance on when to pick this over rotate-pdf or delete-pdf-pages, no prerequisites, and no explanation of when to choose 'reverse' mode versus 'custom' with an order string. The agent must infer everything from the title and schema.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, lowering the bar. The description adds that a result file is returned and that rotation can be limited to selected pages, but says nothing about whether the original is preserved or how pages/angle interact.

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, front-loaded sentences with little waste. 'Accepts pdf' is slightly redundant with the schema but adds the format restriction plainly.

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 mutation tool with a nested options object and no output schema, the description is thin: it never explains page-selection syntax, rotation direction semantics, or output handling. An agent would need to guess at options behavior.

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% at the top level, so the baseline is 3. The description adds no detail about the options object—angle values (90/180/270), the 'pages' string format, or how 'scope' interacts with 'pages'—which the schema itself leaves undocumented.

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?

Specific verb+resource: 'Rotate all or selected pages of a PDF' states the operation and its scope. It doesn't differentiate from nearby siblings like reorder-pdf or crop-pdf, so not a 5.

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

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

No when-to-use/when-not guidance and no mention of alternatives such as reorder-pdf when page order also needs changing. The 'all or selected pages' phrasing implies scope but gives no selection criteria.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. But the description adds nothing about the three divergent split behaviors, whether the original file is preserved, or any size/limits context beyond what the schema states — a real gap for a tool whose mode fundamentally changes the output.

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, front-loaded with the action and resource. The trailing 'Accepts pdf. Returns the result file.' is largely redundant with the schema and annotations, keeping it short of a 5.

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

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

The tool has a nested options object with three distinct behavioral modes, no output schema, and no explanation of what the returned file contains. The description does not address any of this complexity, leaving an agent unable to predict what a given mode will produce.

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 file/upload_id/content_base64 parameters are well documented and the baseline is 3. The description adds nothing, though, and the 'mode' enum values (ranges/extract/each) and 'pages' format carry no schema descriptions, so it misses a chance to compensate where the schema is weakest.

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 ('Split a PDF into parts or extract pages') that an agent can distinguish from merge-pdf and delete-pdf-pages at a glance. However, it never names an alternative or clarifies overlap with delete-pdf-pages/reorder-pdf, so sibling differentiation is only implied.

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

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

No indication of when to use this versus delete-pdf-pages, merge-pdf, or reorder-pdf, and no guidance on choosing between the 'ranges', 'extract', and 'each' modes. The agent is left to infer all selection logic from the schema defaults alone.

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

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

Annotations already declare readOnlyHint=false with destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one useful behavioral fact — 'Returns the result file' — which compensates for the absent output schema, but says nothing about where the output lives, how it is named, or whether anything is persisted.

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

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

Two short sentences with the capability stated first and the supported formats and return behavior following. No filler, though the second half is slightly clipped ('Returns the result file') rather than informative.

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 straightforward format-conversion tool with full schema coverage, explicit annotations, and no output schema, the description covers what it does and what it returns. The size/count limits (10 files, 50 MB) and default option values live in the schema, so the description does not need to repeat them.

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 the nested file objects and the options block are already documented precisely, including the upload_id vs content_base64 alternative. The description only echoes the file-type constraint that already appears in the schema's files array description, adding no new 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?

States a specific conversion (text files → PDF documents) and constrains the accepted input formats to txt, md, log, which separates it from inverse siblings like pdf-to-text and from office/image converters. It stops short of naming the exact sibling to choose for non-text inputs, so an agent must infer the boundary from the format list.

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 accepted-format list implicitly indicates when the tool applies and by omission that other converters (word-to-pdf, excel-to-pdf, convert-office) handle other source types. However, there is no explicit 'use X instead' routing and no stated prerequisites, so usage selection is inferred rather than directed.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, and the description's mutation framing is consistent with them. It adds that a result file is returned, but says nothing about whether the original is left untouched, permission/auth needs, or what the optional password field is for — meaningful gaps for a security-related mutation.

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 the core action front-loaded and no padding. The middle sentence 'Accepts pdf' is largely redundant with the schema's file constraint, a minor wasted clause.

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-required-parameter tool with a nested files object and full schema coverage, the description covers the essentials. It still omits the one thing an agent would likely get wrong — how the password option interacts with an already-encrypted input — and there is no output schema to lean on beyond 'returns the result file'.

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 files, upload_id, content_base64 and the 50 MB limit; the baseline of 3 applies. The description does not clarify the ambiguous 'options.password' field (user vs owner password, default empty string), which is exactly the kind of nuance the schema cannot convey.

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 ('Remove the password protection from a PDF'), which is immediately distinguishable from the sibling protect-pdf. It stops short of naming that inverse sibling explicitly, but the action itself is unambiguous.

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

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

No when-to-use guidance and no reference to the obvious alternative (protect-pdf) or to what to do if the file is not password-protected. 'Accepts pdf' restates the schema rather than advising the caller.

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

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

With readOnlyHint=false unrevealed in the text, the description should explain what is created, but "download the files inside" and "Returns the result file" are inconsistent (plural files vs singular result) and never clarify whether the output is a single archive or individual extracted files. The 50 MB cap and the one-archive limit live only in 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?

It is short and front-loaded, but "Accepts zip" merely restates the tool name and "Returns the result file" is too vague to earn its slot. Two of three sentences carry little information.

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

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

With no output schema, the description must explain the return value, and "the result file" does not say whether it is a zip of extracted contents or a set of files, nor how the caller retrieves it. For an unzip operation that is a significant 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 name/upload_id/content_base64 are already fully documented in the schema. The only added semantic is "Accepts zip" for the file type, which is marginal; 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?

It states a specific verb+resource: "Open a ZIP archive and download the files inside." That is clearly distinct from the sibling zip-files (the inverse), although the description never names the sibling explicitly.

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?

"Accepts zip" is the only constraint given; there is no guidance on when to prefer this over zip-files, what happens with non-zip inputs, or that only one archive is allowed per call. Usage is inferable from the name alone, not 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 declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, lowering the bar. The description adds that a JSON report is returned, but it does not say whether an invalid invoice produces an error or a report, nor how findings are surfaced — useful context for a validator that is left unstated.

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, front-loaded with the purpose, then accepted formats, then return shape. No filler; minor loss because the return-value sentence is vague ('a JSON report') rather than informative.

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?

A validation tool's key output is the verdict and its findings, and with no output schema the description should sketch the report's contents. It states only that a JSON report exists, leaving the agent unable to anticipate success/failure signaling or result structure.

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 nested file object, upload_id vs content_base64 alternative, and the 50 MB limit are all already documented in structured fields. The description's 'Accepts pdf, xml' repeats the schema's own wording rather than adding format or encoding guidance. Baseline 3 applies.

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

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

States a specific verb ('Check') and resource ('XRechnung and ZUGFeRD invoices') plus the standard applied ('official rules'), which clearly separates it from siblings like create-einvoice and extract-einvoice-xml. It stops short of naming those siblings explicitly, so no credit for direct differentiation.

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

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

The description gives no when-to-use guidance, no exclusions, and never points to the related create-einvoice, extract-einvoice-xml, or einvoice-to-pdf tools. An agent must infer the workflow position from the tool name alone.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, and the description usefully adds that it returns a result file rather than modifying in place. However, it does not address permissions, whether the original is altered, processing limits (only in schema), or anything about the produced output beyond its existence.

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

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

Two short, front-loaded sentences with no filler; the operation is stated first and the return behavior second. Every clause carries information an agent can act on.

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 fully documented nested schema and no output schema, the description covers purpose and return shape adequately. The only meaningful gap is the misleading 'every page' generalization against the pages option, which the schema resolves.

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 carries the parameter semantics, and the description adds essentially nothing beyond the text example. Critically, the phrase 'on every page' contradicts the presence of a 'pages' option that scopes the watermark, and options like layout, opacity, color and size go unmentioned.

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

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

The description gives a specific verb and resource ('Stamp text ... on every page') plus concrete examples ('CONFIDENTIAL', 'DRAFT') that make the operation immediately recognizable. It is reasonably distinguishable from siblings like add-page-numbers or protect-pdf, though it never names an alternative to sharpen that distinction.

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

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

Usage is only implied by the examples of watermark text; there is no explicit when-to-use, when-not-to-use, or pointer to a related tool such as add-page-numbers or protect-pdf. An agent can infer the purpose but 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds format support and that a result file is returned, but says nothing about how multiple inputs are handled or output naming, and "Returns the result file" is vague for a tool accepting up to 5 files.

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

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

Two short sentences with the core action front-loaded and no filler. The format enumeration partially restates the schema, so it is efficient rather than perfectly economical.

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 with full schema coverage and no output schema, this is close to sufficient. However, the singular "result file" is ambiguous given the 1–5 file array, and the overlap with convert-office is never resolved, leaving real gaps for an agent choosing and calling the tool.

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

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

Schema description coverage is 100%, including the 50 MB total limit and per-field guidance on upload_id vs content_base64. The description's format list duplicates what the schema already states for the files parameter, adding no new semantics.

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 ("Convert Word documents to PDF") and enumerates accepted input formats. It never distinguishes itself from the sibling convert-office tool, which likely overlaps directly, so it falls short of a 5.

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

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

No indication of when to pick this over convert-office or pdf-to-word, and no prerequisites or exclusions. The name implies the basic use case, but with a near-duplicate sibling present the agent is left to guess.

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 the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false). The description adds that a result file is returned, which is useful since there is no output schema, but the phrase 'Accepts *' is garbled placeholder text that conveys nothing and leaves key behavior (how the result is delivered, size/quantity limits) to 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?

Very short and front-loaded, which is good, but 'Accepts *' is a defective sentence fragment that occupies an entire sentence without earning its place and signals an unfinished definition.

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, non-destructive tool with full schema coverage, the description is minimally sufficient and mentions the returned file. It is not enough to say how the result is returned (e.g., an upload link or ID) or to compensate for the missing output schema.

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

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

Schema description coverage is 100%, so the nested name/upload_id/content_base64 fields and the 50 MB / 50-file limits are already documented. The description's only attempt at parameter meaning is the broken 'Accepts *', adding no value, so the baseline 3 applies.

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

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

States a specific verb and resource ('Pack several files into one ZIP archive') and the inverse relationship with the unzip-files sibling is obvious. It does not explicitly name the sibling or scope boundaries, but the operation is unambiguous.

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

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

No guidance on when to use this tool versus alternatives such as compress-pdf or create_upload, and no prerequisites. The only routing signal is implicit from the sibling name unzip-files.

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