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

No behavioral details are disclosed beyond the basic operation. The description does not mention output format, asynchronous processing, error handling, or authentication nuances. Since no annotations are provided, the description carries the full burden for transparency and fails to meet it.

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

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

The description is appropriately concise at two sentences. The reference link adds little actionable value for an AI agent and could be omitted, but the text is otherwise free of fluff and front-loads the core purpose.

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

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

The tool has no output schema, so the description must explain what the tool returns or how to interpret results. It does not, leaving significant gaps about output format, error behavior, and usage nuances. The description is too minimal for a tool that lacks structured return information.

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

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

The input schema already provides descriptions for both parameters (url and api_key) with 100% coverage, so the description adds no additional parameter semantics. The baseline of 3 applies because the schema handles parameter documentation effectively.

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

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

The description clearly states the tool's function with a specific verb ('Extracts'), resource ('data from invoices'), and method ('using AI'). This distinguishes it from sibling tools like pdf_to_json or pdf_to_csv, which are generic converters and not invoice-specific.

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

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

Usage context is implied by the tool name and purpose—use when invoice data extraction is needed—but there is no explicit guidance on when to use it versus alternatives, nor any 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?

No annotations are provided, so the description carries the burden. It reveals the annotation object shape and links to the upstream API doc, which is genuinely useful, but it never says whether the source PDF is modified or a new file is produced, nor what the response contains (e.g., output URL).

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?

Purpose statement is front-loaded, the example is the most information-dense part of the definition and earns its space given the untyped array item schema, and the reference link is a single line. No filler sentences.

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 no annotations and no output schema, the description should state what is returned and that a new document is generated. It covers input shape well but leaves the result and side effects unstated, so an agent cannot predict the outcome.

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%, which sets a baseline of 3, but the annotations parameter declares items as an empty schema with only a loose prose description. The worked JSON example supplies the actual field names and value types (text, x, y, size, pages, type, id) that the schema omits, so it adds real value above baseline.

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

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

States a specific verb and resource: 'Create new fillable form elements in a PDF document.' That is clear enough to act on, but it does not distinguish itself from close siblings like fill_forms or pdf_add_annotations_images_fields, leaving the agent to infer 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as fill_forms (populate existing fields) or pdf_add_annotations_images_fields (add annotations/images). The example shows how to shape input but not when to pick this tool.

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

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

With no annotations at all, the description carries the full disclosure burden and discloses almost nothing: it does not say that the call produces a downloadable output link that expires, that the operation may be long-running (siblings get_job_check and wait_job_completion imply async job semantics), or that credentials may be needed. The schema carries the parameter-level detail, but the behavioral profile of the call is absent.

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 lines, front-loaded with the conversion statement, no filler. The reference URL is compact and arguably useful, though it consumes space that could have gone to behavioral context.

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 9-parameter file-generation tool with no output schema and no annotations needs the description to explain the return value (an expiring output URL), async/job behavior, and credential handling; none of this is present. An agent can call it from the schema alone but cannot predict what comes back.

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 each of the 9 parameters documented in the schema itself (url source types, pages syntax, autosize, expiration, profiles, http auth). The description adds nothing beyond that, which is appropriate for a baseline of 3.

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

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

Names a specific verb and resource plus the accepted input formats (CSV, XLS, XLSX), so the conversion direction is unmistakable. However, it does not differentiate from the sibling excel_to_pdf, which by name appears to cover the same XLS/XLSX-to-PDF operation, leaving an agent guessing which to pick for a spreadsheet.

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 use this vs excel_to_pdf or document_to_pdf, and no mention of prerequisites such as obtaining a PDF.co API key or uploading local files first. The only extra pointer is a documentation URL, which is reference material rather than 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?

With no annotations, the description carries the full burden but says nothing about authentication (api_key), whether conversion is synchronous or job-based, or what is returned. Output handling is only implied by the schema's 'expiration' parameter describing a deleted output link, not by the description.

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 the format list in parentheses, plus one reference link. Nothing is bloated, though the bare link contributes little beyond the schema's own profile link.

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

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

For a 9-parameter tool with complete schema coverage but no output schema, the essential facts (what converts, to what) are present and the input contract lives in the schema. The missing piece is whether output is a downloadable file/link and how errors or jobs surface, which would materially help an agent chain calls.

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 parameter meaning is already fully documented in the schema and the baseline of 3 applies. The description adds no parameter-level nuance, and its type list (JPG, PNG, TIFF, WEBP, CSV) is broader than the url parameter's own list (DOC, DOCX, RTF, TXT, XPS), which could mislead an agent about image input handling.

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 ... into PDF') and enumerates supported input types, so the agent knows exactly what it produces. It does not differentiate from siblings such as html_to_pdf, image_to_pdf, excel_to_pdf, or csv_to_pdf, whose formats are all listed here, leaving format-overlap 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?

No guidance on when to use this generic converter versus the format-specific siblings (html_to_pdf, excel_to_pdf, image_to_pdf), and no prerequisites such as needing a publicly accessible URL. The only extra pointer is a documentation link.

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?

No annotations exist, so the description carries the full behavioral burden, yet it only adds a documentation link. It says nothing about API key requirements, that output is a temporary link controlled by expiration, or whether the conversion is synchronous or a job that must be polled.

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?

Extremely short and front-loaded, but the brevity crosses into under-specification for a 9-parameter conversion tool; the second line is a bare external link that an agent may not be able to fetch.

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

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

For a 9-parameter, no-annotation, no-output-schema tool in an async-job API, the description omits return shape, job handling, and authentication. The schema covers parameters but the description leaves the surrounding workflow unknown.

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 parameters like embedAttachments, convertAttachments, paperSize and expiration are already fully documented. The description adds no parameter meaning beyond the schema, which is the baseline 3 case.

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 email to PDF'. The resource (email) implicitly separates it from document_to_pdf or webpage_to_pdf, but no sibling is named and the accepted email formats (MSG/EML) are only in 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?

No guidance on when to use this instead of document_to_pdf or html_to_pdf, no mention that local files must first go through upload_file, and no note about asynchronous job polling via get_job_check/wait_job_completion.

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?

No annotations are provided, so the description carries the full burden. It does disclose a genuinely useful behavioral trait — the API endpoint retirement on January 5, 2027 — which is non-obvious and important for an agent choosing tools. However it says nothing about authentication, whether the call is synchronous or returns a job, rate limits, or what the response contains (presumably a link).

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

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

The core action is front-loaded in the first sentence, and the retirement warning plus doc link are compact and relevant. Nothing is padded, though the raw URL line could be folded into the warning sentence.

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 say what the call returns — presumably a CSV output link subject to the expiration parameter — but it does not. Parameters are fully covered by the schema, and the deprecation notice is a plus, leaving the return-value gap as the main deficiency.

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

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

Schema description coverage is 100%, so every one of the 8 parameters is documented in the schema, including url sourcing, api_key fallback, profiles, expiration, and worksheetIndex. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource pair ('Convert Excel(XLS, XLSX) to CSV') including the input formats accepted. Sibling tools like excel_to_json, excel_to_html, and excel_to_txt are distinguished only implicitly by the named output format; no explicit differentiation is given.

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 excel_to_json/excel_to_xml/excel_to_html or pdf_to_csv, and no prerequisites stated. The only contextual note is the retirement date, which is about lifecycle, not usage.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds a genuinely valuable lifecycle disclosure (API endpoint retirement date) and a reference link, but says nothing about the output (raw HTML vs. a hosted link), cost, or permissions—important for a conversion tool returning a 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?

The description is short, front-loads the core purpose, and follows with the deprecation notice and reference. Every sentence serves a purpose, though the reference URL is somewhat incidental.

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 8 parameters and no output schema, the description should clarify the return shape—whether the result is a URL to the converted HTML, raw HTML content, or a job reference. It is otherwise adequate given full schema coverage and the lifecycle note.

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

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

Schema description coverage is 100%, so all 8 parameters including url, name, api_key, profiles, expiration, and worksheetIndex are already documented in the schema. The description adds no syntax, defaults, or format details beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource with scope: 'Convert Excel(XLS, XLSX) to HTML.' The input formats are named explicitly, so the agent knows the accepted source types. However, it offers no differentiation from siblings like excel_to_json, excel_to_csv, or excel_to_xml, which perform structurally similar conversions.

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 and names no alternatives among the many excel_to_* siblings. The only additional sentence is a lifecycle/deprecation notice, which is useful operationally but does not tell the agent when to pick this tool over others.

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 no annotations, the description carries the full behavioral burden. It usefully discloses the January 2027 retirement, but says nothing about whether conversion is synchronous or job-based, what the response contains, credit consumption, or error behavior.

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

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

The purpose is front-loaded in the first sentence, and the retirement notice is clearly separated. The developer URL is somewhat extraneous but the whole definition remains short and scannable.

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

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

For an 8-parameter conversion tool with no output schema and no annotations, the description never explains what is returned (inline JSON vs. a file link) or whether a job/polling flow is involved. The retirement note is helpful but leaves core invocation context missing.

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

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

Schema description coverage is 100%, so all eight parameters, including URL sourcing and upload_file guidance, are already documented. The description adds no parameter-level meaning beyond the schema, which is the baseline case for full coverage.

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

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

States a specific verb and resource ('Convert Excel(XLS, XLSX) to JSON') and names both input formats and the output format, which is exactly what distinguishes it from siblings like excel_to_csv and excel_to_xml.

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 target makes the intended use obvious, but there is no explicit guidance on when to choose this over excel_to_csv/excel_to_xml or how it relates to the job-checking siblings. 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?

No annotations are supplied, so the description carries the full burden of behavioral disclosure, and it discloses almost nothing. It does not say whether the call is synchronous or a job that must be polled with get_job_check or wait_job_completion, what the response contains (an output link?), whether credits are consumed, or how the 'expiration' lifetime affects the result. Only a bare documentation link is offered.

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

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

One short sentence plus a reference link, front-loaded with the conversion direction and free of filler. It is efficient, though arguably too terse for an 8-parameter service endpoint.

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 an 8-parameter conversion endpoint with no annotations and no output schema, the description should at least explain what is returned and whether a job must be polled. The schema covers the inputs well, but the agent gets no information about the output artifact or the asynchronous flow, and it must infer both.

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

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

Schema description coverage is 100%, and each of the 8 parameters is documented in the schema itself, including url sources, api_key fallback, profiles, and expiration semantics. The description adds no parameter meaning beyond that, so the baseline of 3 applies.

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

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

Names a specific verb ('Convert') and both the source formats (XLS, XLSX) and target format (PDF), which is enough to tell it apart from excel_to_csv, excel_to_json, and csv_to_pdf without opening the schema. It does not explicitly name a sibling or a boundary condition, 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 description gives no guidance on when to pick this tool over document_to_pdf, excel_to_html, or the other converters. The only usage hint, namely that local files should go through upload_file, lives in the url parameter's schema text rather than in 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?

No annotations are provided, so the description carries the behavioral burden. It usefully discloses the endpoint retirement date and reference link, but it does not describe return behavior, failure modes, authentication expectations, or how generated files are delivered.

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

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

The description is front-loaded with the core conversion purpose and then gives the retirement warning and reference. It is appropriately sized with no wasted prose.

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 a fully described schema, the description covers the operation and important lifecycle status. It is nearly complete, though it could mention the output artifact more explicitly since there is no 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 all eight parameters are already documented in the input schema. The description adds no parameter-specific semantics beyond what the schema provides, which is acceptable at the baseline for fully described schemas.

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: converting Excel XLS/XLSX files to TXT. The output format uniquely distinguishes it from sibling tools such as excel_to_csv, excel_to_json, and excel_to_html.

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

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

Usage is implied by the output format, and the retirement note gives a temporal when-not boundary. However, it does not explain when to choose TXT versus the many other Excel or PDF conversion siblings.

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

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

No annotations, so the description carries the burden. It discloses that this is a thin wrapper over a specific PDF.co API endpoint, that the endpoint is being discontinued on a stated date, and points to reference docs. It doesn't state what the call returns (a URL to a generated XML file) or that the operation is remote/asynchronous, which is a real gap for a conversion 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: capability first, then the deprecation warning, then a reference link. Front-loaded and every sentence carries distinct information an agent needs.

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 eight params fully documented in the schema and no output schema, the main missing pieces are the return shape (URL to the generated XML) and any file-size or plan limits. The deprecation notice is exactly the kind of lifecycle context a schema cannot express, which offsets those 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% and every parameter, including the upload_file pointer for local files, is documented in the schema. The description adds no parameter-level meaning beyond what the schema already provides, 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 with input formats spelled out: 'Convert Excel(XLS, XLSX) to XML.' Among siblings that are all Excel conversions (excel_to_csv, excel_to_json, excel_to_html, excel_to_txt, excel_to_pdf), the target format alone cleanly identifies which tool to pick.

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 explicit when-to-use or when-not guidance, and no reference to the sibling conversions. The choice is inferable from the output format in the name/description, but the agent must infer it. The retirement notice does at least tell the agent this tool has a limited lifetime and should be avoided in long-lived workflows.

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?

No annotations are supplied, so the description carries the full burden and largely drops it: it never says what is returned (attachment list? archive? URLs?), whether the operation is async and requires get_job_check/wait_job_completion, whether outputs expire, or that an API key/credits are consumed. The 'expiration' and 'profiles' parameters hint at async job semantics the description never surfaces.

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?

Only two sentences, which is short, but the second is a raw URL with no framing about what it explains or when the agent should consult it. There is no real waste, but the reference adds no self-contained value and the front-loaded sentence is under-specified rather than tight.

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

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

A 7-parameter, no-annotation, no-output-schema tool needs the description to explain return shape and job/expiration behavior, and this one explains neither. An agent cannot tell from the description whether it will get attachment URLs, a zip, or a job ID to poll.

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 each of the 7 parameters self-documented (including API key fallback, http auth, and expiration lifetime). The description adds nothing beyond the one required 'url' implicitly, 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 ('Extracts attachments from a source PDF file') that is unambiguous and unlike anything in the sibling list (which covers conversion, splitting, form filling, etc.). No sibling actually competes with it, so the lack of explicit differentiation costs little.

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 use this versus alternatives, no prerequisites (e.g., that this is for PDFs with embedded files rather than attachments in an email sense), and no exclusions. The only 'guidance' is a bare documentation link.

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?

No annotations are provided, so the description carries the full disclosure burden. It reveals the field payload shape and the dependency on read_pdf_forms_info, which is useful, but it never says that a new output file is produced (with a lifetime governed by 'expiration') or what happens to fields that don't match existing names.

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?

Front-loaded with the core action, followed by the fields example and the prerequisite call in priority order. The reference URL is the only marginally expendable element; everything else 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 an 8-parameter generation tool with no output schema, the description should say what comes back (a link to the filled PDF, subject to expiry). It covers input preparation well but leaves the return contract and partial-failure behavior 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?

With 100% schema coverage the baseline would be a 3, but the description adds real value beyond the schema: the 'fields' array items are untyped ('items': {}), and the worked example supplies the 'fieldName'/'pages'/'text' keys that the schema omits. Other parameters are left to their own descriptions.

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

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

States a specific verb and resource ('Fill existing form fields in a PDF document'), and the word 'existing' implicitly separates it from create_fillable_forms. It does not, however, explicitly distinguish itself from pdf_add_annotations_images_fields, which also touches form fields, so sibling 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?

Gives a concrete prerequisite: call 'read_pdf_forms_info' first to obtain the fieldName values, which is exactly the context an agent needs before invoking. It stops short of stating when not to use it (e.g., when the PDF has no form fields, or when creating a form rather than filling one).

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

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

With no annotations, the description carries the full burden, yet it discloses almost nothing: no permission/auth model, no note that this is a read-only analysis call, no pagination or rate-limit behavior. Only the vague hint that coordinates are returned (rather than extracted table data) adds behavioral information.

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

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

One front-loaded sentence plus a reference link, with zero filler. It is not padded, though it is also thin enough that it borders on under-specification.

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?

Eight parameters and no output schema mean the description should explain the return shape, but 'coordinates' is all it offers, leaving the response structure (bounding boxes per page, table IDs) unknown. Schema coverage compensates for inputs but not for the vague output expectation.

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

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

Schema description coverage is 100%, so every parameter (pages, api_key, password, profiles, expiration, http auth) is already documented in the schema itself. The description adds no parameter-level meaning beyond that, which is the baseline 3 case.

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 ('Find tables in PDF') plus the useful outcome ('get their coordinates'). It is distinguishable from siblings like find_text or pdf_to_json by implication, but it never names an alternative 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?

There is no guidance on when to choose this over find_text, pdf_to_json, or the extraction tools, and no stated prerequisites or exclusions. The only pointer is an external documentation URL, which an agent may not be able to follow.

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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that coordinates are returned and that regex is supported, but says nothing about read-only safety, required permissions/API key handling, output format, pagination, or rate limits.

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 plus a reference link, with the core action and output front-loaded. No wasted text, and the external reference is compact and relevant.

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 an 11-parameter tool with no annotations and no output schema, the description is too thin. It never explains the coordinate output format or how results are returned, and it leaves all authentication, page-range, and profile behaviors 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 all 11 parameters thoroughly. The description adds only the regex-support hint, which is already covered by the regexSearch parameter description; baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Find text in PDF') plus a concrete outcome ('get coordinates'), which clearly separates it from extraction siblings like pdf_to_text and from find_table. It does not explicitly name an alternative, 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?

There is no guidance on when to choose this tool over pdf_to_text, pdf_make_searchable, or find_table, and no stated prerequisites or exclusions. The regex support note implies a use case, but selection guidance is absent.

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

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

The description transparently lists all possible statuses and their meanings, including 'working' for nonexistent jobs. Given no annotations, it carries the burden well, though it could mention it is a read-only operation with no side effects.

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

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

The description is efficient, front-loading the purpose, and each line serves a clear function. The list of statuses could be formatted for clarity, but overall it is concise.

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

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

The description adequately explains status outcomes but does not clarify what 'results' entails (e.g., return format). Since there is no output schema, more detail on what the tool returns would improve completeness.

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

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

Schema coverage is 100%, so the schema already documents the two parameters. The description adds no extra meaning beyond the schema, such as format or constraints.

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

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

The description clearly states the tool checks job status and results, listing possible statuses. However, it does not differentiate from the sibling tool 'wait_job_completion', which may be used for similar purposes.

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

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

Usage is implied (when you have a job ID), but the description offers no guidance on when to use this tool versus alternatives like 'wait_job_completion', nor when not to use it.

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

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

With no annotations, the description must carry behavioral disclosure, and it does add real value by documenting the special header/footer classes (date, title, url, pageNumber, totalPages, base64 img) and an example. However, it omits other important behavior: whether the call is synchronous or job-based (siblings get_job_check/wait_job_completion suggest async jobs), what the response contains, and authorization/rate-limit 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?

The purpose is front-loaded in one sentence, followed by relevant header/footer documentation and a compact example. The external reference link adds little immediate value and the total length is slightly long, but every section except the bare URL 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 description covers the most complex parameter behavior (header/footer templating) well, and the schema covers all 15 parameters. But for a conversion tool with no output schema, the description does not explain what the tool returns (a link, a file, a job ID) or whether it runs synchronously, leaving an agent without critical end-to-end context.

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 would be 3, but the description meaningfully supplements the schema for the trickiest parameters. It explains the placeholder classes available in header and footer markup and provides a concrete example, which is not in the schema descriptions.

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

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

The description names a specific verb and resource ('Convert HTML to PDF'), so the core action is unambiguous. It does not differentiate from sibling conversion tools such as document_to_pdf, webpage_to_pdf, or image_to_pdf, which is the main gap for this dimension.

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 guidance on when to choose this tool over the many sibling conversion endpoints, nor does it state prerequisites such as an API key or input restrictions. The only reference to an alternative is a URL to external documentation, not an in-context when-to-use 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about how the result is delivered (output link), that the link expires and the file is deleted, authentication requirements, or whether the call is synchronous versus a job. For a network conversion tool with zero annotation coverage this is a substantial gap.

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 lines: the purpose is front-loaded in the first sentence and the second is a reference pointer. There is no filler, though the stray trailing backticks are a formatting blemish.

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 eight parameters, no annotations, and no output schema, the description should at least sketch what comes back and any operational constraints. Instead it stops after the format list plus a doc link, leaving the return shape and delivery model entirely undocumented.

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

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

Schema description coverage is 100%, so all eight parameters — including multi-URL input, page ranges, profiles, and expiration — are already fully documented in the schema. The description adds no parameter detail beyond the format list, 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 ('Convert ... to PDF') and enumerates the accepted input formats (JPG, PNG, TIFF), which implicitly separates it from siblings like document_to_pdf, html_to_pdf, and excel_to_pdf. It does not explicitly name an alternative, but the format constraint makes the boundary clear.

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 pick this over document_to_pdf or webpage_to_pdf, no mention that local files must first go through upload_file (that lives only in the url parameter description), and no preconditions such as the required API key. The only added pointer is an external doc URL.

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

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

With no annotations provided, the description carries the full burden but omits key behavioral details: whether the original PDF is modified in place or a new file is generated, what the output return value looks like (e.g., expiring link), authentication requirements (api_key parameter exists but not explained), and effects of flatten/encrypt. It does note scanned PDF support and that fields must already exist, which is some 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?

The description is front-loaded with a summary and organized into numbered sections with examples, making it easy to scan. Some redundancy exists (the opening list is repeated in the sections), but examples earn their place by illustrating complex array inputs.

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 13 parameters, no output schema, and no annotations, the description covers the core content-addition behavior but leaves gaps: output format/expiration behavior, page range syntax (e.g., '0-'), interaction of flatten and encrypt, and differentiation from sibling fill_forms. It is adequate but incomplete for an agent to invoke confidently without consulting external references.

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 concrete JSON examples for the three array parameters (annotations, images, fields), which clarify structure and expected value types beyond the schema text. It does not cover all parameters (e.g., flatten, encrypt, expiration) but the schema handles those adequately.

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

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

The description clearly states the tool adds annotations, images, and fills form fields in PDFs, using specific verbs and resources. However, it does not distinguish this tool from sibling tools like fill_forms or create_fillable_forms, leaving ambiguity about when to choose this multi-purpose tool over specialized ones.

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 explicit guidance on when to use this tool versus alternatives. The 'three main ways' section describes capabilities but not selection criteria, and despite the presence of fill_forms and create_fillable_forms siblings, no comparison or exclusion is provided.

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

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

No annotations are provided, so the description carries the full burden. It does not state that this is a write/mutating operation producing a new protected file, what the result is (presumably a link with a limited lifetime), or that permission flags default to prohibited. These gaps matter for a 19-parameter 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?

The description is a single front-loaded sentence, which is efficient, but it is under-specified rather than concise. The reference URL adds a pointer but is not integrated into actionable guidance.

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

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

For a tool with 19 parameters, no annotations, and no output schema, the description says nothing about what the tool returns (a link?), that the output expires, or which permissions the owner_password controls. The rich schema compensates partially, but an agent still lacks behavioral context.

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

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

Schema description coverage is 100%, so every parameter including enums like encryption_algorithm and print_quality is already documented in the schema. The description adds no extra meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource: 'Add password protection to a PDF file.' An agent can immediately distinguish this from the sibling pdf_remove_password. It stops short of naming that sibling or clarifying scope, 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 (e.g., pdf_remove_password, or upload_file for local sources), no prerequisites, and no mention of what to do if the source PDF is already encrypted. The only pointer is a raw documentation URL.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the categories of information returned (page count, metadata, security, form fields), but says nothing about output format, whether password-protected PDFs are handled, or the significance of the expiration/output-link semantics that the schema hints at.

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 stating the resource and the returned fields, followed by a reference link. No filler; every element 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 seven-parameter, no-output-schema tool with no annotations, the description explains the kind of data returned but not its shape or how errors/password-protected files are surfaced. Adequate but leaves an agent guessing about the response 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 all seven parameters are already documented in-schema, and the baseline is 3. The description adds no parameter-level meaning beyond the schema, but it does not need to.

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 ('Get detailed information about a PDF document') followed by an enumeration of what is retrieved (pages, metadata, security, form fields). It does not name the overlapping sibling read_pdf_forms_info or pdf_to_text, so differentiation is only partially achieved.

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 explicit when-to-use or when-not-to-use guidance and no named alternative. An agent must infer from the tool name that this is the inspection step, and must guess how it relates to read_pdf_forms_info, which appears to overlap.

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?

No annotations are provided, so the description carries the full behavioral burden. It usefully explains that OCR runs and an invisible text layer is added, but it omits critical operational behavior such as whether this is an asynchronous job, how the output is delivered (link vs. file), and any auth or rate-limit context.

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

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

Three sentences with no waste: the purpose is front-loaded, the OCR mechanism is described next, and a reference link follows. Every sentence adds distinct value.

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

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

For a 10-parameter, no-annotation OCR tool with no output schema, the description is missing key context about return values, job handling, and output delivery. The input schema is rich, but the absence of output-schema documentation means the description should have explained what the agent receives after 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?

The input schema has 100% description coverage for all 10 parameters, so the schema already documents each parameter thoroughly. The description adds no parameter-specific semantics beyond what the schema already provides, which is the baseline expectation when schema coverage is high.

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: converts scanned PDFs or images into a text-searchable PDF via OCR. It clearly distinguishes the operation from extraction tools like pdf_to_text, though it does not explicitly name any sibling.

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

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

The context of use is implied by 'scanned PDF documents or image files,' giving the agent a reasonable trigger. However, the description does not state when to prefer this tool over alternatives such as pdf_to_text or pdf_make_unsearchable, nor does it list prerequisites or 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?

No annotations are provided, so the description carries the full burden. It discloses the core mechanism of removing the text layer but omits important behavioral details such as whether it returns a new file or modifies the original, whether processing is asynchronous, and how to retrieve results.

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

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

The description is two sentences, front-loaded with the core operation, and the reference link is a compact pointer for further details. There is no unnecessary text.

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

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

Given no annotations, no output schema, and nine parameters, the description should explain what happens after invocation. It does not clarify whether the tool submits a job, returns a processed file link, or requires polling via get_job_check/wait_job_completion.

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

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

Schema description coverage is 100%, so all nine parameters are already documented in the schema. The description adds no parameter-level meaning beyond the schema, which is the expected baseline.

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

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

The description states a specific verb and resource: 'Make existing PDF document non-searchable'. It also explains the mechanism, 'removing the text layer', which clearly differentiates it from the sibling pdf_make_searchable.

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 does not state when to use this tool versus alternatives, nor does it mention the obvious sibling pdf_make_searchable. The intended use is only implied by the tool name and 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?

With no annotations, the description carries the full behavioral burden but only states the basic merge operation. It does not disclose output delivery format, possible asynchronous/job behavior, authentication requirements, or whether existing files are affected.

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

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

The text is two sentences and front-loads the operation before the reference link. It is efficient, though the grammar is slightly awkward ('Merge PDF from two or more PDF...').

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?

Input parameters are fully described in the schema, so the agent can call the tool. However, there is no output schema and the description does not explain what the tool returns or whether it runs synchronously, leaving meaningful context 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 schema already documents all seven parameters. The description adds a small amount of meaning by saying 'two or more' and mentioning ZIP inputs, but most parameter semantics remain in the schema, 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?

The description uses a specific verb and resource: merge two or more PDFs or other supported files into a new PDF. It clearly states the tool's function, though it does not explicitly distinguish itself from nearby conversion tools like document_to_pdf or image_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?

The phrase 'two or more' and 'into a new PDF' implies the use case: combining multiple source files. There is no explicit when-to-use versus alternatives guidance, no mention of upload_file for local inputs, and no exclusions or prerequisites beyond an external reference link.

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 no annotations, the description carries the full behavioral burden. It does not say whether the output is a new file vs. modifying in place, what happens when the wrong password is supplied, or that the output link expires (that detail lives only in the schema). For a file-mutating tool with zero annotation coverage, this is a meaningful gap.

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 plus a documentation reference URL. Nothing is wasted, though the reference-only second line adds little for an agent that cannot browse.

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 an 8-parameter file-mutation tool with no annotations and no output schema, the description is thin: it omits output behavior (generated link, expiration) and failure modes. The rich 100% schema coverage compensates substantially, keeping this at a minimum-viable 3 rather than lower.

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

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

Schema description coverage is 100%, so every parameter, including the password, profiles, expiration, and HTTP auth fields, is already documented in the schema. The description adds nothing beyond that, which meets the baseline of 3 when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Remove password protection from a PDF file'), which is unambiguous and distinguishable from the sibling pdf_add_password by name and verb. However, it never names the inverse sibling or clarifies the relationship, so differentiation is left entirely to the tool 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?

There is no when-to-use/when-not guidance and no mention of the sibling pdf_add_password that performs the opposite operation. An agent gets no help deciding between the two beyond the name, and no preconditions (e.g., that a password is only required for protected files) are 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?

No annotations are provided, so the description carries the full burden and falls short: it doesn't say whether the call is synchronous or returns a job id, what the response contains (one link per resulting file?), whether files expire, or that a source URL can be cloud storage or require HTTP auth. A bare reference link is the only added context.

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

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

Two short lines, front-loaded with the core action. The raw 'Ref:' URL is dead weight for an agent that cannot browse, but it is small and does not obscure the purpose.

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

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

This is a 9-parameter, output-producing operation with no annotations and no output schema, yet the description says nothing about the returned artifact (multiple files/links), execution model, or error handling. The schema covers the inputs well, but the tool's behavior and results are left entirely undocumented.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters in detail, including the pages syntax and the expiration semantics. The description only restates page indexes/ranges, adding nothing 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 and resource ('Split a PDF into multiple PDF files') and names the two mechanisms (page indexes or page ranges). It does not distinguish itself from siblings such as pdf_merge or explain how the output file set is structured, so sibling differentiation is absent.

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 versus alternatives, no prerequisites, and no mention of follow-up tools like get_job_check or wait_job_completion even though those siblings exist in the same namespace.

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 no annotations, the description carries the full behavioral burden but only describes the conversion output in broad terms. It does not disclose operational details such as whether processing is synchronous or job-based, how output links expire, API key requirements, password handling, or error behavior.

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

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

The description is front-loaded with the core conversion purpose and has no filler. The reference URL is useful but is not self-contained, and the overall text is extremely sparse for a 13-parameter tool.

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 13 parameters, no annotations, no output schema, and many format-specific siblings. The description says what is converted but does not explain return behavior, job handling, output-link lifetime, or when this tool should be selected over pdf_to_xls, pdf_to_xlsx, or pdf_to_json.

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

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

Schema description coverage is 100%, so all 13 parameters are already documented in the input schema. The description adds no parameter-level meaning beyond the schema, which is acceptable at the baseline for fully covered schemas.

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: convert PDFs and scanned images into CSV. It also mentions the output includes layout, columns, rows, and tables, which helps distinguish the CSV output from plain text. However, it does not explicitly distinguish this tool from siblings such as pdf_to_xls, pdf_to_xlsx, or pdf_to_json.

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 explicit guidance on when to choose CSV over sibling formats like XLS, XLSX, JSON, or text. It implies that scanned images are supported, likely via OCR, but does not state prerequisites, exclusions, or alternative-tool routing.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about what is returned (an output link vs. inline HTML), expiration semantics, OCR requirements for scanned inputs, or API-key/auth expectations. The only added context is that scanned images are handled, which implies OCR but doesn't explain it.

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

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

Two short sentences, front-loaded with the operation and followed by a documentation reference; no filler. It is on the sparse side for a 13-parameter tool, but nothing present 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 13-parameter conversion tool with no annotations and no output schema, the description should at minimum say what the tool returns and how OCR/scanned input behaves. Neither is covered, leaving the agent unable to predict the result shape or handle scanned documents correctly without reading external docs.

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

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

Schema description coverage is 100%, so all 13 parameters are already documented in the schema, establishing a baseline of 3. The description adds no extra meaning about any parameter — notably it does not connect the "scanned images" claim to the lang/OCR parameter, which would have been genuinely useful.

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 PDF and scanned images to HTML format"), and the target format implicitly distinguishes it from siblings like pdf_to_text, pdf_to_json, and pdf_to_image. It does not name any sibling explicitly, so the differentiation is left to inference.

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 use this tool versus the many other PDF conversion siblings, and no prerequisites or exclusions. Usage is only implied by the tool name and the conversion verb; the agent must infer routing from the output-format keyword 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing beyond the conversion action. It does not mention whether the operation is synchronous or asynchronous, what the response contains, authentication requirements, rate limits, or how output files are returned.

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

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

The description is front-loaded with the core purpose in a single sentence and avoids filler. The four reference links are compact and relevant, though they are not integrated into any usage or behavioral context.

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 14 parameters, no annotations, and no output schema, the description is too thin. While the input schema is fully documented, the description does not explain return behavior, async/job semantics, or other context an agent needs to invoke the tool correctly beyond the basic purpose.

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

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

Schema description coverage is 100%, so the schema already documents all 14 parameters thoroughly, establishing a baseline of 3. The description adds only a redundant list of output formats already captured by the schema's type choices and provides no additional meaning for parameters such as pages, rect, profiles, or expiration.

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: convert PDF and scanned images into image formats, and names the output types (JPG, PNG, WebP, TIFF). This clearly distinguishes it from text/structured-data converters, but it does not explicitly name a sibling or contrast the use case beyond 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 description provides no explicit when-to-use or when-not-to-use guidance, no prerequisites, and no named alternatives. It merely states the conversion operation and links to endpoint docs, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing: it does not say whether the call is synchronous or returns a job to poll (relevant given get_job_check and wait_job_completion siblings), what the response contains (an output link? inline JSON?), or that the output link expires. The mention of scanned images implies OCR, but the lang parameter is the only clue.

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 lines, front-loaded with the core action and output characteristics, plus a reference link. Efficient and free of filler, though the reference line contributes little for an agent that cannot fetch it.

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?

No annotations and 13 parameters, but the schema is fully documented with defaults and formats, and a docs reference is given. What is missing is return-value and execution-model context (sync vs async job, output link lifetime), which matters given the visible job-polling siblings.

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

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

Schema description coverage is 100%, so all 13 parameters are already documented with defaults and examples. The description adds no parameter meaning beyond pointing at the /pdf/convert/to/json2 endpoint and a docs URL, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Convert PDF and scanned images into JSON representation') and enumerates what is preserved (text, fonts, images, vectors, formatting), which distinguishes it from plain-text siblings like pdf_to_text. It does not name those siblings explicitly, so the differentiation is inferred rather than declared.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as pdf_to_text, pdf_to_xml, or pdf_to_html even though the sibling list is crowded with near-identical converters. The only routing hint ('use upload_file for local files') lives in the schema, not 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?

No annotations exist, so the description carries the full burden, yet it discloses almost nothing behavioral. It never says whether the call is synchronous or a job requiring get_job_check/wait_job_completion (siblings that strongly suggest async), what the return value is (extracted text vs. a temporary output URL), that the output link expires, or that an API key/environment variable is needed — all of which the schema hints at but the description should surface.

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 core capability and followed by a single reference link — no filler. It is efficient, though the reference URL substitutes for content rather than supplementing it.

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 13-parameter conversion tool with no annotations and no output schema, the description is too thin: it omits the return shape, the async/job flow, OCR handling implications and the expiration behavior of the produced output. An agent could invoke it but could not predict what it gets back or how to retrieve 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 all 13 parameters including lang, pages, rect, unwrap and profiles are already documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

States a specific verb+resource ('Convert PDF and scanned images to text') plus a meaningful qualifier ('layout preserved'), which implicitly separates it from format-specific siblings like pdf_to_json, pdf_to_csv and pdf_to_html. It doesn't name an alternative explicitly, so it stops short of full sibling differentiation.

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

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

No guidance on when to pick this over pdf_to_json, pdf_to_csv, pdf_to_html, or pdf_make_searchable, and no prerequisites or exclusions. The only pointer is an external reference URL, which forces the agent to leave the tool definition to decide.

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?

No annotations are provided, so the description carries the full disclosure burden, and it discloses almost nothing beyond the format. It does not say whether the call is synchronous or job-based (siblings get_job_check/wait_job_completion suggest async), that the result is a downloadable link that expires, or that an API key is required. The only extra is a bare documentation URL.

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

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

One front-loaded sentence plus a reference link, with zero filler. It is efficient, though efficiency here partly reflects how little was said rather than disciplined editing.

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

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

This is a 13-parameter conversion tool with no output schema and no annotations, and the description never explains what comes back (a link to the generated XLS file) or how the expiration parameter affects it. The format distinction that matters most against pdf_to_xlsx is implied but never made explicit, leaving real gaps for the calling agent.

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

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

Schema description coverage is 100% and all 13 parameters are individually documented in the schema, including lang, pages, rect, and expiration. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb+resource pair ('Convert PDF and scanned images to XLS') and adds the useful qualifier that the target is Excel 97-2003 format, which is the main thing separating it from the sibling pdf_to_xlsx. However, it never names pdf_to_xlsx or pdf_to_csv as the alternatives, so an agent must infer the format distinction itself.

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

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

There is no when-to-use guidance at all: no statement of when to pick this over pdf_to_xlsx (modern format) or pdf_to_csv, no prerequisites about the source file being publicly reachable or uploaded first, and no note that OCR only applies to scanned inputs. An agent gets only the bare conversion 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?

No annotations are provided, so the description carries the full behavioral burden and discloses almost nothing. It does not say whether the call is synchronous, what it returns (a download link?), how long that link lives (the expiration param implies deletion), or that OCR is applied to scanned input. The external doc reference helps slightly but isn't self-contained.

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 lines with the capability stated first and a documentation pointer second — no filler. It is arguably too terse for a 13-parameter conversion tool, but it is well front-loaded and wastes nothing.

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 13-parameter conversion tool with no annotations and no output schema, the description omits what an agent most needs: the return value shape and whether the result is a job or a direct link. Ambiguity with pdf_to_xls is also left unresolved, so the definition is incomplete relative to the tool's complexity.

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

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

Schema description coverage is 100% across 13 parameters, so the schema already explains url, lang, rect, pages, unwrap, line_grouping, and expiration. The description adds no extra semantic detail on any parameter, so the baseline of 3 applies.

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

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

States a specific verb ('Convert'), concrete sources (PDF and scanned images), and a concrete output format (XLSX/Excel 2007+). However it does nothing to distinguish itself from the sibling pdf_to_xls, which an agent could easily mistake for the same operation, 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?

There is no guidance on when to use this tool versus pdf_to_xls, pdf_to_csv, or other conversions, and no mention of prerequisites such as supplying an API key or uploading local files first. The only usage hint lives in the schema's url description ('Use upload_file tool to upload local files'), not in the description itself.

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

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

No annotations are provided, so the description carries the full disclosure burden. It says nothing about whether the call is synchronous or returns a job ID (siblings get_job_check and wait_job_completion suggest async patterns exist), what the response contains, or that output links expire per the 'expiration' parameter. Only a docs link is offered.

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

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

One front-loaded sentence plus a reference URL — zero padding and no repetition of schema content. It is efficiently sized, though the brevity reflects missing information rather than disciplined compression.

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 13-parameter conversion tool with no annotations and no output schema, the description should explain the return shape, async behavior, and OCR applicability. Instead it offers a single sentence and a link, leaving key operational facts for the agent to guess.

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

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

Schema description coverage is 100%, so every one of the 13 parameters is already documented in the schema, including OCR language, page ranges, and expiration. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Convert PDF and scanned images to XML format'), which cleanly separates it from siblings like pdf_to_json, pdf_to_csv, and pdf_to_html. It does not explicitly name which sibling to prefer, but the target format alone makes the tool identifiable.

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

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

There is no guidance on when to choose this tool over pdf_to_json, pdf_to_html, or excel_to_xml, nor any prerequisites or exclusions. The 'scanned images' mention hints at OCR use, but the agent must infer that condition rather than being told.

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 no annotations provided, the description carries the full behavioral-disclosure burden. 'Extracts information' implies a read-only operation, but the description does not explicitly say the tool is non-destructive, describe the response shape, or explain how results are returned (for example, inline versus an output link).

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

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

The description is very short and front-loaded: the first sentence states the action and target, and the second provides a documentation reference. There is no filler or repetition.

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 seven parameters, full schema coverage, and no output schema, so the description should clarify what is returned and how it is delivered. It says 'extracts information' but does not specify the return format or handling of the output, leaving a noticeable gap for an agent deciding whether the result meets its needs.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in the schema, including the URL, optional API key, password, profiles, expiration, and HTTP credentials. The description itself adds no parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: it extracts information about fillable PDF fields from an input PDF file. This is clear, but it does not explicitly distinguish itself from closely related siblings such as pdf_info_reader, fill_forms, or create_fillable_forms.

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 alternatives, no prerequisites, and no exclusions. The description only states what it does and adds a reference URL, leaving the agent to infer usage from the name and context.

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

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

No annotations are provided, so the description carries the full burden. It fails to disclose any behavioral traits such as authentication requirements, success/failure responses, rate limits, or side effects. The description is too brief to guide safe invocation.

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

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

The description is a single sentence with no wasted words, which is efficient. However, it could be slightly expanded to include essential context without becoming verbose. It is appropriately sized but lacks structure for additional guidance.

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

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

Given that there is no output schema and no annotations, the description should explain what the tool returns (e.g., a URL or job ID). It does not, leaving the agent without critical information for using the result. The description is incomplete for the tool's role as an upload step.

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

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

The input schema has 100% description coverage, so the schema already documents both parameters (file_path and api_key). The description adds no extra meaning beyond the schema, but it is not necessary. A score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action (upload) and the target (file to PDF.co API), providing a specific verb and resource. However, it lacks mention of what the upload accomplishes or returns, which could help differentiate it further from sibling tools that also involve file input.

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

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

No guidance is given on when to use this tool versus alternatives, such as prerequisites (e.g., must be used before processing tools like pdf_merge) or context like file size limits. The description does not help an agent decide to select this tool over others.

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 no annotations, the description fails to disclose blocking behavior, polling mechanism, timeout handling, or return value. It only states the obvious.

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?

Single sentence is concise but lacks critical information like blocking behavior. It is not optimally informative for an agent.

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?

Description lacks details on return format, polling behavior, error handling, and effect of interval/timeout, leaving significant gaps for a 4-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?

Input schema has 100% coverage; description adds no extra meaning. Baseline score applies.

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

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

The description clearly states the tool waits for job completion, but it doesn't differentiate from the sibling 'get_job_check' which likely checks status once.

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 vs alternatives like 'get_job_check'. The description does not provide any usage context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds useful detail about header/footer HTML templating and base64 image support, but omits critical behavior: what the tool returns (file, link, job ID), whether conversion is synchronous or asynchronous, authentication behavior beyond schema, and output file lifetime.

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

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

The purpose is front-loaded in the first sentence. The header/footer explanation and code example are relevant and earn their place, though the section is somewhat lengthy and a reference link is included without much framing.

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 schema is rich with 100% parameter description coverage, and the header/footer semantics are well covered. However, with no output schema, the description should explain return values or async job behavior, and it does not. An agent cannot tell from this description whether the call returns a PDF directly, a URL, or a job identifier.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond the schema for the complex header and footer parameters by explaining supported HTML classes, base64 image constraints, and giving a concrete example. It does not elaborate on other complex parameters like profiles or paperSize, but the schema documents those adequately.

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

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

The description clearly states a specific verb and resource: convert an external webpage URL to PDF. It implies differentiation from html_to_pdf by specifying 'external webpage URL', but does not explicitly name or contrast with sibling tools.

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

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

Usage is implied by the first sentence: this tool should be used when the source is an external webpage URL. However, there is no explicit guidance on when to prefer this over html_to_pdf or document_to_pdf, and no exclusions or prerequisites are stated.

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