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

With no annotations provided, the description carries the burden. It discloses the composition behavior, optional watermark, output format options, and return type (Base64-encoded bytes). However, it omits details like error handling, required permissions, or whether the operation is destructive (though composition is likely non-destructive).

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

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

The description is concise, with a clear opening sentence, bullet-style parameter explanations, and a return statement. Every sentence adds value without redundancy, and the structure is front-loaded with 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?

Given the tool's complexity (multi-part composition with flexible fields) and the lack of schema descriptions, the description covers key aspects: part structure, watermark, output format, and return value. It lacks error handling or edge-case guidance but is sufficient for basic use. The presence of an output schema (even if not described) lowers the burden slightly.

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 0%, so the description must compensate. It explains the 'parts' parameter as a list of dicts with fields like htmlContent, markdownContent, templateName, and fields. It also clarifies 'watermark' as diagonal text overlay and enumerates output_format options (PDF, DOCX, ODT). This adds significant meaning beyond the bare schema types.

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 composes a multi-part document from several sections, which distinguishes it from sibling tools like generate_document or generate_pdf_from_html that likely create single-part documents. The verb 'compose' and resource 'multi-part document' are specific and descriptive.

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 lacks explicit guidance on when to use this tool versus alternatives such as generate_document or generate_pdf_from_html. It does not state prerequisites, limitations, or scenarios where other tools would be more appropriate.

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 full burden for behavioral disclosure. It only states conversion to PDF/A and returns base64, but does not mention whether the conversion is lossy, if metadata is preserved, or any specific PDF/A version compliance.

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

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

The description is brief and to the point, using a docstring format that separates Args and Returns. It contains no extraneous information, though the formatting could be slightly more streamlined.

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

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

For a simple tool with one parameter and an output schema (indicated but not provided), the description is adequate but lacks details about the PDF/A version, error handling, or comparison to sibling archival tools like validate_zugferd.

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 description adds meaning to the single parameter 'pdf_base64' by clarifying it is a 'Base64-encoded PDF file.' The input schema only provides the title 'Pdf Base64', so the description fills a gap, though it could specify expected encoding format.

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

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

The description clearly states the tool converts a PDF to PDF/A archival format. The verb 'Convert' and the resource 'PDF to PDF/A' are specific, distinguishing it from sibling tools like merge_pdfs or rotate_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?

No guidance on when to use this tool vs alternatives such as validate_zugferd or extract_text_from_pdf. There is no mention of prerequisites (e.g., input must be a valid PDF) or situations where conversion is not appropriate.

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 must carry the full behavioral burden. It describes the return format (Base64 PDF with XML) but does not disclose side effects, storage behavior, authentication requirements, or potential rate limits. The lack of behavioral context is significant for a creation 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 well-structured with a summary line, an explanation of the items parameter, a parameter list, and return type. It is front-loaded with the main purpose. While somewhat lengthy, every sentence adds value and it avoids tautology.

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

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

Given the tool's complexity (22 parameters, no annotations, no output schema details), the description covers the essential aspects: what it does, input parameters, and return format. However, it lacks guidance on error handling, empty items, and authentication needs, limiting completeness slightly.

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 description adds substantial meaning beyond the schema, which lacks property descriptions. It explains each parameter's purpose, the expected structure of 'items' (description, unitPrice, optional fields with allowed units), and default values for country and currency. This compensates for the schema's lack of 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 clearly states it creates a ZUGFeRD-compliant invoice PDF, which is a specific verb+resource combination. This distinguishes it from sibling tools like generate_pdf_from_html or fill_excel_template that produce different document types.

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

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

The description implies usage for generating e-invoicing PDFs but does not explicitly state when to use this tool versus alternatives like compose_document or generate_pdf_from_html. No guidance on prerequisites or use cases 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?

With no annotations, the description carries full burden. It discloses auto-formatting behavior (header styling, auto-filter, frozen row, auto-sized columns) and return type (Base64 XLSX). Missing edge cases like large CSV performance or encoding, but still solid.

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?

Concise: two introductory sentences then a bullet-like Args list. No wasted words, though defaults could be omitted since schema already has them. Still very efficient.

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

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

Given 4 parameters and an output schema, the description covers main conversion and formatting behavior. It specifies the return format (Base64 XLSX). Lacks error scenarios or size limits, but overall adequate for an 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 0%, so the description must add meaning. It provides one-line explanations for all 4 parameters, including defaults and interpretation (e.g., 'Raw CSV text', 'CSV delimiter'). Does not elaborate on allowed delimiter characters or null handling, but adds significant value.

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

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

The description clearly states the verb 'Convert' and the resource 'CSV content' to 'styled Excel workbook', and lists auto-formatting features. It effectively distinguishes from sibling tools like excel_to_csv (reverse) and generate_excel (for custom data).

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

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

No explicit guidance on when to use this tool versus alternatives. Usage is implied by the description, but no when-not-to-use or alternative names are 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 provided, so description must disclose behavior. It states deletion but does not mention irreversibility, permissions required, or side effects like cascade deletes. Insufficient transparency.

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?

Concise two-sentence structure with clearly labeled Args and Returns. Efficiently communicates intent but could include more details within the same length.

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

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

Given low complexity and presence of output schema, the description is minimally adequate. However, it does not specify return value details beyond a vague 'Confirmation message' or address error conditions like missing template.

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 0%, so description must compensate. It adds basic meaning by indicating that 'name' is the template's name, but does not explain format, case sensitivity, or uniqueness 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 'Delete a template by name,' using a specific verb and resource. It distinguishes this delete operation from sibling tools like list_templates and upload_template.

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. Does not mention prerequisites, such as the template existing, or when deletion is appropriate.

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?

Without annotations, the description must fully disclose behavior. It states the input and output format but does not mention error handling, side effects, or constraints (e.g., XML size, encoding). For a detection tool, the basic behavior is clear, but transparency is limited.

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 extremely concise, with a one-sentence purpose and a structured Args/Returns section. No wasted words; each sentence contributes meaningfully.

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

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

Given the tool's simplicity (one parameter, clear output), the description covers essential information. However, it omits details on malformed or non-XRechnung input behavior. Though an output schema exists, the description could still benefit from mentioning expected response fields.

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 0% description coverage, so the description must compensate. It clarifies that 'xml' expects XML content, but does not specify formatting (e.g., string, base64) or provide examples. This adds minimal value beyond the schema's type and title.

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 detects if an XML document is an XRechnung and identifies its format and version. The verb 'detect' is specific and the resource is well-defined, distinguishing it from siblings like validate_xrechnung or parse_xrechnung.

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

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

No explicit guidance on when to use this tool versus alternative tools such as validate_xrechnung or parse_xrechnung. The description implies it's a preliminary check, but lacks direct comparison or usage scenarios.

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 present, yet the description only states a straightforward conversion with no disclosure of side effects, file size limits, or performance characteristics. For a transformation tool, more behavioral details would be beneficial.

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-loaded with the purpose, and structured using a docstring format. Every sentence contributes value, though the Args/Returns section could be slightly more streamlined.

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

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

Given the tool's simplicity and the presence of an output schema, the description adequately covers the core functionality and parameters. It lacks only minor details like potential limits or edge cases.

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 0%, but the description adds meaningful semantics to all three parameters: explains base64 encoding, 0-based sheet index, and default delimiter. This goes well beyond the schema's bare names and types.

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 ('Extract data') and the resource ('an Excel sheet'), with the output format ('CSV text'). It effectively distinguishes from sibling tools like excel_to_json or csv_to_excel.

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 lists arguments but does not provide explicit guidance on when to use this tool versus alternatives (e.g., excel_to_json). Usage is implied but not elaborated.

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 provided, so description carries full burden. It explains the extraction and return format but does not explicitly state it is read-only or disclose constraints like file size limits or error handling.

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

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

Description is concise with a summary line followed by clear Args and Returns sections. No unnecessary words, and key information is front-loaded.

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

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

Given the tool's moderate complexity and presence of an output schema, the description covers purpose, parameters, and return format. It lacks error scenarios but is sufficient for typical use.

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 0%, but the description provides detailed explanations for all three parameters (excel_base64, sheet_index, has_header) in the Args section, adding meaning beyond types and defaults.

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?

Description clearly states 'Extract data from an Excel sheet and return structured JSON', specifying verb, resource, and output format. It distinguishes from siblings like excel_to_csv by targeting JSON output.

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

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

No explicit guidance on when to use this tool vs alternatives like excel_to_csv or inspect_excel. The description only explains what it does, not when to choose 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?

Discloses it returns Base64-encoded CSV but not behavioral traits like side effects or auth needs. Annotations absent, so description carries full burden; basic disclosure but gaps remain.

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-line description with clear purpose, Args, and Returns sections, no unnecessary words.

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?

Covers key aspects: input expected, output format. Could mention what DATEV-compatible entails or size limits, but adequate for a simple export 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 description adds 'List of receipt extraction results (from extract_receipt)' to the receipts parameter, clarifying its source and type, which is valuable beyond the schema's bare definition.

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

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

Clearly states the tool exports extracted receipt data as DATEV-compatible CSV, distinguishing it from sibling tools like export_receipts_xlsx.

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?

Implies usage after receipt extraction but lacks explicit guidance on when to choose CSV over other formats or any 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?

Discloses return format (Base64-encoded XLSX) and input requirement. No annotations provided, so description covers essential behavior but lacks details on side effects or limitations.

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

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

Very concise, purpose front-loaded, no redundant text. Every sentence adds 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?

Sufficient for a simple export tool with one parameter. Covers what, input, and output. Could mention no side effects, but overall complete.

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

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

With 0% schema coverage, description compensates by explaining the parameter expects receipt extraction results from extract_receipt, adding semantic meaning beyond the raw schema.

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

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

Clearly states the tool exports receipt data as XLSX format. Differentiates from sibling export_receipts_csv by specifying Excel workbook format and links to extract_receipt as data source.

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?

Implies usage after extract_receipt by specifying input source. Does not explicitly compare with CSV export or state when not to use, but context is clear enough for simple export.

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 full burden. It discloses the AI-based extraction and return format but omits limitations, error handling, or performance characteristics (e.g., image size, confidence thresholds).

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

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

The description is concise (4 sentences plus a bullet list of return fields) and front-loaded with the core purpose. It wastes no words, though the list could be integrated more smoothly.

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

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

Given the tool's complexity (AI OCR, structured output), the description covers input requirements and output fields comprehensively. However, it does not detail the exact JSON structure or error responses, and the output schema existence is not leveraged.

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 0% schema description coverage, the description adds meaning to all three parameters: image_base64 as base64-encoded image, filename for format detection, content_type with MIME type defaults and PDF handling. This compensates well for the sparse schema.

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

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

The description clearly states the tool extracts structured data from receipt/invoice images via AI, listing specific extracted fields. It distinguishes itself from sibling tools like extract_receipt_async (async variant) and extract_text_from_pdf (pure text extraction) by focusing on structured receipt data.

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

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

The description implies use for receipt/invoice images but lacks explicit guidance on when to use this tool versus alternatives like extract_receipt_async. No when-not conditions or prerequisites are mentioned.

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

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

No annotations are provided, so the description must carry the behavioral burden. It states the return (job ID) and optional callback_url, but lacks details on error handling, rate limits, or potential rejection reasons. It adequately describes the async submission pattern.

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 extremely concise: one sentence for purpose, one for usage guidance, and a clear list of parameters. Every sentence adds value, and the structure front-loads the most important information.

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

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

Given the complexity (async job with polling), the description covers the full lifecycle: submit, then poll status, then get result. It mentions the return JSON structure and the optional callback_url. With sibling tools for polling and results, this is complete.

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

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

The input schema has 0% description coverage, so the description fully compensates by explaining each parameter (image_base64, filename, content_type, callback_url), including defaults and optionality. This adds significant value beyond the schema.

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

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

The description clearly states the action (submit a receipt), the resource (receipt), and the outcome (returns a job ID for polling). It distinguishes from siblings like extract_receipt (synchronous) and get_receipt_job by emphasizing the async nature.

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 explicitly instructs to use get_receipt_job for status and get_receipt_job_result for the result, and implies this is the async alternative to extract_receipt. This provides clear when-to-use guidance.

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

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

Description does not disclose behavioral traits beyond the basic operation; no mention of performance, file size limits, or support for scanned PDFs.

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 concise with a clear Args/Returns structure, no wasted words.

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?

Sufficient for a simple extraction tool with an output schema; missing some behavioral context but comprehensive enough for basic use.

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?

Adds meaning to the parameter pdf_base64 by specifying it is a Base64-encoded PDF file, which the schema did not provide.

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

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

Clearly states the tool extracts all text content from a PDF, distinguishing it from sibling tools like merge_pdfs or get_pdf_metadata.

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

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

No guidance on when to use this tool vs alternatives; lacks context about limitations 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 provided; description only states extraction and return of JSON. Does not disclose error handling, side effects, or requirements like file format validity.

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?

Short description with clear Args/Returns sections. No redundant information, though could include more behavioral details without excessive length.

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

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

Tool has output schema (implied by 'Returns JSON'), so return structure is covered. However, lacks usage context and behavioral traits, leaving gaps for a new user.

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

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

Single parameter 'pdf_base64' has 0% schema description coverage; description adds meaning by specifying it is 'Base64-encoded ZUGFeRD PDF', compensating for the schema gap.

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 'Extract structured invoice data from a ZUGFeRD/Factur-X PDF', using a specific verb and resource. It distinguishes from siblings like validate_zugferd and parse_xrechnung by focusing on extraction.

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

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

No guidance on when to use this tool versus alternatives (e.g., validate_zugferd might be used for validation). No mention of 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?

With no annotations, the description carries full burden. It discloses that recalculate defaults to true and returns a base64 XLSX, but does not mention whether the original template is modified (it is not—returns new file), authorization needs, or error conditions. The information is present but could be more explicit about non-destructive nature and 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 a clean docstring format (Args, Returns) with no wasted words. Each sentence earns its place: the opening sentence covers the core action, parameter list includes details, and return type is specified. It is front-loaded and easy to parse.

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?

Despite moderate complexity (template filling with cells and tables) and no annotations, the description covers parameters, defaults, and return value. It could mention input validation or template format requirements, but overall it is sufficient for an agent to use the tool correctly. The presence of an output schema is not utilized but the description compensates well.

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 0%, yet the description explains all four parameters with concrete examples: 'template_base64: Base64-encoded Excel template file', 'values: Cell values... key = cell ref like Sheet1!A1 or named range', 'tables: Table data... key = range name, value = row arrays', and the default for recalculate. This adds substantial meaning beyond the schema types.

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 ('Fill') and resource ('Excel template'), specifying 'with data at named cells and ranges'. This is unambiguous and distinguishes from siblings like 'generate_excel' which creates new files, or 'csv_to_excel' which converts CSV. The verb+resource combination is specific.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. No context is given about prerequisites or typical use cases. For example, it could mention that this is for populating existing templates rather than generating from scratch. The absence of usage recommendations limits the agent's decision-making.

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?

Given no annotations, the description must disclose behavior. It mentions the flatten option and that it returns a base64-encoded PDF, but lacks details on error handling, missing fields, or potential side effects. It does not contradict anything, as no annotations exist.

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

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

The description is concise (5 lines) and well-structured with Args and Returns. Every sentence adds value without redundancy, making it easy to parse quickly.

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?

While the description covers basic usage and return value, it misses edge cases like what happens if fields are empty or if the PDF lacks form fields. Given the tool's simplicity and the presence of an output schema, it is adequate but not exhaustive.

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 0%, so the description compensates by explaining each parameter (e.g., 'pdf_base64: Base64-encoded PDF with form fields'). This adds meaning beyond the schema's titles, though more detail (e.g., accepted formats for fields) would improve it.

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

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

The description clearly states 'Fill form fields in a PDF,' specifying a precise verb and resource. This distinguishes it from sibling tools like merge_pdfs or generate_pdf_from_html, which serve different purposes.

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

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

The description explains the tool's function and parameters but does not explicitly state when to use it versus alternatives like inspect_pdf_form (to check fields) or generate_pdf_from_html (to create new forms). No when-not or comparative guidance is provided.

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

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

No annotations provided, so description must disclose behavior. It mentions that the tool generates a document and returns base64-encoded bytes. However, it does not state whether any state is modified, if authentication is required, or any rate limits. The stateless nature is implied but not explicit.

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

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

The description is concise with a clear opening line and a list of parameters. It avoids redundancy but the list of args is necessary due to lack of schema descriptions. Could be more structured (e.g., separate sections for args and return).

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?

Covers inputs and output, but misses stating that at least one of html_content, markdown_content, or template_name must be provided (though schema marks all optional). No examples or usage notes. Output schema exists, so return values are assumed covered.

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 has no descriptions (0% coverage), so the description fully compensates by explaining each parameter's purpose. However, it does not clarify constraints like mutual exclusivity of html_content and markdown_content, or that a template_name requires a pre-uploaded template.

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

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

The description clearly states the tool generates documents with optional template, fields, and watermark. It lists inputs and output format. However, it does not differentiate from siblings like generate_pdf_from_html or generate_pdf_from_markdown, which perform similar tasks.

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. For example, it doesn't clarify that if only HTML to PDF is needed, generate_pdf_from_html might be more appropriate. No prerequisites or exclusions mentioned.

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

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

The description discloses the return format (Base64-encoded XLSX) and input structure, but does not explicitly state side effects or statelessness. With no annotations, it partially covers behavioral traits, but could be more explicit about being a pure generation function.

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 well-structured with a summary sentence followed by bullet points. It is somewhat lengthy but necessary given the minimal schema. Front-loaded with purpose, though some details could be integrated into a more defined schema.

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

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

Given the tool's complexity and the absence of detailed schema, the description covers input structure and return type comprehensively. It does not address error handling or size limits, but overall provides sufficient context for invocation.

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

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

The input schema only defines a generic object with additionalProperties true, providing no structure. The description compensates fully by detailing sheets, columns, rows, formulas, properties, and password, adding essential meaning that the schema lacks.

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 'Generate an Excel workbook (.xlsx) from a structured JSON definition.' with a specific verb 'generate' and resource 'Excel workbook', distinguishing it from siblings that perform other operations like CSV conversion or template filling.

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

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

No explicit guidance on when to use this tool versus alternatives like csv_to_excel, fill_excel_template, or inspect_excel. The description does not mention scenarios or exclusions, leaving the agent to infer usage from the purpose alone.

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

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

No annotations present. The description only states the return format (Base64-encoded PDF bytes). Lacks disclosure on idempotency, safety (read/write), authentication needs, size limits, or any 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?

Concise two-line description with structured Args/Returns. No wasted words, though it could be more informative about constraints.

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?

Tool is simple with one param and an output schema. Description covers input and output format. However, context signals indicate no nested objects or enums, so basic completeness is adequate, but missing details like supported HTML features or file size limits.

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?

One parameter 'html' described as 'HTML content to convert to PDF'. This adds context beyond the schema's type string. Schema description coverage is 0%, so description partially compensates.

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

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

Clearly states verb 'Generate' and resource 'PDF from HTML content'. Distinguishes from siblings implicitly by specifying HTML input, but lacks explicit differentiation from similar tools like 'generate_pdf_from_markdown'.

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

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

No guidance on when to use this tool versus alternatives like 'generate_pdf_from_markdown' or 'fill_pdf_form'. No exclusions or prerequisites mentioned.

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

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

The description discloses the core behavior (convert Markdown to PDF) and the output format (Base64-encoded bytes). However, it omits details like supported Markdown features, page orientation, error handling, or any side effects. With no annotations, these gaps reduce transparency.

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 extremely concise: three lines covering purpose, parameter, and return value. No redundant text. It is well-structured and front-loaded.

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

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

Given the tool's simplicity (one parameter) and the presence of an output schema, the description is mostly complete. It specifies the output type (base64 PDF bytes), which is helpful. Missing context includes potential size limits or encoding details, but these are minor.

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 only parameter 'markdown' has 0% schema description coverage, but the description adds that it is the 'Markdown content to convert', clarifying it is not a file path. This is adequate but minimal.

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 ('Generate a PDF') and the input ('Markdown content'), making it easy for an AI agent to understand what the tool does. The name and description together distinguish it from siblings like 'generate_pdf_from_html' or 'compose_document'.

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 provided on when to use this tool versus alternatives such as 'generate_pdf_from_html' or 'compose_document'. There are no mentions of prerequisites, limitations, or context where this tool is preferred.

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

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

With no annotations, the description must fully disclose behavior. It mentions the return type (JSON string) and content (metadata fields), but lacks details on error handling, file size limits, or processing side effects. Basic disclosure but incomplete.

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

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

The description is concise, with a front-loaded purpose statement and a compact arg/return listing. Every sentence adds value without redundancy.

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

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

Despite low schema coverage, the description fully covers the single parameter and mentions the return format (JSON). The presence of an output schema reduces the need to detail return values. For a simple tool, it is complete.

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

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

Schema coverage is 0%, so the description must compensate. It explains pdf_base64 as 'Base64-encoded PDF file', adding meaning beyond the schema's type and name. This clarifies the input format.

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

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

The description clearly states the verb 'get' and resource 'metadata from a PDF', distinguishing it from siblings like extract_text_from_pdf. It lists the specific metadata fields (title, author, page count) which further clarifies the purpose.

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

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

The description implies usage for retrieving PDF metadata, but does not explicitly mention when to use this tool over alternatives like get_pdf_page_count or extract_text_from_pdf. No exclusions or context are 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 must disclose behavioral traits. It does not mention whether it is read-only, performance characteristics, size limits, or error handling beyond a straightforward page count. The minimal description leaves uncertainty.

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

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

The description is concise and well-structured with clear sections for args and returns. It avoids unnecessary words, though it could be more structured with examples or constraints.

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 basic purpose and input meaning, but given no annotations and a simple single-parameter tool, it is adequate. However, it lacks information on output format details (even though an output schema exists) and edge cases, making it only moderately complete.

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

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

Although schema description coverage is 0%, the description explicitly states 'pdf_base64: Base64-encoded PDF file,' adding semantic meaning beyond the schema's type string alone. This helps the agent understand the input format.

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 'Get the total number of pages in a PDF' clearly states a specific verb (get) and resource (page count of a PDF), distinguishing it from sibling tools like get_pdf_metadata or extract_text_from_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?

No guidance on when to use this tool versus alternatives, such as when only metadata is needed or when page count is part of a larger extraction task. The description does not provide usage context 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, but description discloses return format with possible statuses (PENDING, PROCESSING, COMPLETED, FAILED). No side effects noted, acceptable for a status check.

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-line description with clear Args/Returns structure, no fluff, front-loaded 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?

Output schema present, description covers status values. Complete for a simple polling tool with clear input source.

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?

Single parameter job_id with 0% schema description coverage; description clarifies it is the ID from extract_receipt_async, adding value beyond schema.

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

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

States 'Check the status of an async receipt extraction job' with a clear verb and resource, distinguishing from siblings like extract_receipt_async and get_receipt_job_result.

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?

Explicitly mentions that job_id comes from extract_receipt_async, implying when to use. Could mention alternatives like get_receipt_job_result for 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 present, so the description must carry the burden. It implies the job must be completed but does not specify behavior for pending or failed jobs, nor does it mention permissions 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?

The description is concise with three clearly separated sections: summary, Args, Returns. Every sentence adds value with no redundancy.

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

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

Given the tool's simplicity (one required param, output schema present), the description provides essential context: purpose, parameter meaning, and return type. It could mention error handling but is largely complete.

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

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

With 0% schema description coverage, the description adds value by explaining job_id as 'The job ID returned by extract_receipt_async,' compensating for the sparse schema.

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

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

The description clearly states the tool retrieves the extraction result of a completed async receipt job. It uses a specific verb-resource combination and distinguishes from siblings like extract_receipt_async and get_receipt_job.

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 indicates the job_id should come from extract_receipt_async, providing clear usage context. However, it does not explicitly state when not to use it or mention alternatives for different scenarios.

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 full responsibility. It states that the tool returns metadata but does not disclose whether it is read-only, error handling behavior, or file format compatibility. The minimal information is insufficient.

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

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

The description is concise with three sentences plus structured Args/Returns sections. It is front-loaded and avoids unnecessary words, earning its length.

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

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

Given the output schema exists, the description adequately lists returned fields. However, it lacks information on error cases, file size constraints, or supported Excel versions. It is minimally complete for a simple inspection tool.

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

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

The only parameter, excel_base64, is described as 'Base64-encoded Excel file', which adds basic meaning beyond the schema's title. However, it lacks specifics like file format, size limits, or encoding requirements. With 0% schema coverage, it adds some value but not enough.

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 purpose: inspecting an Excel workbook and returning metadata (sheet names, row/column counts, named ranges). This clearly distinguishes it from sibling tools that convert or generate Excel files.

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

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

No guidance on when to use this tool versus alternatives like excel_to_json or fill_excel_template. The description does not mention when not to use it or any 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?

With no annotations, the description carries the full burden. It discloses the output format (JSON array of form field definitions) but does not mention side effects, permissions, error conditions (e.g., PDF without form fields), or performance constraints. The term 'inspect' implies read-only, but this is not explicit.

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 concise: two sentences for purpose plus a neat Args/Returns section. Every line adds value, and the main action is front-loaded. No wasted words.

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 input format, output structure, and core behavior. With an output schema present, it doesn't need to detail return values further. However, it omits behavior for edge cases like PDFs with no form fields, which could be clarified.

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 description adds meaning beyond the input schema by specifying that pdf_base64 should be a 'Base64-encoded PDF file with form fields,' which clarifies both the encoding and the requirement for form fields. The schema only provides a title.

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 inspects form fields in a PDF and returns their names, types, and values. It uses a specific verb ('inspect') and resource ('form fields in a PDF'), distinguishing it from sibling tools like fill_pdf_form or extract_text_from_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 description implies usage when needing to examine form fields, but provides no explicit guidance on when to use versus alternatives (e.g., fill_pdf_form, extract_text_from_pdf) or 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 carries the full burden. It only states it returns a JSON array, lacking details about read-only behavior, permissions, or any side effects. This is minimal transparency.

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 (two sentences) and to the point, but it could be more structured by adding a brief note on return format or typical usage. It is concise but minimally informative.

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

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

Given zero parameters and the presence of an output schema, the description is minimally complete. However, it does not explain if there are any filters, ordering, or limitations, leaving some gaps about the tool's behavior.

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

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

There are no parameters, and schema coverage is 100%, so baseline is 4. The description does not need to add parameter info, and it does not, which is acceptable.

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

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

The description clearly states it lists 'all uploaded signing certificates' using the specific verb 'list' and resource 'signing certificates', which distinguishes it from sibling tools that deal with other document operations.

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 provided on when to use this tool vs alternatives, nor any prerequisites or exclusions. The lack of context about when listing certificates is appropriate makes it less helpful.

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 full burden. It only mentions the return type (JSON array) without detailing any behavioral traits like read-only nature or performance implications.

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 extremely concise with two sentences, no wasted words, and directly states purpose and return format.

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 zero parameters and the presence of an output schema, the description is largely complete. It specifies listing custom fonts and returning a JSON array, but could mention if there are any limitations or ordering.

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

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

The tool has 0 parameters, so baseline is 4. The description adds no additional param info, which is acceptable.

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 lists all uploaded custom fonts, with a specific verb and resource. It distinguishes itself from sibling tools like list_templates and list_certificates.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites or context 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?

Lacking annotations, the description only states it returns a JSON array but provides no details on job lifecycle, filtering, pagination, or authentication requirements. Minimal behavioral disclosure for a read operation.

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 concise: two sentences, no redundant information. Key purpose and return format are stated upfront.

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?

While an output schema exists and no parameters are needed, the description omits aspects like result ordering, error behavior, or scope (all jobs ever vs. recent). Sufficient for a basic understanding but incomplete for nuanced selection.

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?

No parameters exist, so schema coverage is trivially 100%. The description adds no parameter details, but none are needed. Baseline 3 applies as per rules.

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?

Description clearly states the action (list) and resource (async receipt extraction jobs), distinguishing it from siblings like get_receipt_job (single job) and get_receipt_job_result (result retrieval).

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

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

No guidance on when to use this tool versus alternatives like get_receipt_job or extract_receipt_async. Explicit when-to-use or when-not-to-use is missing.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states the tool lists templates but does not mention authentication requirements, read-only nature, performance implications, or any side effects. This is minimal disclosure.

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 extremely concise: two sentences with clear structure. Front-loaded with the action and resource, followed by return type. Every word is necessary.

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

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

Given the existence of an output schema, the description does not need to detail return values. However, context about how the returned template info can be used with sibling tools (e.g., delete_template) is missing. The tool is minimally complete for a straightforward list operation.

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 is empty with no parameters, and schema coverage is 100%. The description adds no parameter-level details, which is acceptable since there are none. Baseline score of 4 is appropriate.

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

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

The description clearly states the action 'List' and the resource 'uploaded document templates'. It also describes the return type as 'JSON array of template info objects'. However, it does not explicitly distinguish itself from siblings like list_certificates or list_fonts, but the resource name provides enough specificity.

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 provided on when to use this tool versus alternatives like upload_template, delete_template, or other list tools. The description does not mention prerequisites or context for 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, and the description only states the basic operation. It does not disclose behavioral traits such as order preservation, error handling, or file size limits, which are important for a merge 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 concise with two sentences in docstring format, no wasted words, and clearly structured with Args and Returns sections.

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

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

The description is adequate for a simple merge tool, but lacks behavioral details like error handling or ordering. Since an output schema exists, return value explanation is not needed.

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 0%, but the description adds meaning by specifying that 'pdfs_base64' is a list of base64-encoded PDF files to merge, compensating for the schema's lack of detail.

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 (merge), the resource (multiple PDFs), and the output (single PDF), distinguishing it from sibling tools like convert_to_pdfa or generate_pdf_from_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?

No guidance on when to use this tool versus alternatives. Siblings include many PDF operations, but no explicit when-to-use or when-not-to-use context 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, and the description does not disclose any behavioral traits such as side effects, authentication requirements, rate limits, or limits on XML size. It only states the basic parse operation.

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 extremely concise with only three sentences, each serving a clear purpose (purpose, args, returns). No wasted words, and the key information is front-loaded.

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

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

Given the presence of an output schema, the description need not detail return fields. However, it lacks information on error handling or input validation. For a simple parse tool with one parameter, it is largely complete.

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

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

The description adds minimal semantic value for the single 'xml' parameter by specifying it is 'XRechnung XML content', but does not provide format details, size limits, or examples. Schema coverage is 0%, so the description partially compensates.

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

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

The description clearly states the verb 'parse', resource 'XRechnung XML', and output 'structured invoice data'. It distinguishes from sibling tools like 'validate_xrechnung' and 'detect_xrechnung' by focusing on parsing.

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

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

The description implies usage for parsing XRechnung XML but does not explicitly state when to use vs alternatives like validation or detection. No when-not-to-use guidance is provided.

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

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

With no annotations, the description carries the full burden. It does not disclose side effects, rate limits, size constraints, or error behavior for invalid inputs. The description is minimal and leaves the agent uninformed about important behavioral traits.

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

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

The description is concise (5 lines), front-loaded with the main purpose, followed by a clear parameter list. Every line adds value without redundancy.

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

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

The description covers the core functionality and outputs (Base64-encoded PNG). However, it lacks information on error handling (e.g., invalid PDF, page out of range) and does not specify any size or performance limits. Given the tool's simplicity, it is mostly complete.

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

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

The description adds meaning to each parameter beyond the schema: pdf_base64 is 'Base64-encoded PDF file', page is 'Page number (1-based, default: 1)', dpi is 'Resolution in DPI (default: 150)'. Since schema description coverage is 0%, this is valuable context.

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 purpose: 'Render a PDF page as a PNG image preview.' It specifies the verb (render), resource (PDF page), and output format (PNG), distinguishing it from sibling tools like extract_text_from_pdf or merge_pdfs.

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 guidance on when to use this tool versus alternatives, nor does it mention prerequisites or limitations. Usage is only implied by the purpose statement.

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

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

With no annotations, the description carries full burden. It mentions AI extraction and document generation, and states the output format (JSON + base64 document). However, it does not disclose potential side effects, costs, or limitations (e.g., supported image types, file size 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?

The description is fairly concise, with a purpose sentence and a clear argument list. It front-loads the key benefit ('single step'). Minor improvement: the args list could be better formatted for readability, but overall it is efficient.

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

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

Given the 6 parameters (1 required), absence of annotations, and existence of an output schema, the description adequately covers the tool's functionality and parameter semantics. It could be improved by mentioning error handling or supported receipt types, but it is sufficient for an AI 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 0%, so the description's brief explanations for each parameter add necessary context. For example, it explains that image_base64 is base64-encoded receipt image or PDF, and output_format lists possible formats. However, it could be more specific (e.g., valid MIME types for content_type).

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

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

The description clearly states it combines receipt data extraction and expense report document generation into one step, distinguishing it from sibling tools that do only extraction (extract_receipt) or only document generation (generate_document).

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

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

The description implies usage as a single-step end-to-end solution, but does not explicitly state when to use it over the two-step alternative (extract_receipt then generate_document). No when-not or alternative conditions are given.

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

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

No annotations, but the description explains the transformation (PDF rotation) and return value, covering key behavioral aspects.

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 purpose, followed by concise Arg list. Every sentence adds value with no extraneous 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?

Fully covers all input parameters and action; output schema exists, so return value is implicitly clear. No 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?

Description adds meaning to all three parameters: pdf_base64 as base64-encoded file, angle as specific values (90,180,270), and pages with default 'all'. This compensates for the 0% schema coverage.

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

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

Clearly states 'Rotate pages in a PDF' with specific verb and resource, and is distinct from sibling tools like merge_pdfs or extract_text_from_pdf.

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

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

Provides no explicit guidance on when to use this tool vs alternatives, but the description implies it's for rotating PDF pages.

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

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

No annotations are provided, so the description carries the full burden. It states the tool signs a PDF but does not disclose whether the original file is modified, authentication requirements, rate limits, or error conditions. The output is described as a Base64-encoded signed PDF, but behavioral traits beyond the core action are 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?

The description is concise, using a standard docstring format with clear sections for Args and Returns. It front-loads the purpose in the first sentence. No extraneous content, though it could be slightly expanded for clarity without becoming verbose.

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

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

The description covers the core operation and parameters, and the return type is specified. However, missing context such as certificate management (where to upload), permission requirements, and error handling leaves gaps. Given the tool has an output schema and no annotations, the description is adequate but not comprehensive.

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 0%, meaning the schema properties have no descriptions. The tool description compensates by explaining each parameter: 'pdf_base64: Base64-encoded PDF', 'certificate_name: Name of a pre-uploaded certificate', etc. This adds meaningful context beyond the schema's basic titles and types.

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 'Digitally sign a PDF with a PKCS#12 certificate.' This identifies the specific verb ('sign'), resource ('PDF'), and method ('PKCS#12 certificate'). No sibling tool performs signing, so it is well-differentiated.

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 mentions 'pre-uploaded certificate' but does not provide guidance on when to use sign_pdf versus alternatives, prerequisites (e.g., upload via list_certificates), or when not to use it. Sibling tools like list_certificates suggest preparation steps, but no explicit direction is given.

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

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

No annotations provided, and description fails to disclose behavioral traits such as authentication requirements, file size limits, overwrite behavior, or response details beyond a generic 'JSON with upload result'.

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

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

Description is extremely concise: 4 lines covering purpose, arguments, and return value. No wasted words; front-loads the core action.

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 low complexity (2 simple parameters) and presence of an output schema, the description is minimally adequate for an agent to understand the tool's purpose. However, missing behavioral details and usage guidance reduce 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 descriptions are empty (0% coverage), but description adds meaning: template_base64 is 'Base64-encoded template file' and filename includes an example. This compensates partially for the schema gap.

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?

Description clearly states verb 'Upload' and resource 'document template' with supported formats (ODT or DOCX), distinguishing it from siblings like delete_template, list_templates, and compose_document.

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

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

No guidance on when to use this tool versus alternatives (e.g., when to upload vs. compose or delete templates). No exclusions or prerequisites mentioned.

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

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

Although no annotations are provided, the description discloses the return format (JSON with valid, format, errors, warnings) and implies read-only behavior. It does not mention any side effects or permissions, but for a validation tool, this is moderately transparent.

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 concise (two lines for Args and Returns) and front-loaded with the main purpose. Every sentence adds value, and there is no fluff.

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

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

Given the tool validates a specific standard (XRechnung), the description lacks context about compliance rules, version support, or typical use cases. The return structure is partially explained, but without an output schema, more details would help.

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 0% schema description coverage, the description must compensate. It only says 'xml: XRechnung XML content', adding minimal value over the schema's type string. No format, encoding, or example is given.

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 'Validate XRechnung XML for compliance', which is a specific verb (validate) and resource (XRechnung XML for compliance). It distinguishes itself from siblings like 'parse_xrechnung' and 'detect_xrechnung' by focusing on compliance validation.

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 guidance on when to use this tool versus alternatives like 'detect_xrechnung' or 'parse_xrechnung'. It lacks context on prerequisites, preferred scenarios, or 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?

No annotations are provided, and the description lacks disclosure of behavioral traits such as side effects, authentication requirements, or limitations. It does mention the return structure but not fully.

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 extremely concise, with a single clear purpose sentence followed by structured Args/Returns, ensuring readability and quick comprehension.

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

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

While the description covers the basic validation function and output, it lacks details on supported ZUGFeRD profiles or versions, which would enhance completeness given the sibling 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?

With 0% schema coverage, the description adds meaning by explaining 'pdf_base64' as a Base64-encoded PDF with embedded ZUGFeRD data, going beyond the schema's title and type.

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 ('Validate') and the resource ('ZUGFeRD/Factur-X PDF'), effectively distinguishing it from sibling tools like 'detect_xrechnung' and 'validate_xrechnung'.

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 provided on when to use this tool versus alternatives (e.g., 'validate_xrechnung'), nor any when-not-to-use or prerequisite conditions.

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

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

No annotations provided. Description only mentions return format, not behavior on invalid input, side effects, or read-only nature. Insufficient for a tool with no annotations.

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

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

Very concise, two sentences plus return spec. Front-loaded with purpose. Could be slightly more structured but efficient.

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

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

Adequate for a single-param tool with output schema mentioned, but lacks error handling details and assumption of input validity. More context 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?

Description adds that pdf_base64 must be base64-encoded and signed, which is useful beyond the schema's empty title. However, with 0% schema coverage, more detail would help.

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 verifies digital signatures in a PDF, using a specific verb and resource. It distinguishes from siblings like sign_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?

No guidance on when to use this tool vs alternatives like sign_pdf or extract_text_from_pdf. It lacks context for agent decision-making.

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