FrankKi

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the context of listing from the partner address book and optional filter fields, but does not disclose any additional behavioral details such as pagination, default result limits, or how the 'reasoning' parameter behaves. With annotation coverage, a score of 3 is appropriate: the description adds some value but not rich context.

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

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

The description is concise, consisting of two sentences (one in German and one in English). It front-loads the primary action ('Listet die Adressen') and then mentions optional filters. The bilingual repetition is somewhat redundant but not excessive. It earns a high score for brevity and clarity, though the repetition could be trimmed.

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

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

The tool is a simple list operation with three optional parameters and no output schema. The description provides the basic purpose and filter capability but fails to explain the meaning of all parameters (especially 'reasoning' and how 'searchQuery' maps to the mentioned filters). It also does not describe the return format or any pagination behavior. Given the lack of output schema and parameter descriptions, the description is incomplete for an agent to fully understand 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?

Schema description coverage is 0%, meaning parameter properties have no descriptions. The description mentions filtering by name, city, or client, but the actual parameters are 'limit', 'reasoning', and 'searchQuery'. There is no mapping of filter fields to 'searchQuery', and 'reasoning' remains entirely unexplained. The description does not adequately compensate for the lack of parameter documentation.

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

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

The description clearly states the tool lists addresses in the partner address book and optionally filters by name, city, or client. It uses a specific verb (list) and resource (addresses), making the primary purpose obvious. However, it does not explicitly differentiate from the sibling tool 'address_search_company', which likely serves a similar search 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?

No guidance is provided on when to use this tool versus alternatives. The description mentions optional filtering but does not explain scenarios where this tool is preferred over address_search_company or address_upsert. There is no mention of exclusions or alternative tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the detail about returning authority PO boxes but does not disclose any further behavioral traits like rate limits or response structure. No contradiction with annotations.

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

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

The description is two short sentences, bilingual, and front-loaded with the core function. No unnecessary words, and the structure is 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?

For a simple search tool, the description covers the main purpose and return value, but lacks elaboration on parameter details, potential multiple results, or error scenarios. Given the annotations and simple schema, it is adequate but not fully 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%, and the description does not explain the parameters query, country, or reasoning. The parameter names are somewhat self-explanatory, but the description fails to add meaning beyond the schema, leaving the agent to guess formats or usage.

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

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

The description clearly states the tool's function: searching for companies and public authorities in a directory and returning the matching mailing address, including authority PO boxes. This distinguishes it from siblings like address_list (listing addresses) or address_validate (validating addresses).

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

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

It provides clear context for when to use the tool: when you need a mailing address for a company or public authority from the directory. However, it does not explicitly mention alternatives or when not to use it, which is a minor gap.

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

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

Annotations are minimal (readOnlyHint false, destructiveHint false). The description adds behavioral context by stating 'Validates the address using country-specific rules,' indicating that invalid addresses may be rejected. It does not, however, disclose behavior around upsert semantics (e.g., addressId handling) or side effects, so it's adequate but not rich.

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

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

Two sentences, concise and front-loaded with the core action. The bilingual repetition (German and English) is somewhat redundant, but the structure is clean and efficient.

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

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

Despite being a 12-parameter tool with no output schema and minimal annotations, the description is only two sentences. It doesn't explain return values, upsert key behavior (addressId), addressType enum meaning, or when validation fails. The overall package is inadequate for the tool's complexity.

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

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

Schema description coverage is only 8% (only 'country' is described), and the tool description does not compensate. It does not clarify cryptic parameters like 'mandantennummer', 'pobox', 'addressType', or 'isDefault', nor does it explain which fields are required beyond what's in the schema. The description adds no parameter-level guidance.

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 explicitly states 'Creates or updates an address in the partner address book' with a specific verb and resource, distinguishing it from siblings like address_list (listing only) and address_validate (validation only). The validation behavior is mentioned, further clarifying scope.

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

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

The description clearly conveys the tool's purpose for creating/updating addresses, but it does not explicitly address when to use this instead of address_validate or address_list. Given there is an address_validate sibling, a direct alternative reference is missing, so not a 5. However, the context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context by reinforcing the non-mutating nature ('address book is left untouched') and explaining the error reporting mechanism (hard failures as ADDRESS_INVALID). While it doesn't cover all behavioral aspects, it complements the annotations well.

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 bilingual and efficiently packs purpose, behavior, and an alternative into two short sentences per language. It is front-loaded with the core function and adds no filler, making every sentence earn its place.

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

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

With no output schema and low parameter coverage, the description could be more complete, but it does convey the essential context: the tool is a read-only validation that returns ADDRESS_INVALID on hard failures. It omits details about success responses and parameter semantics, but for a simple validation tool with strong annotations, this covers the main use case adequately.

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 very low (8%, only country has a description). The description does not compensate for the 12 parameters; it provides no details on fields like reasoning, mandantennummer, addressType, etc. Users must infer meanings from names alone, which is insufficient for several ambiguous parameters.

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

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

The description clearly states the tool's function: validating an address using country-specific rules and reporting hard failures as ADDRESS_INVALID. It explicitly distinguishes itself from related tools by noting it only performs a check and leaves the address book unchanged, with a direct pointer to address_upsert for modifications.

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 explicit when-to-use guidance: 'Nur eine Prüfung' (only a check) and excludes creating/changing addresses, directing users to address_upsert. This is a clear, actionable usage guideline with a named alternative.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that amounts are net costs in cents and lists the included metric categories, providing interpretative context beyond the annotations. No contradiction with the annotations.

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

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

The description is concise and front-loaded, using two bilingual sentences. The first sentence states the core purpose and lists deliverables; the second adds essential unit information. Every sentence earns its place.

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

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

The description covers the tool's purpose and output categories well. Since there is no output schema, the exact response structure is not described, and the influence of parameters like topN or months on the output is left to the schema. Still, it is fairly complete for an analytics summary tool.

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

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

Schema description coverage is high (83%), with each parameter already described. The description lists the metric categories and unit details but does not add new parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description explicitly states 'Liefert die aggregierten Kennzahlen des Partnerkontos' and enumerates specific metrics, making it clear that this tool returns aggregated account analytics. This distinct purpose is not covered by any sibling tool, 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 implies use for retrieving account metrics, but it does not explicitly state when to use this tool over alternatives or mention exclusions. It provides context but no direct comparison with sibling tools.

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

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

Beyond the annotations (destructiveHint=true), the description discloses the 10-minute dispatch delay, the cancellation path via order_cancel, the draft/refund behavior on rejection, and the mandatory consent gate. This is rich behavioral context that annotations alone do not provide, and there is no contradiction.

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

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

The description is front-loaded with the core action and uses a clear warning structure, but the entire content is repeated in German and English, doubling the length without adding new information. As a result, not every sentence earns its place.

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

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

For a high-complexity decision tool with destructive side effects and no output schema, the description thoroughly covers the required preconditions, the 10-minute grace period, cancellation via order_cancel, and the consequences of rejection. It is sufficient for safe and correct invocation.

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

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

Schema description coverage is only 17%, and the description compensates well for the key parameters: it explains user_saw_preview's consent requirement and defines approve/reject semantics (delay vs. draft+refund). It does not elaborate on comment, reasoning, or clientOrderId, but these are optional and reasonably inferable from their names.

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

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

The description opens with a specific verb+resource: 'Gibt eine wartende Freigabe ... frei oder lehnt sie ab' (approves or rejects a pending approval). It clearly states the tool's scope, but does not distinguish itself from the sibling 'approval_decide_app', so it lacks explicit sibling differentiation.

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

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

The description provides explicit procedural guidance: before calling 'approve', the agent MUST show the preview link, exact price, and delivery type, obtain explicit consent, and then set user_saw_preview:true. It also names order_cancel as the alternative for stopping during the 10-minute window and describes rejection behavior. However, it doesn't contrast with approval_decide_app.

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

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

Annotations only indicate readOnly=false and destructive=false. The description adds valuable behavioral detail: on approval, the letter is sent after 10 minutes and can be stopped until then. This goes beyond the structured annotations, though it does not cover all potential 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 duplicates all content in German and English, roughly doubling the length. Each language part is concise, but the repetition is unnecessary and could be streamlined. The core information is front-loaded in the 'Nur fuer' phrase, but the structure could be tighter.

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

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

The tool has no output schema and moderate complexity (4 params). The description explains the core behavior and the 10-minute delay, but omits parameter semantics and any return behavior. It is functional but leaves gaps for correct invocation.

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

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

The input schema has 4 parameters with 0% description coverage. The description only implies a decision (approve/reject) but does not explain approvalId, cardNonce, or reasoning. This leaves the agent without guidance on how to populate the parameters correctly.

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 (approves or rejects) and the specific resource (the displayed approval on the interactive card). It also distinguishes itself from the sibling 'approval_decide' by explicitly stating it is for the interactive approval card only.

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

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

The description gives explicit context: 'Only for the interactive approval card' and 'after the human pressed the button on the card'. This sets a clear usage condition and implies when not to use the tool, though it does not explicitly name alternatives.

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

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

Annotations already declare readOnlyHint and destructiveHint, so the description does not need to repeat safety. It adds valuable behavioral details: ordering (newest first), time-limited PDF preview, included fields (cost, reason, deadlines), and default pending filter. This meaningfully complements the annotations.

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

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

The description is concise and front-loaded with the core purpose. The bilingual repetition (German and English) is redundant but not excessive; each clause provides useful information. It is appropriately sized for the content covered.

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

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

Given there is no output schema, the description lists what the response includes (PDF preview, cost, reason, deadlines) and the default filter. It covers the essential behavior for a list tool, with parameters handled by the schema. It is complete enough for the agent to understand what to expect.

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 80%, so the schema already documents most parameter semantics. The description adds only minor context (default pending status aligns with status parameter) but does not elaborate on limit, since, offset, or reasoning. It does not strongly compensate for the undocumented reasoning parameter but remains adequate.

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 account approvals with specific details (newest first, PDF preview, cost, reason, deadlines). It distinguishes itself from siblings by explicitly mentioning the follow-up approval_decide tool, making its role in the workflow unambiguous.

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

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

The description provides clear context: use to list approvals, then decide via approval_decide. It notes the default pending status and implies the status parameter for filtering. While it does not explicitly exclude alternatives like approval_status_app, the workflow guidance is strong.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds valuable context about the time-limited nature of the image links and the expiration condition. It does not contradict the annotations; 'renew' in this context refers to generating fresh URLs rather than mutating persistent data.

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 two short sentences (German and English) that deliver the essential scope, action, and condition without fluff. It is front-loaded with the key restriction ('Nur fuer...') and follows with the operational trigger.

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 no output schema, the description covers what it does, when to use it, and its scope. It does not explicitly describe the return value, but the action implies the output is the renewed image links. Overall, it is sufficiently complete for this tool's complexity.

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

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

The schema has 0% description coverage, but the single parameter 'approvalId' is self-explanatory and its purpose is implied by the tool's scope ('approval card'). The description does not explicitly explain the parameter, leaving slight ambiguity, but the parameter name and context are sufficient for basic correct usage.

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

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

The description uses a specific verb ('renew') and resource ('image links of the letter pages'), and explicitly scopes it to the interactive approval card. This clearly differentiates it from sibling tools like letter_page_urls_app and template_page_urls_app by stating 'Nur fuer die interaktive Freigabe-Karte' / 'For the interactive approval card only.'

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

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

The description provides clear context: it is only for the interactive approval card and should be used when old time-limited image links have expired. It does not explicitly name alternatives or state when not to use it, but the 'only' constraint and expiration condition give adequate guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'reads' aligns with this. It adds the card-specific context (old card rendering) but no additional behavioral traits such as error handling, authentication requirements, or rate limits. Doesn't contradict annotations.

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

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

Two short bilingual sentences, front-loaded with the core action and scoping. Every word earns its place, 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?

For a simple single-parameter read-only tool with good annotations, the description covers the purpose and specific use case (countdown/end state rendering). It lacks explicit return format details, but given the simplicity and lack of output schema, it's adequately 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 1 required parameter (approvalId) with 0% description coverage. The description does not mention or explain the parameter directly, and while the purpose makes it somewhat obvious, it fails to compensate for the schema gap by clarifying the parameter's role or 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 reads the current state of an approval (specific verb + resource), and explicitly scopes it to 'the interactive approval card only', distinguishing it from siblings like approval_list or approval_submit. The intended use case (rendering correct end state and countdown on old cards) adds 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?

The description says 'Nur fuer die interaktive Freigabe-Karte' ('For the interactive approval card only'), providing a clear usage restriction. It also explains the purpose in context (rendering end state and countdown), though it doesn't explicitly name alternative tools or exclusions beyond the 'only' qualifier.

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

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

Annotations only provide readOnlyHint=false, destructiveHint=false, which are minimal. The description goes far beyond by disclosing side effects: it checks mandatory details, recipient, AVV and limits, creates the final PDF, calculates price, reserves costs, and adds an approval to the queue. It also explains dryRun behavior (balance and queue untouched) and that approvalId is returned for later approval. This is rich behavioral context that helps the agent anticipate consequences.

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 long due to bilingual repetition, but every clause carries meaningful information: the action, the checks, the side effects, and the dryRun behavior. It is front-loaded with the purpose and structurally clear. The length is justified by the tool's complexity, though the German/English duplication makes it less concise than a single-language version.

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 (29 parameters, no output schema, minimal annotations), the description covers the overall workflow, side effects, and the returned approvalId. It explains the approval lifecycle and dryRun semantics. However, it omits details about return values beyond approvalId, error conditions, what AVV specifically means, and how it relates to draft creation or sending tools. Still, it is substantially more complete than typical for a tool of this size.

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 low (~28%), so the description must compensate for under-documented parameters. The description does clarify some parameter-related semantics: dryRun stops before reserving costs, maxCostEuros relates to limits, recipient fields to the recipient check, and approvalMode to the approval flow. However, many parameters (e.g., approvalMode, scheduledAt, templateId, signatureId, auditTag, reasoning) remain unexplained, and the description does not map to all parameters. The compensation is partial, not sufficient for 29 parameters.

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: submitting a letter for human approval instead of sending it immediately. It specifically identifies the resource (letter) and the action (submit for approval), and distinguishes itself from approval_decide by explaining that sending only occurs after approval. This is a specific verb+resource description that also differentiates it from sibling tools.

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

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

The description explains when to use the tool: when a letter needs human approval before sending, and explicitly mentions that sending happens only after approval via approval_decide. It contrasts with immediate sending, indicating a clear alternative context. However, it does not explicitly name alternative tools like order_send or letter_schedule, so the guidance is clear but not exhaustive.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds that this is a scheduling operation returning a job ID rather than executing the export directly. However, it does not disclose potential side effects such as email notifications or file generation, though these are partly covered by the annotations.

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

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

The description is two sentences, one in German and one in English, with no filler or redundant detail. It front-loads the core purpose and returns valuable information concisely.

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 provides the essential purpose and return value (job ID), but with 8 parameters and no output schema, it lacks detail on optional filters, target destination, and notification behavior. It is adequate for basic understanding but incomplete for confidently invoking the tool with complex options.

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 carry the burden of explaining parameters. It mentions date range and format types (GoBD CSV, DATEV, etc.), but it does not explain the meaning or expected format of 'since', 'until', 'target', 'senderProfileFilter', 'mandantennummerFilter', or 'notifyEmail', leaving most parameters underspecified.

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 schedules an archive export, lists the supported formats, and mentions it returns a job ID for status queries. This distinguishes it from the sibling archive_export_status, which is for querying status.

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

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

The description provides clear context: use this tool to schedule an export for a date range and obtain a job ID. It implicitly distinguishes from the status-checking sibling by mentioning the job ID, but it does not explicitly name alternatives or state 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, which the description does not contradict. It adds useful behavioral context by specifying the 90-day validity of the download URL and that the URL is provided only upon completion, which goes beyond the basic annotations.

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

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

The description is bilingual but compact, with two sentences conveying purpose, the asynchronous nature, and the URL validity. Every word contributes meaningful information, and the key details are front-loaded.

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

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

For a tool with no output schema, the description gives a high-level summary of return values (status and download URL) but lacks details on possible statuses, error handling, or what happens if the job is not complete. It is adequate for basic understanding but leaves gaps in fully predicting behavior.

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

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

Schema description coverage is 0%, so the description must compensate. It does not mention jobId (though likely inferable from name and context) or the optional 'reasoning' parameter at all. Given the low coverage and lack of explanation, the description adds minimal value for parameter understanding.

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

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

The description clearly states the tool 'returns the status of an archive export job' and adds the key detail of a 90-day download URL upon completion. This specific verb+resource combination distinguishes it from sibling archive_export and other tools.

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

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

The description provides clear context that this tool is for checking archive export job status. It does not explicitly exclude other uses or name alternatives, but the pairing with archive_export is obvious from the name and sibling list, giving sufficient guidance.

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

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

Annotations only indicate mutation (readOnlyHint=false), so the description adds valuable context: server-side scaling to A4, merged page count check (max 30), automatic EXIF orientation application, and rotation behavior. These behaviors go beyond the annotations and help predict side effects. However, it does not disclose error handling when the page limit is exceeded or any auth requirements, preventing a perfect score.

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 and front-loaded with the core purpose, but the bilingual repetition (German and English) doubles the length without adding unique value. Despite this redundancy, it remains readable and every key behavior is covered without excessive verbosity.

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

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

With no output schema and 7 parameters, the description explains the main processing flow but lacks details on return values, error conditions (e.g., page limit exceeded, invalid image source), and prerequisites (e.g., letter existence or permissions). It is adequate for a basic understanding but leaves important operational gaps.

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

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

Schema coverage is only 43%, so the description must compensate. It provides significant extra meaning for the rotation parameter by explaining that EXIF orientation is already baked in and rotation applies on top, which is crucial. However, it does not elaborate on title, position, reasoning, or the imageUrl/imageBase64 alternative beyond what the schema already states, leaving gaps for less obvious parameters.

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 specific action (upload image) and resource (partner letter), and differentiates from sibling tools like attachment_upload_pdf by specifying that images (PNG/JPEG) are converted to PDF pages. The verb 'Lädt ... hoch' is explicit and the scope is unambiguous.

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

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

The description implies usage context (uploading images to letters) and provides guidance on the rotation parameter ('leave it at 0 unless you deliberately want to turn the image further'), but does not explicitly state when to prefer this over attachment_upload_pdf or mention exclusions. No explicit alternative is named, so it is below the 'clear context with alternatives' level.

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

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

The annotations indicate the tool is not read-only and not destructive. The description adds valuable behavioral context beyond annotations by disclosing pre-save validation checks: file size (max 50 MB) and merged page count (max 30 pages including letter and other attachments). This informs the agent of potential failure conditions and sets expectations for what the tool will reject.

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 bilingual but remains concise, with each language version providing the same core action and validation constraints. The first sentence states the purpose, the second adds critical limits, making it well-structured and front-loaded without redundancy or unnecessary detail.

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

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

The tool has 6 parameters, no output schema, and only 33% schema description coverage. While the description covers the main upload action and validation limits, it omits meanings for parameters like title, position, reasoning, and the mutual exclusivity of pdfUrl/pdfBase64. It also does not mention any return value or success/failure indicators. Overall, the description is adequate for understanding the general purpose but incomplete for full operational usage.

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 only 33% (2 of 6 parameters have descriptions). The tool description does not compensate by explaining the remaining parameters (title, letterId, position, reasoning) or clarify that exactly one of pdfUrl/pdfBase64 is required. It adds no parameter-specific semantics, leaving a significant gap for the low-coverage fields.

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 identifies the tool's function: 'Lädt ein PDF als Anhang zu einem Partner-Brief hoch' (uploads a PDF as an attachment to a partner letter). It is specific with a verb and resource, and it distinguishes itself from sibling tools like 'attachment_upload_image' by specifying PDF and partner letter context. The extra validation details further clarify the exact operation.

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

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

The description provides clear context that this tool is for uploading PDF attachments to partner letters, with specific constraints (file size, page count). However, it does not explicitly mention alternatives or exclusionary guidance, such as 'for images use attachment_upload_image' or 'do not use for other file types'. Thus it lacks explicit when-not-to-use instructions.

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 that found logos are stored as design assets in the account (a write side effect), and that the result is only a proposal until brand_kit_save is called. This goes beyond the annotations, which only set readOnlyHint=false, and provides clear behavioral context.

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

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

The description is unnecessarily long and repetitive, including full German and English versions plus a redundant 'Suche technisch nach brand_import_from_website'. The duplication and meta-instruction waste space and reduce clarity.

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

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

With no output schema, the description adequately explains the outcome (a proposal to review) and the required follow-up (brand_kit_save). It covers side effects and website accessibility, but could further clarify return value structure or edge cases like no logos found.

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 already cover all 100% of parameters, so baseline is 3. The description adds no new param-level details, though the mention of 'Logo-Kandidaten' indirectly relates to maxLogoCandidates without adding syntax or additional meaning.

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

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

The description clearly states the tool reads a public company website and proposes a letterhead design, listing specific outputs (brand colors, typeface, logo candidates, company details). It differentiates from siblings like brand_kit_save by emphasizing the website import and proposal 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?

Provides workflow guidance: result is a proposal for customer review, and the brand is only adopted via a subsequent brand_kit_save call with brandingOwnershipConfirmed. It implies when to use, though it doesn't explicitly mention alternatives 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is confirmed. The description adds the return payload (logo references, colours, font), which is useful, but it does not disclose any additional behavioral traits such as data freshness, caching, or permissions. This is adequate given the annotation coverage.

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 duplicated in German and English, which doubles its length without adding information, and includes an extraneous sentence 'Suche technisch nach brand_kit_get.' It is not overly long but contains redundant and confusing elements that prevent it from being tightly structured.

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 read-only tool with no output schema, the description explains what is returned (logos, colors, font) and its place in the design workflow. It does not cover error cases or the reasoning parameter, but the overall context is complete enough for an agent to select and invoke the tool correctly.

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

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

The only parameter 'reasoning' has no description in the schema (0% coverage) and is not mentioned in the tool description. The agent is left to infer its purpose from the name alone. While the parameter is optional, the description does nothing to clarify its meaning or usage.

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 identifies the action (Liest/Reads), the resource (saved brand values for Briefkopf & Marke), and the specific outputs (logo references, colours, font). It distinguishes itself from siblings by positioning it as the retrieval step before letter_design_preview and letter_design_save.

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 states that the returned brand values are 'fuer die weitere Gestaltung mit letter_design_preview und letter_design_save', giving a clear usage context. It does not explicitly list exclusions or alternatives, but the workflow hint is sufficient for a read-only tool with an obvious save counterpart (brand_kit_save).

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 that ownership confirmation is mandatory and that the response contains the saved state and review link, adding context beyond the annotations. It does not disclose whether the operation overwrites existing data or what permissions are needed.

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 bilingual German/English repetition doubles length, and the sentence 'Suche technisch nach brand_kit_save' is unnecessary meta-commentary. The core information is present but could be expressed more efficiently.

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 absence of an output schema, the description gives useful return info (saved state and review link) and the required validation flag. Yet it omits the 'reasoning' parameter and any error or overwrite semantics, so it is only minimally complete for a mutation 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?

It adds meaning to the brandKit parameter by explaining it contains logo references, colors, and font, and clarifies brandingOwnershipConfirmed's purpose. However, it does not mention the optional 'reasoning' parameter, and schema coverage is low at 33%.

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 saves logo references, colors, and font for the user-facing letterhead/brand result, distinguishing it from sibling tools like brand_kit_get (retrieve). The verb 'Saves/Speichert' and resource are 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?

It provides clear context for use (saving brand kit for letterhead) and explicitly requires brandingOwnershipConfirmed to be true as a precondition. However, it does not explicitly mention alternatives or when not to use this tool.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description adds important behavioral context: drafts remain free until sent, FrankKi re-computes and validates amounts, and the document is set in a specific layout. It also mentions the returned letterId. No contradictions with annotations.

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

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

The description is excessively long due to full bilingual repetition and a large inline example. The opening sentence is clear, but the overall size is inflated and not every sentence earns its place, affecting conciseness and efficient token use.

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 complex tool with nested objects and no output schema, the description covers the core behavior, validation, numbering, layout, and next steps. It is fairly complete but lacks explicit error behavior or what happens on validation failure, and does not describe all parameters.

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 compact example and the 'all amounts in integer cents' note add valuable meaning beyond the schema. However, with schema description coverage at only 47%, many top-level parameters (designId, signatureId, includeSignature) remain unexplained in the description, so it only partially compensates for the low coverage.

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

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

The description clearly states the tool creates a finished document from structured billing data and stores it as a letter draft, with specific actions like recomputing amounts, checking §14 UStG, and drawing document numbers. This distinguishes it from siblings like letter_create_draft by emphasizing billing validation and document generation.

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

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

The context implies usage for billing documents (invoices, reminders, dunning) and provides next-step workflow guidance (order_send, approval_submit, letter_schedule), but it does not explicitly name alternatives or state when not to use this tool. It is clear but not explicit about exclusions.

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

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

Annotations already indicate readOnlyHint=true. The description adds substantial behavioral context: referencePrefill is meant to be pasted unchanged, exports are signed download links only, and error reasons (DOCUMENT_EXPORT_NOT_READY vs NOT_SUPPORTED) are explained. No contradiction with annotations.

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

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

The description is front-loaded with the core purpose, but it is very long and duplicates the entire content in German and English. Every sentence does not earn its place due to the bilingual repetition, making it about twice as long as 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?

There is no output schema, so the description carries the full burden of explaining return values. It does so exhaustively: referencePrefill usage, export formats (ZUGFeRD, XRechnung), download-only semantics, error reasons, and next steps. This makes the tool's behavior highly predictable 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?

The input schema contains documentId and reasoning, but the description never mentions either parameter. With 0% schema description coverage, the description should have compensated by explaining what documentId refers to, but it only implies it through the word 'document'.

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

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

The description clearly states the tool's function: it returns one document with full payload, including line items, totals, VAT rates, and reference, plus letterId and orderId. This is specific and distinguishes it from siblings like document_list and document_create.

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 recommended follow-up actions (order_status, document_create) and explains when exports are not available, thus implying when this tool is the right choice for retrieving a document with follow-up context. However, it does not explicitly contrast with other retrieval tools like document_list.

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

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

Annotations already signal a read-only, non-destructive operation. The description adds useful behavioral details beyond that: 'neueste zuerst' (newest first) and 'deine erzeugten' (documents you created) scope, plus filtering dimensions. It does not contradict annotations.

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

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

The description is concise and front-loaded with the action and scope. The bilingual repetition is somewhat redundant but acceptable. Every sentence provides useful information, no filler.

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

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

For a list tool with 9 parameters and no output schema, the description is decent but incomplete. It hints that document_get returns the full payload, implying this list returns partial data, but it does not describe the return structure, pagination behavior, or the meaning of 'since' and 'reasoning'. More detail would be needed for full 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 description coverage is 44%, so the description must compensate. It explains filter parameters (Art, Mandant, Empfänger, Bezugsbeleg) at a high level, but leaves 'since', 'offset', and 'reasoning' unexplained. Limit/offset are partially covered by schema descriptions.

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

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

The description clearly states the tool lists user-created documents with specific types (invoice, payment reminder, dunning letter, credit note), newest first, with filter dimensions. It explicitly distinguishes from document_get (full payload) and document_create (follow-up), satisfying the differentiation criterion.

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

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

It provides clear usage context: lists documents you created, filtered by specific criteria, and names next-step tools (document_get, document_create). However, it does not explicitly exclude letters or other sibling tools like letter_list, though the scope is implicitly limited to financial document types.

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

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

Beyond the annotations (which only say readOnly=false, destructive=false), the description thoroughly discloses behavior: it creates and stores a draft, generates a preview PDF, returns a 24h preview link, delivers warnings, returns images for checking, and clarifies that paid/print is final. This is far more transparent than the annotations alone.

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

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

The description is front-loaded and logically organized, but the full German content is repeated in English, doubling the length unnecessarily. While every sentence provides value, the bilingual duplication makes it less concise than it could be.

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?

Even without an output schema, the description explains the key return values (page count, preview link validity, cost estimate, images, warnings) and the draft lifecycle. It also references the blocks-guide resource for detailed parameter semantics. For a complex 15-parameter tool, this is quite complete, though the output payload structure is not fully specified.

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 critical parameter semantics not fully in the schema: clear exclusivity between content and blocks, a compact blocks example, limits, and a pointer to the full blocks-guide resource. With schema coverage at 67%, the description compensates for the most complex parameters, though many simpler parameters are left to 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 opens with 'Legt einen Briefentwurf an' and then concretely explains what it does: creates a preview PDF, stores the draft, and returns page count, preview link, and cost estimate. It also names related sibling tools (letter_preview, order_send, letter_schedule) as next steps, distinguishing this creation tool from send/preview 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?

The description gives clear workflow guidance: drafts stay free until sent, you can fix and recreate drafts, and after creation you can preview, send, or schedule via the returned letterId. It does not explicitly state when NOT to use this tool, but the context strongly implies it is for drafting before sending.

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

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

The annotations already indicate this is a destructive operation (destructiveHint: true). The description adds significant behavioral context beyond annotations: it clarifies that the operation is an 'archive/delete' and explains the impact on future sends versus already-sent letters, including the retention of original letterheads for auditability. This provides valuable transparency about the operation's side effects and non-reversibility (or archival nature).

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 structured well, front-loading the core action and then explaining consequences. However, it duplicates the same content in German and English, which introduces redundancy. Each language version essentially repeats the other, making the description longer than necessary for an AI agent to parse. It is not as concise as it could be, but the information is organized logically.

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

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

There is no output schema, so the description is responsible for conveying behavior. It thoroughly covers the lifecycle impact: new sends use remaining letterheads, and sent letters retain the original for auditability. This is sufficient for a delete/archive tool. It does not describe return values or error conditions, but for this operation the description is essentially complete given the annotations.

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 50% coverage (designId has a description, reasoning does not). The tool description does not mention either parameter or provide any additional meaning beyond the schema. For example, it does not explain what 'reasoning' is for or how designId should be obtained. Since the schema coverage is moderate and the description does not compensate, the parameter semantics are underrepresented.

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: 'Archiviert (loescht) ein gespeichertes Briefpapier' (archives/deletes a saved letterhead). It uses a specific verb and resource, and it distinguishes this tool from siblings like letter_design_save (create/update) and letter_design_list by explicitly describing the deletion/archival function and its consequences.

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 practical effect of deletion ('New sends then run on the remaining letterheads') and notes that sent letters keep their original for auditability. This provides clear context on the tool's impact but does not explicitly state when to use it versus alternatives (e.g., letter_design_save for modifications) or provide when-not-to-use guidance. Usage is implied rather than explicitly directed.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds context that designs are referenced by name/id and can carry all mail types, but it does not disclose return structure or pagination. This is acceptable given the annotations, but the added behavioral detail 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 bilingual and front-loaded with the core purpose, but it repeats the same information in German and English, making it longer than necessary. Every sentence does not earn its place overall, though the structure is clear.

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 list tool, the description covers the resource and its purpose, but it does not explicitly differentiate from sibling list tools or address archived behavior beyond the schema. With no output schema, it could still benefit from noting pagination or the absence of filtering.

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 50%: only 'includeArchived' has a description, while 'reasoning' is undocumented. The tool description does not explain either parameter or add meaning beyond the schema, failing to compensate for the missing rationale behind the 'reasoning' parameter.

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 the partner's saved letter designs (Briefpapiere) including full design JSON. It specifies the resource and verb, and distinguishes from siblings by emphasizing 'gespeicherten' (saved) designs and the reference by name/id when sending, which separates it from presets or preview tools.

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

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

The description implies the tool is used to view saved designs for later referencing when sending mail, and lists the mail types covered (cancellation, invoice, etc.). However, it does not explicitly mention when to use this over sibling tools like letter_design_list_presets or letterhead_list, nor 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?

Annotations already mark it read-only, but the description adds valuable behavioral context: the plain list is text-only and cheap, while presetId triggers a real composer preview with inline PNG, and the list grows with approved templates. No contradictions with annotations.

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

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

The description is well-structured and informative but repeats the same content in both German and English, which adds length without additional value. Despite this, it is still reasonably concise.

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

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

With no output schema, the description should clarify what the list contains (e.g., fields, metadata) and how parameters like resolution and pages affect output. It covers the core behavior and use cases but leaves these gaps, making it slightly incomplete for a 4-parameter tool.

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

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

The description adds meaning for presetId (switching to preview mode) and mentions the list becomes image-free without it. However, pages and resolution are not explained, and with only 25% schema coverage, these parameters remain unclear for an agent.

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 returns owner-approved native-v2 letterheads as safe starting points for various document types, and emphasizes it grows with approved templates. This distinguishes it from sibling tools like letter_design_list by focusing on curated presets.

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

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

It explains the tool is for cancellations, invoices, etc., and provides guidance on choosing between a cheap text-only list and a rendered preview via presetId. However, it does not explicitly name sibling alternatives or state when NOT to use the tool.

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

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

The description goes well beyond the readOnlyHint annotation: it states the run is free, the letter remains a draft, it uses real partner sender data with a fictional recipient and sample body, returns an inline PNG page, and page 2 only appears for continuationHeader. It also explains the visual behavior of sampleVariant empty.

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

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

The description is front-loaded with the primary purpose and structured into render behavior and sampleVariant empty use case. It is long due to bilingual German/English repetition, but each sentence adds relevant detail rather than padding.

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

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

For a complex tool with no output schema, the description covers the return format (inline PNG page), page count behavior, cost/draft effects, and the difference between typical and empty sample variants. It doesn't fully document all parameters but gives enough context to invoke the tool for design preview.

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 only 22% schema description coverage, the description partially compensates by explaining pages behavior, sampleVariant empty, and schemaVersion support. However, several parameters (designId, reasoning, reference, resolution, sampleContent, sampleSubject) receive no descriptive help, so the agent must rely on schema names.

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

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

The description opens with a specific verb: 'Rendert ein gespeichertes oder inline uebergebenes Briefdesign' (renders a saved or inline letter design) and clarifies scope: schemaVersion 1 or 2, same resolution/composer as a real send. It clearly differentiates from sibling tools like letter_preview or template_preview by focusing on letter design preview.

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

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

It provides clear context for when to use the tool: to preview how a design looks on stationery, with sampleVariant empty for the exact dashboard picture. It doesn't explicitly name alternatives or say when not to use it, but the use cases (cancellation, invoice, etc.) make the intended scenario evident.

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

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

Annotations already indicate a non-read-only, non-destructive operation. The description adds valuable context: the design is fully validated and checked against postal clear zones before storage, and it returns a stored-source hash. This goes beyond the annotations, although it does not disclose error behavior or potential side effects like overwriting.

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

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

The description is front-loaded with the core action and includes useful use-case context. However, it duplicates content in German and English and contains an odd sentence about client-side tool unload, which adds unnecessary length and distracts from the tool's behavior.

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 complex schema (5 params, nested design object) and no output schema, the description is incomplete. It covers purpose and validation but misses key details about parameter semantics (especially designId as both input and output), update vs. creation behavior, and error handling. An agent would need more information to invoke the tool correctly with all parameters.

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 only 40%, so the description should compensate by explaining parameters. It mentions schemaVersion 1 or 2 in the design but does not clarify the roles of designId (which appears as both input and output), reasoning, or brandingOwnershipConfirmed. The description's statement that it returns designId could confuse agents since designId is also a schema property.

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

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

The description states a specific verb and resource: "Speichert ein wiederverwendbares Briefpapier (Briefdesign) mit schemaVersion 1 oder 2 im Partnerprofil und gibt designId sowie den Hash der gespeicherten Quelldaten zurueck." This clearly distinguishes it from sibling tools like letter_design_delete, letter_design_list, and letter_design_preview by focusing on the save action.

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

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

It provides clear usage context: the letterhead is reusable and applies to all mail types (cancellation, invoice, payment reminder, etc.), which implies when to use it. However, it does not explicitly name alternatives or state when not to use it, nor mention prerequisites such as branding assets or ownership confirmation.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds useful behavioral context by specifying that the download URL is valid for 24 hours and that the response includes the associated order, which helps the agent handle time-sensitive data. This goes beyond the annotation baseline, though it omits details like error handling or authentication.

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

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

The description is short and starts with the verb, but it duplicates the same information in German and English. The English sentence adds no new content, so the second sentence is redundant. It is not overly verbose but could be improved by removing duplication or adding unique details.

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

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

Given there is no output schema and three parameters, the description provides a high-level overview but lacks critical details about how the letter/order is selected via parameters and the exact structure of the response. The 24-hour URL validity is a good detail, but the absence of parameter semantics and return-field documentation leaves gaps in the tool's 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?

The schema has 0% description coverage, and the description does not explain the meaning or usage of orderId, letterId, or reasoning. Although the description mentions returning a letter and order, it never maps these to the parameters, leaving the agent to infer how to specify the target letter. The description fails to compensate for the low schema coverage.

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

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

The description clearly states the tool returns a partner's letter along with its order and a time-limited PDF download URL. The verb 'Returns' plus the specific resource distinguishes it from sibling tools like letter_list and letter_search, which are for listing or searching.

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 such as letter_list or letter_search. It does not mention prerequisites, preferred scenarios, or when another tool would be more appropriate, leaving the agent without explicit selection criteria.

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

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

The description adds meaningful behavioral context beyond the readOnlyHint and destructiveHint annotations by disclosing that the preview URL is short-lived (valid for 24 hours). It does not cover other behaviors like pagination or error handling, but the annotations already cover the safety profile, so this added detail earns a 4.

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, providing the core purpose and a key detail (URL validity) in just two short sentences. It is front-loaded and every word earns its place, with no redundancy despite being bilingual.

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 list tool with one optional parameter and no output schema, the description covers the primary behavior and the preview URL expiration. However, it fails to explain the reasoning parameter and does not describe the response structure, leaving some gaps that could be filled given the absence of an output schema.

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

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

The only parameter, 'reasoning', is entirely unexplained in the description. With schema description coverage at 0%, the description should compensate by clarifying the parameter's purpose or expected values, but it does not. This leaves the agent without guidance on how to use the optional parameter.

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 explicitly states that the tool lists letterheads stored in the partner profile and highlights the unique feature of a short-lived preview URL (24 hours). This clearly distinguishes it from sibling tools like letterhead_upload (uploading) or letter_list (listing letters), making its purpose unambiguous.

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

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

The description implies when to use the tool (when you need a list of letterheads with preview URLs) but does not explicitly mention alternatives or exclusion criteria. It lacks guidance on preferring this over letter_design_list or letterhead_upload, so usage is implied rather than explicitly guided.

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 that PDF letterheads are stored but not printed (rendered=false), while PNG is printed. This is critical behavioral information beyond the empty annotations.

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

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

The bilingual structure duplicates content and lengthens the description, but each section carries unique information and the layout is logical. Slightly verbose but not wasteful.

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

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

With 7 optional parameters and no output schema, the description covers the core behavior, constraints, and contextual usage thoroughly, including the rendered=false nuance and letter-rebuild guidance.

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 high (86%) and includes detailed parameter descriptions. The description adds the exclusive-or relationship between fileUrl and fileBase64 and the preference for fileUrl, complementing the schema.

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

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

The description clearly states it uploads a letterhead as PNG or PDF and stores it in the partner profile. It distinguishes from siblings like letterhead_list and letter_design_save by specifying the exact action and resource.

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 explains when to use fileUrl vs fileBase64 and requires exactly one of them. Also gives contextual guidance on what belongs here versus letter_design_save and blocks when rebuilding a letter.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond the filters, such as pagination behavior or default sorting. It neither conflicts with annotations nor provides extra useful behavioral details, hence a mid-range score.

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 two short sentences (one per language) with no filler. It gets straight to the point, describing the purpose and filter capabilities efficiently.

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

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

With no output schema and multiple parameters, the description omits return format, pagination behavior, and how filters combine. It doesn't explain the meaning of offset/limit or the reasoning parameter. This leaves significant gaps for an agent to invoke the tool correctly beyond basic listing.

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 should compensate. It maps 'recipient name' to recipientNameContains, 'subject' to subjectContains, 'status' to statusFilter, and 'time' to since, but leaves limit, offset, and reasoning unexplained. This partial semantic help warrants a 3.

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

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

The description clearly states the tool's function: 'Listet die Briefe des Partners mit optionalen Filtern...' (Lists the partner's letters with optional filters). It specifies the resource (letters) and the verb (list), and differentiates from siblings like letter_get and letter_search by emphasizing the list-with-filters capability.

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

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

The description gives no guidance on when to use this tool vs alternatives. It doesn't mention letter_search or letter_get as alternatives, nor any exclusions or prerequisites. The usage context is merely implied by the name 'list'.

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

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

The annotations declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds context about time-limited links and expiration, which is useful. The verb 'erneuert' could imply mutation, but it is not a clear contradiction with the read-only annotation, especially since the tool is scoped to an interactive view.

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

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

The description is compact, with a German sentence and an English translation. It front-loads the scope and action. The bilingual repetition is slightly redundant but still concise 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?

For a simple one-parameter tool with annotations, the description conveys the purpose and trigger condition. However, it does not mention what the response contains (e.g., the renewed URLs), and there is no output schema to provide that information, leaving a minor completeness gap.

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

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

The schema has 0% description coverage for the single parameter letterId. The description does not explicitly explain the parameter, relying on its name and the context of 'letter pages' to infer meaning. It adds minimal semantic value beyond the schema.

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

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

The description clearly states the action ('reneuert' / 'renews'), the resource (time-limited image links of letter pages), and the scope ('interactive letter view'). It does not explicitly differentiate from sibling tools like template_page_urls_app, but the resource is specific enough for an agent to understand its purpose.

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

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

The description provides clear usage context: 'Nur fuer die interaktive Brief-Ansicht' (only for the interactive letter view) and the condition 'when the old ones have expired'. This implies exclusions (not for other views) but does not name alternatives or explicitly state 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?

Beyond annotations (readOnlyHint=true, destructiveHint=false), the description discloses that the preview is free of charge, the letter remains unsent ('bleibt liegen'), an unsaved design applies only to that preview, and form mode drops recipient block/date/subject and starts content at 27mm. This is significant additional behavioral context.

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

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

The description is long but front-loaded with the core function, then provides input modes, warnings, a JSON example, and a workflow. It is bilingual, which repeats content, but is well-organized and each section has a purpose. A slightly shorter version could preserve the essential guidance, but the structure is logical.

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 (13 params, nested design object) and absence of an output schema, the description covers the primary use cases (preview, form preview, rebuild), the key return components, and the critical behavioral nuances. It doesn't explain every parameter, but the schema descriptions fill most gaps, and it references frankki://blocks-guide for deeper specification, so it is sufficiently complete for an agent to 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?

The schema already describes most parameters (77% coverage), giving a baseline of 3. The description adds a concrete blocks example, explains the content/blocks mutual exclusivity, highlights the transient nature of an inline design, and gives the specific design object needed for form mode, which goes beyond the schema's field-level 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 the tool previews letters and drafts as images, renders form previews, and returns inline PNGs, PDF link, page count, cost and designRender. It also distinguishes the tool's scope by mentioning 'actual documentMode, rendered letter chrome and bodyStartMm' and by making it mandatory for rebuilds, which sets it apart from generic preview tools.

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

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

The description gives explicit instructions: it says letter_preview is mandatory for rebuilds (PFLICHT), that forms should always be previewed first with a specific design, and that template_save/template_release should follow once the layout matches. However, it does not explicitly contrast with sibling tools like template_preview or letter_design_preview, so agents may need extra context to choose among them.

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

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

Discloses that all checks and pricing are performed immediately with cost reservation, and that the actual send runs later through the same pipeline. This adds valuable behavioral context beyond the sparse annotations.

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

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

Two bilingual sentences are efficient and front-loaded, though the English translation effectively doubles length. No wasted words, but slight redundancy from bilingual repetition.

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

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

For a complex tool with 22 parameters and no output schema, the description conveys the essential operation but lack details on response format, error handling, and the many parameters the schema doesn't document.

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 no specific parameter semantics beyond the schema; it only outlines the three scheduling modes. With schema coverage at 45%, many parameters remain undocumented without description assistance.

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 schedules the sending of an existing draft for a later time, with fixed, relative, or cron modes. This distinguishes it from immediate-send tools like order_send and from list/cancel tools like schedule_list_or_cancel.

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

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

The description clearly implies use for delayed sending ('for a later time') and notes checks are done immediately, but it doesn't explicitly name alternatives or exclusions. Context is clear, though not fully explicit.

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

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

Annotations already indicate read-only and non-destructive behavior, so the bar is lower. The description adds context about search scope (subject, recipient name, content) but doesn't disclose additional behavioral traits such as pagination defaults, matching behavior, or response format. It provides some value beyond annotations but not extensive context.

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

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

The description is a single concise sentence, repeated in English for clarity, with no wasted words. It front-loads the primary action and scope, 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?

The tool is a straightforward search operation with helpful schema annotations and parameter descriptions for limit, since, and offset. The description covers the core scope and query semantics. It doesn't explicitly describe the return format, but the tool's purpose is clear and the read-only annotations cover safety. Overall, it is sufficiently complete for most use 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 description coverage is 60%, and the description adds meaning to the 'query' parameter by specifying the fields it searches. However, the 'reasoning' parameter remains undocumented, and the description does not fully compensate for the schema gaps. It is adequate but not exceptional.

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: full-text searching the partner's letters across subject, recipient name, and content. The specific verb 'Durchsucht' and the resource scope distinguish it from sibling tools like letter_list and letter_get.

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

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

The description implies when to use this tool (when you need full-text search across letter fields) but does not explicitly state alternatives or when not to use it. It is clear enough for basic selection but lacks exclusionary guidance that would help an agent choose between it and letter_list.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds context about the returned fields, but it does not disclose potential edge cases or constraints (e.g., what happens if no identifier is provided, or whether the operation can fail). This adds some value but leaves gaps.

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

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

The description is compact: a single German sentence followed by an exact English translation. It front-loads the action verb and efficiently lists the included data fields with no superfluous words, making it fully concise and well-structured.

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 lists the returned fields, which is helpful given the absence of an output schema. However, it leaves unresolved the fact that no parameters are required, creating ambiguity about how the tool selects a single Mandant. It also does not explain the reasoning parameter, leaving the overall context incomplete for a get tool.

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

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

Schema description coverage is 0%, and the description offers no explanation of mandantId, mandantennummer, or reasoning. The parameter names are self-explanatory to a degree, but the description does not clarify which identifier is required or how reasoning is used, failing to compensate for the absence of schema descriptions.

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

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

The description clearly states a specific verb ('Liefert' / 'Returns') and resource ('einen Mandanten' / 'a client'), and enumerates the exact set of returned attributes (addresses, category, case handler, etc.). This distinguishes it from sibling tools like mandant_list and mandant_search, which would list or search rather than retrieve a single entity.

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 such as mandant_list or mandant_search. It does not mention required identifiers or exclusions, leaving the usage context entirely implied by the tool name and parameter names.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds the scope 'des Partners' (of the partner) and optional filtering, which is useful context but not extensive. No significant behavioral traits beyond annotations are disclosed.

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

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

The description is two concise sentences (German and English), front-loaded with the action and resource, and contains no redundant information.

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

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

For a simple read-only listing tool with good annotations, the description is largely complete: it states purpose, scope, and filter options. It lacks return format details (though no output schema exists) and leaves the 'reasoning' parameter unexplained, preventing a perfect score.

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 only 43% (3 of 7 parameters documented). The description compensates by explicitly naming three filter parameters: Suchbegriff (searchQuery), Kategorie (kategorieFilter), and Tag (tagFilter), providing semantic meaning not present in the schema. However, the 'reasoning' parameter remains unexplained, and limit/since/offset are left to the schema.

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

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

The description uses the specific verb 'listet' (lists) and clearly identifies the resource 'Mandanten des Partners' (partner's clients). It distinguishes from sibling tools like mandant_get (single client) and mandant_search (search) by specifying it's a list operation with optional filters.

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

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

The description implies when to use the tool by mentioning optional filters for search term, category, or tag, suggesting it's for listing with possible narrowing. However, it does not explicitly name alternatives or state when not to use it, leaving the choice among siblings to inference.

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

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

Annotations already mark readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds a concrete behavioral detail: 'nennt für jeden Treffer die passende Spalte' (names the matching column for each hit), which goes beyond the annotations. It does not describe pagination behavior, but with annotations covering safety, this is acceptable.

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

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

The description is front-loaded with purpose and next steps, but it is duplicated in German and English, making it longer than strictly necessary. Every sentence is informative, and the duplication is justifiable for a bilingual context. No filler 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?

For a search tool with 5 parameters, no output schema, and read-only annotations, the description covers search criteria, output behavior (matching column), and follow-up tool options. It does not describe the response format in detail (e.g., pagination metadata), but given the schema provides offset/limit and the behavior is hinted, it is reasonably 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 description coverage is 60%; query and reasoning lack schema descriptions. The description compensates for 'query' by listing search dimensions (Mandantennummer, Name, Tags, Sachbearbeiter). The other parameters (limit, since, offset) already have schema descriptions. This adds meaningful semantics for the undocumented query parameter.

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

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

The description states a specific verb and resource: 'Sucht Mandanten über Mandantennummer, Name, Tags oder Sachbearbeiter' (searches clients by client number, name, tags, or case handler). It also distinguishes from siblings by noting it names the matching column for each hit, which is a unique behavioral trait not covered by mandant_list or mandant_get.

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

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

The description provides clear next-step guidance: 'Nächster Schritt mit der gefundenen mandantennummer: document_create... mandant_get... letter_create_draft...' This implicitly tells when to use this search tool (to locate a client before using those tools). It does not explicitly state when not to use it, but the context is clear and useful.

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 reveals what the probe checks (token, processing chain, render path) and what it reports (setup prerequisites). Annotations already indicate read-only safety, and the description adds behavioral context without contradicting them.

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

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

The core information is clear and front-loaded, but the German and English versions are duplicated, roughly doubling the length. A single concise bilingual paragraph would be more efficient without losing meaning.

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 health-check tool without an output schema, the description provides adequate context: what is verified, what is reported, and when to call it. It does not describe the exact response format, but that is not required given the tool's simplicity.

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 elaborates on checkRender by explaining it tests rendering for preview/thumbnail, going slightly beyond the schema. However, the 'reasoning' parameter has no description in either the schema or the tool description, leaving its purpose unexplained. Schema coverage is only 50%, so the description should have compensated more.

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 is a health/echo probe that verifies the partner token and the full processing chain end-to-end. It distinguishes itself from sibling tools by focusing on system health and setup readiness rather than sending or document management.

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 advises calling this tool before building a template that will need to be viewed, giving a concrete use case. It does not mention when not to use it or name alternative tools, but the provided context is sufficient.

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

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

Beyond the destructiveHint annotation, the description discloses specific behavioral traits: the amount is credited to the wallet instead of the card, cancellation is rejected if printing has started, and the approvalId path stops a send before dispatch. This adds meaningful context about side effects and limits, with no contradiction to annotations.

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

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

The description is information-dense, covering the two cancellation modes, the wallet credit, and the rejection condition in two sentences. The bilingual repetition adds length but is justified for accessibility; no sentence is purely filler.

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

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

With no output schema, the description explains the key outcomes (wallet credit, rejection if printing, stop before send) but does not specify the return format or behavior when outside the cancellation window. Given the moderate complexity and clear parameter guidance, it is largely complete for an agent to invoke correctly.

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

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

The description adds significant meaning to orderId and approvalId by explaining their distinct use cases and the 10-minute window, going beyond the schema's field descriptions. However, the optional reason and reasoning parameters are not elaborated in the description, and schema coverage is 75%, leaving a small gap for those parameters.

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 cancels a letter and credits the amount to the wallet, naming the specific resource (order/approval) and the effect. It distinguishes two distinct modes (orderId vs approvalId) and differentiates from sibling tools like order_send or order_fix_resubmit by focusing on cancellation with a financial credit.

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?

Explicit guidance is given for when to use each parameter: orderId for an existing order within the cancellation window (with clean rejection if already printing), and approvalId for a chat-approved send within a 10-minute grace window. This provides clear context and exclusion criteria, effectively replacing the need to consult sibling tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description need not re-state safety. It adds useful behavioral details: download URL validity (90 days), inclusion of postmark and provider, and verification from GoBD archive. This exceeds the annotation coverage without contradicting it.

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

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

The description is two sentences (German and English), concise, and front-loaded with the core purpose and key return values. Every phrase adds value, and there is no redundancy or filler.

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

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

For a read-only retrieval tool with no output schema, the description covers the main return values and context. It lacks mention of error scenarios (e.g., order not found or not sent) and any prerequisites beyond 'sent order', but given the simplicity of the operation, it is reasonably 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 description coverage is 0% as the description does not mention orderId or reasoning. While orderId is implied by the context of retrieving a receipt for a specific order, the optional reasoning parameter is entirely unexplained. The description fails to compensate for the low schema coverage, especially for a two-parameter interface.

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 with a specific verb ('Liefert') and resource ('Einlieferungsbeleg'), and details the exact data returned (download URL valid for 90 days, postmark, mail provider, GoBD record). It clearly distinguishes itself from sibling tools like order_status or order_send.

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 specifies that the tool is for 'versendeten Auftrag' (sent orders), implying when it should be used. It does not explicitly exclude alternatives, but the unique resource and return data make the usage context clear. It lacks an explicit 'when not to use' statement but provides adequate context.

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

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

Annotations already mark the tool as destructive and not read-only. The description adds valuable context: it preserves the current price/charge, thereby clarifying financial implications, and specifies the exact error response for invalid status. It does not contradict annotations and enhances understanding of 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 compact and front-loaded, with two sentences per language covering the core action, the status requirement, price implications, and error behavior. Every sentence contributes meaningful information without redundancy or fluff.

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

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

Given the tool's moderate complexity (4 parameters, no output schema), the description provides adequate context: the target state, the error condition, and the financial outcome. It lacks elaboration on reasoning and clientOrderId parameters, but the core behavior and constraints are well 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 description coverage is only 25%, covering just the recipient parameter. The description does not explain the semantics of orderId (requires recipient?), reasoning, or clientOrderId beyond their names. Since coverage is low, the description was expected to compensate but does not, leaving key parameter meanings implicit.

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 tool's function: correcting the recipient address of a letter specifically in status awaiting_partner_fix and releasing it for sending. The verb 'Korrigiert'/'Corrects' and resource 'letter' are specific, and the inclusion of the required status distinguishes it from sibling tools like order_send or order_cancel.

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

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

The description explicitly states when the tool applies: only for letters with status awaiting_partner_fix, and that any other status returns ORDER_NOT_FIXABLE. This provides a clear usage condition and implicit when-not-to-use, though it does not name specific alternative tools such as order_cancel or order_send.

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

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

Annotations already declare destructiveHint=true, but the description adds rich context: it checks six gates, defaults to an approval queue where a human decides via approval_decide, dryRun is a full rehearsal through all six gates and is free, dryRun returned letterId is a probe handle and NOT_FOUND in letter_get/letter_preview, and there are two recovery paths. It also clarifies that the actual send is released only after approval. No contradiction with annotations.

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

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

The description is long but well-structured and front-loaded with the core purpose, then flows into preview guidance, content modes, approval flow, dryRun, and alternatives. Every sentence carries useful information. However, it is doubled by full German and English repetition, which makes it less concise than a single-language version would be. It is structured well enough to stay navigable.

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

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

For a tool with 40 parameters, nested objects, and no output schema, the description is exceptionally complete. It covers the full workflow (preview, content variants, approval queue, dryRun, recovery), explains side effects (approval, wallet reservation indirectly via approvalMode in schema), gives a concrete blocks example, references the full blocks guide, and clearly positions sibling tools. There is no major missing context that would impair an agent's ability to use it correctly.

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

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

Schema coverage is 53%, so baseline is 3. The description adds semantic meaning beyond the schema for key parameters: explains content vs blocks vs letterId (exactly one of the two inline modes), gives a compact blocks example, describes dryRun semantics, and points to the blocks-guide resource. It does not cover all 40 parameters, but it compensates for the most complex/ambiguous ones, lifting it above baseline.

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

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

The description opens with a clear verb and resource: 'Versendet einen Brief physisch per Post' (sends a letter physically by post), and outlines the full process (checks sender, address, AVV, limits, creates PDF, calculates price, releases). It also explicitly differentiates from siblings: letter_create_draft and letter_preview are for viewing rendered pages before sending, shipping_quote is for cost planning, and order_cancel/order_fix_resubmit are recovery paths. This provides strong distinction.

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

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

The description gives explicit when-to-use and when-not-to-use guidance: look at the letter as an image first with letter_create_draft/letter_preview; use letterId or inline content with exactly one of content/blocks; default goes to approval queue then order_status; dryRun is a free rehearsal with a probe letterId that returns NOT_FOUND in letter_get/letter_preview; for a real draft use letter_create_draft; shipping_quote answers cost while content is still planned. It also names recovery tools (order_cancel, order_fix_resubmit), making alternatives explicit.

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

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

The description discloses critical behavior beyond the destructiveHint annotation: per-entry validation and pricing, error continuation, the single-approval submission, full dispatch on approval vs. full refund on rejection, and the free dryRun simulation. This substantially exceeds what annotations communicate, with no contradiction.

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

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

The description is thorough and well-structured, but it is bilingual, repeating the same content in German and English, which doubles the length. It is still appropriately sized for the complexity of the batch behavior and front-loads the main purpose.

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

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

The description covers the end-to-end workflow: per-item processing, approval behavior, error handling with stopOnError, and dryRun semantics, including the refund on rejection. With no output schema, the description sufficiently explains what the agent can expect without needing to enumerate return 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?

Schema description coverage is 100%, so the schema already documents dryRun, presetName, stopOnError, and items. The description mentions dryRun and stopOnError in prose but adds no parameter-specific semantics beyond the schema, meeting the baseline.

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

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

The description opens with 'Versendet mehrere Briefe in einem Stapel' / 'Sends several letters in a batch', giving a specific verb, resource, and scope. It clearly distinguishes this batch tool from the sibling order_send by covering multiple letters and a single-approval workflow.

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 clarifies when to use this tool: to send a batch of letters as one approval with a single approval_decide decision. It explains options like stopOnError and dryRun, but does not explicitly name an alternative for single-letter sending (e.g., order_send), so there is no explicit exclusion.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, but the description adds valuable behavioral context: the conditional tracking number for registered mail only, the inclusion of estimated delivery, and the cancellable flag that influences next steps. No contradiction with annotations.

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

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

The description is bilingual, which doubles its length but serves a practical purpose. Each sentence conveys distinct information: what is returned, the conditional tracking number, and action guidance. It is structured and front-loaded with the core purpose, though a more concise single-language version could be slightly tighter.

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?

Without an output schema, the description lists the key return fields: status, tracking history, tracking number, estimated delivery, and cancellable flag. It also covers the important status-specific behavior and related actions. Missing minor details like possible error cases, but it is sufficiently complete for a read-only status query.

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 for parameter information. However, it does not explain the 'reasoning' parameter at all, and only implicitly references orderId via 'order status'. The description adds minimal value beyond what is obvious from the tool name and 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 'delivers the current status of an order' and lists specific data returned: tracking history, tracking number (registered mail only), estimated delivery, and cancellability. It uses a specific verb and resource, and the mention of related tools (order_fix_resubmit, order_cancel) distinguishes it from siblings.

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

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

The description provides explicit when-to-use vs alternatives: on status awaiting_partner_fix, call order_fix_resubmit; while cancellable is true, order_cancel can still stop the send. This clearly guides the agent on when to use this read-only status tool versus other actions.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description reveals that limits inside the preset are stored as-is and serve only as a note, while enforcement runs on web-set limits. It also notes that the name is unique per partner. This adds meaningful behavioral context, though it does not address overwrite behavior.

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

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

The description is bilingual, repeating the same content in German and English, which doubles length. Despite the repetition, each sentence provides valuable information and the main action is front-loaded. It remains reasonably concise for the information conveyed.

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

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

No output schema is provided, and the description does not explain return values or error behavior. Key behaviors like unique names and limit enforcement are covered, but the 'reasoning' parameter is unexplained, and there is no mention of handling duplicate names. Sufficient for a save tool but with notable gaps.

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

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

Schema description coverage is 67%, covering 'name' and 'preset' but not 'reasoning'. The description adds that the name is unique per partner and that limits within the preset are non-enforced, which deepens understanding beyond the schema. However, the 'reasoning' parameter remains undocumented.

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

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

The description clearly states 'Saves a named preset (configuration bundle) in the partner profile' using a specific verb and resource. It distinguishes from sibling tools like letter_design_list_presets, which target letter design presets, by emphasizing the partner profile scope.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions. However, the partner-profile focus and description of preset behavior provide implied context for use, but no explicit guidance 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?

The description adds important context beyond the annotations (readOnlyHint=true, destructiveHint=false): it explicitly states the prices are 'Beispielpreise' (example prices) for a one-page black-and-white standard letter within Germany, not final quotes. It warns that actual prices depend on additional factors and directs to shipping_quote. This discloses the limitation of the tool's output, which is valuable behavioral 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 front-loaded with the main purpose, followed by usage and caveats. It is bilingual (German and English), which adds length but serves the tool's likely audience. The repetition across languages is not purely redundant; each language conveys the full message. It is concise enough without wasting words, though the double-language format keeps it from being maximally concise.

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

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

For a simple, read-only pricing tiers lookup with no required parameters, the description covers the core purpose, usage triggers, and critical limitations. It even directs to an alternative for real quotes. However, it does not describe the return format or structure of the tier data (e.g., array of objects), and the undocumented 'reasoning' parameter leaves a small gap. Still, it is otherwise complete for the expected use case.

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

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

The schema has one parameter, 'reasoning', with zero schema description coverage. The tool description does not mention this parameter at all, let alone explain what it is for or how to use it. With 0% schema coverage and no compensation in the description, the agent has no guidance on what to pass as 'reasoning'. This is a significant 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 the tool's action: 'Liefert die Staffelpreise (Mengenrabatte) von FrankKi' – delivers volume tiers/bulk discounts. It specifies the exact resource (FrankKi pricing tiers) and what information is provided (monthly quantity to example price per letter). It distinguishes itself from the sibling tool shipping_quote by clarifying that this is for example prices only.

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

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

The description provides explicit usage guidance: 'Nutze das, wenn jemand nach Mengenrabatt, Volumenpreis, Staffelpreis oder Großkundenpreis fragt' – use when asks about bulk/volume/discount pricing. It also names an alternative: 'dafür shipping_quote' – for real per-letter pricing based on page count, color, delivery type, and destination, use shipping_quote. This gives clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds context about the returned contents, which is useful but does not disclose additional behavioral traits like auth requirements, rate limits, data freshness, or how the overview is assembled. It goes slightly beyond annotations but lacks richer behavioral detail.

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

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

The description is a single, information-dense sentence (plus an English translation). It front-loads the main purpose and lists all components efficiently. The bilingual duplication adds some length but is not wasteful; each language serves a potential audience. It could be slightly more concise if only one language were used, but the structure is clean.

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

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

Given there is no output schema, the description does a good job of enumerating the return content (address, signature, letterhead, presets, wallet, pricing). It is complete for an overview tool, though it omits any detail about the 'reasoning' parameter and does not mention potential side effects or prerequisites. The absence of output schema raises the burden, but the description covers the major aspects.

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

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

The schema contains a single optional parameter 'reasoning' with 0% description coverage in both schema and tool description. The description does not mention this parameter at all, failing to compensate for the low schema coverage. The agent is left to infer its purpose from the parameter name alone, which is insufficient for proper invocation.

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

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

The description clearly states the tool's function with a specific verb ('Liefert'/'Returns') and resource ('Partnerprofil'). It enumerates the exact components returned (sender address, signature, letterhead, presets, wallet summary, pricing), which unambiguously distinguishes it from sibling tools like sender_profile_get or wallet_balance that focus on narrower subsets.

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

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

The description clearly implies its usage as a high-level overview tool by listing the aggregated data. However, it does not explicitly state when to prefer this tool over alternatives or provide exclusions (e.g., 'for detailed wallet info use wallet_balance'). The context is clear, but there is no direct when/when-not guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false; the description adds valuable behavioral context by explaining that cancelling releases the reserved amount. This goes beyond the annotation by describing the financial side effect, though it doesn't cover all possible behaviors like irreversibility.

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

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

The description is two concise bilingual sentences, front-loaded with the core functionality and a key side effect. 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?

Given the tool's moderate complexity (dual action, 5 params) and the rich schema/annotations, the description covers the main purpose and the critical cancellation effect. It doesn't explain output format or error conditions, but the schema and annotations fill most gaps. A small gap remains because there's no output schema and no mention of what the list returns, so deduct one point.

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 80% (reasoning param lacks description). The tool description does not add new parameter-level details beyond the schema; the effect of releasing the reserved amount is already present in dryRun's schema description. Therefore baseline 3 applies.

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

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

The description clearly states a specific verb+resource: 'Lists the partner's scheduled sends or cancels a scheduled send.' This distinguishes it from siblings like letter_schedule or order_cancel by focusing on managing existing scheduled sends, including the effect of releasing reserved amounts.

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

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

The description provides clear context for when to use the tool (listing or cancelling scheduled sends) but does not explicitly mention alternatives or when-not-to-use conditions. It lacks a direct comparison to sibling tools, so it earns a 4 rather than a 5.

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

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

Annotations already indicate readOnly and non-destructive. The description adds value by specifying exactly what data is returned (mandatory details, bank account, disclaimer), which is useful behavioral context beyond the annotations. No contradiction.

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

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

The description is two short sentences (one German, one English), front-loaded with the core action and result. Every word earns its place, with no fluff or repetition.

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

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

For a simple read tool with one required param and no output schema, the description covers the key return information. It does not explain error cases (e.g., profile not found), but given the low complexity this is acceptable.

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 for parameter meaning. It does not mention profileId or reasoning at all, leaving the agent to infer from the schema alone. The returned content is described, but not the input parameters.

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 returns a single sender profile with mandatory details, bank account, and disclaimer. It uses a specific verb (returns) and resource (sender profile), and distinguishes from list/upsert siblings by emphasizing 'single'.

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 fetching one specific profile via 'single', but does not explicitly mention when to use it over sender_profile_list or provide exclusions/alternatives. No clear 'use this when' guidance beyond the singular phrasing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is known. The description adds value by revealing that it returns all profiles (no filtering) and specifies the included attributes (legal form, mandatory details completeness). This conveys scope beyond the basic safety profile.

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 duplicates the same content in German and English, making the second sentence redundant. It is not concise; the English translation adds no new information and should be omitted or merged. The front-loaded purpose is good, but the redundancy lowers the score.

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

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

The tool is simple with no required parameters and no output schema. The description covers the main purpose and some output content, but it lacks details on return structure, pagination, or any limits on the 'all' list. This is a minimum viable description but leaves room for clarification.

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 is one optional parameter 'reasoning' with no schema description, and schema description coverage is 0%. The description does not explain this parameter, forcing the agent to infer its purpose. Since the parameter is optional and likely meta, the impact is moderate, but the description still fails to compensate for the missing information.

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 sender profiles of the partner, including their legal form and completeness of mandatory details. This distinguishes it from sibling tools like sender_profile_get (single profile) and sender_profile_upsert (write operation).

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

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

The description implies use when you need a full overview of sender profiles, but it does not explicitly state when not to use it or mention alternatives. No exclusion or comparison to related list tools is provided.

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