John's Essentials

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

Annotations already declare readOnlyHint=true, so the description doesn't need to restate that. It does add the list of analyzed fields and mentions waveform data, which gives some insight into the analysis output. However, it does not disclose any side effects, limitations, or processing nuances beyond the annotation, so the added value is moderate.

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

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

The description is a single sentence with the core action front-loaded. However, the leading 'Audio Analyzer' repeats the title, and the trailing '[category: analyze]' is unnecessary metadata. These redundancies reduce efficiency slightly but the structure remains clear and 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 only one required parameter and no output schema, the description lists the key return fields (duration, sample rate, bit rate, channels, codec, waveform data), which is essential for an agent to know what the tool produces. It falls short of specifying the structure of waveform data or error behavior, but the simplicity of the tool and existing annotations cover most needs.

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

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

The schema description covers 100% of the single parameter, listing supported audio formats. The tool description adds no extra meaning about the parameter itself; it only lists output fields, which is unrelated to parameter semantics. Baseline 3 applies due to high 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 uses a specific verb ('Analyse') and resource ('audio file'), then enumerates concrete output properties (duration, sample rate, bit rate, channels, codec, waveform data). This clearly distinguishes it from sibling tools like analyze_video or analyze_file by naming audio-specific attributes.

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 usage context is implied by the audio-specific list of properties, but the description does not explicitly state when to choose this tool over alternatives (e.g., analyze_video, analyze_metadata) or when not to use it. No exclusion criteria or alternative routing is provided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: no note on processing limits, supported image constraints beyond the schema, or what the extraction produces. It contributes no behavioral context of its own.

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

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

One short, front-loaded sentence with the action stated first. The appended '[category: analyze]' tag is redundant noise but does not bloat the description meaningfully.

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

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

There is no output schema, so the description could usefully say what is returned (palette list, hex values, ordering), but it does not. For a simple two-parameter read-only tool this is adequate but leaves the return shape unspecified.

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

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

Schema coverage is 100%, so both parameters (file and colors, with min/max/default) are fully documented in the schema. The description adds no additional meaning about the colours count or input format, so the baseline 3 applies.

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

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

States a specific verb and resource ('Extract the dominant colour palette from an image'), which is clear and actionable. It does not name or contrast with any sibling (e.g. analyze_image_quality, photo_color_adjuster), so an agent must infer the boundary itself.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance anywhere in the description. The '[category: analyze]' tag only restates the name prefix and provides no selection criteria.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the specific statistics computed, which is useful context, but discloses nothing about return format or the 10,000-row sampling behavior (that lives only in the schema).

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

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

One compact sentence with the verb and the computed outputs front-loaded; nothing is wasted. The trailing '[category: analyze]' tag adds little selection value and is the only slight noise.

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 two-parameter tool with no output schema, enumerating the returned statistics in the description is exactly the right compensation. It is nearly complete, missing only an explicit note that large files are sampled unless 'strict' is set.

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

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

Schema description coverage is 100%, so both 'file' and 'strict' (including the row-cap behavior) are fully documented in the schema. The description adds no parameter detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Analyse a CSV file') and enumerates the concrete outputs it computes (row/column count, data types, null counts, min/max/mean per column), which is unusually informative. It does not, however, differentiate itself from format-sibling tools like analyze_file, so it falls short of a 5.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance. The implicit applicability to CSV files is the only cue, and the '[category: analyze]' tag is metadata rather than routing help.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds value by disclosing the perceptual-hashing mechanism, which implies approximate matching rather than byte-level comparison. It does not disclose result format, similarity threshold, or behavior on mixed file types, but the schema's note about silently ignoring files beyond 20 covers the main edge case.

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

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

A single tight sentence that front-loads the purpose before the method. The 'Duplicate Detector —' prefix slightly redundantly repeats the tool name, but there is no other wasted content, and the key discriminator (perceptual hashing) is included.

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

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

For a one-parameter, read-only analyze tool with a fully documented schema, the definition covers the essential context: what it does, how it does it, and the input constraints. The main gaps — return value shape and near-duplicate threshold — are minor for an analyze-category tool with no output schema and would likely be observable at runtime.

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%: the 'files' parameter already documents the 2-20 range, accepted types, and silent-ignore behavior. The description's 'batch upload' phrasing adds minor framing but no new semantic detail beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb ('Identify'), a specific resource ('duplicate or near-duplicate files in a batch upload'), and the method ('perceptual hashing'). This distinguishes it from siblings like analyze_hash (plain hashing) and analyze_image_similarity (image-specific similarity) — an agent can tell what this tool does without opening the schema.

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

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

The phrase 'in a batch upload' implies the intended scenario (comparing a set of files at once), and the schema's 2-20 file range reinforces this. However, the description gives no explicit when-to-use vs. when-not-to-use guidance and names no alternatives, leaving the agent to infer the boundary against near-siblings like analyze_image_similarity and analyze_hash.

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 the description reinforces this by explicitly stating the tool only reports and does not convert or rewrite the file. It also adds useful behavioral context about what kinds of files and encoding issues it addresses. The description aligns with and slightly extends the annotation-provided 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 is compact and front-loaded, starting with a clear one-line summary followed by a practical use case and an explicit scope limitation. Every sentence earns its place, and the category tag is unobtrusively appended.

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 detector tool, the description covers the trigger scenario, supported encodings, input file types, and the boundary of what it does not do. No output schema exists, but the description's 'reports the encoding only' sufficiently conveys the outcome. Nothing critical is missing.

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

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

The single parameter 'file' is already fully documented in the schema with type, format, and accepted extensions (TXT, HTML, CSV, XML), so schema coverage is 100%. The description adds no new parameter-specific semantics beyond listing example encodings, which is marginal value. Baseline 3 is appropriate.

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

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

The description clearly identifies the specific action 'Detect the character encoding' and the resource 'text or HTML file.' It also distinguishes itself from conversion tools by stating 'It REPORTS the encoding only — it does not convert or rewrite the file,' making its purpose unmistakable among the large sibling set.

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

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

It provides an explicit trigger condition: 'Use when accented letters, apostrophes or quotation marks arrive as garbled symbols.' It also clarifies what it does not do, so an agent knows not to use it for conversion or rewriting. However, it does not name specific alternative tools or state when not to use it beyond the conversion 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 declare readOnlyHint=true, so the tool's safety profile is clear. The description adds useful behavioral context beyond the annotations by specifying the exact output facets the analysis returns (type, encoding, size, MIME type, magic bytes, structure summary). It does not disclose limitations like file size limits, but the low-risk read-only nature makes that 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 one front-loaded sentence that immediately states the action and the return values. The 'File Analyzer —' prefix redundantly repeats the tool name and the '[category: analyze]' tag adds marginal value, but there is no meaningful padding or wasted prose.

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

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

For a simple one-parameter read-only tool with no output schema, the description covers the essential information: what the tool does and what it returns. The lack of explicit guidance about specialized sibling tools is a gap, but the low complexity and full schema coverage keep the definition 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?

The schema has 100% description coverage: the single binary 'file' parameter is documented as 'Input file (any)'. The description adds no extra parameter-level details, so the baseline score of 3 is appropriate since the schema fully handles parameter semantics.

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

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

The description uses a specific verb ('Analyse') and names the resource ('a file') while enumerating concrete outputs: type, encoding, size, MIME type, magic bytes, and structure summary. However, it does not explicitly distinguish itself from specialized sibling analyzers such as analyze_metadata or analyze_encoding_detector, leaving some ambiguity about which tool to choose for a generic file.

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 generic phrasing 'Analyse a file' and the '[category: analyze]' tag imply this is a general-purpose analyzer, but there is no explicit statement about when to use it instead of specialized tools like analyze_audio, analyze_csv, or analyze_pdf_inspector. No alternatives or exclusions are mentioned, so the agent must infer usage context.

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

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

Annotations already carry the read-only safety profile, so the description's burden is lower. It adds the line-by-line comparison behavior and the pair requirement, but does not disclose operational limits such as the 2,000-line cap (which lives only in the strict parameter description). 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?

A single front-loaded sentence states the core purpose and the two valid input modes, ending with the key usage constraint 'Provide one complete pair.' No filler; the [category: analyze] tag is minor but does not hurt.

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

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

For a two-mode tool with rich per-parameter descriptions and a read-only annotation, the description plus schema fully covers how to invoke the tool correctly. The only gap is that no output format is described, but the line-by-line diff behavior makes the expected result self-explanatory.

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 every parameter thoroughly. The description adds useful grouping by naming which parameters belong to file mode vs text mode, but this repeats information already encoded in the parameter descriptions and x-require-one-of. 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?

Description states a specific action ('Show a line-by-line diff') and the exact resources involved ('two text files' or 'two pasted texts'). It also names the relevant parameter pairs, making it clear this is a text-diff tool rather than the image-diff sibling photo_image_diff.

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?

Description gives clear usage context: provide one complete pair, either file_a+file_b or text_a+text_b. It does not explicitly name alternatives or exclusions, but the two-mode instruction is enough to guide most calls and is reinforced by the schema's x-require-one-of.

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 readOnlyHint annotation already communicates that this is a non-mutating operation. The description adds useful behavioral context by limiting inputs to PDF/DOCX and excluding images, but it does not disclose additional behaviors such as output format, behavior on unsupported files, or font-detection limitations.

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

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

The description is a single compact, front-loaded sentence. It leads with the tool's role, follows with accepted formats, and ends with the key exclusion. No unnecessary filler or repetition of schema 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?

For a simple one-parameter, read-only tool with no output schema, the description adequately covers the core scenario: input file types and an important unsupported case. It does not detail return structure, but the tool name and action make the expected output reasonably clear.

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

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

The schema already documents the single 'file' parameter as PDF/DOCX input, so the description is not the only source. However, it adds meaningful semantic value by explicitly stating that images are unsupported, which clarifies the accepted input domain 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 ('Detect fonts') and the resource scope ('PDF or DOCX document'), with an explicit exclusion of images. This makes it unmistakable what the tool does and distinguishes it from the many sibling analyze_* 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 when-to-use context: any PDF or DOCX where font detection is needed. It also gives a when-not-to-use signal by explicitly stating that images are not supported, though it does not name a specific alternative 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?

Annotations already mark the tool read-only, so the description adds value by disclosing the hybrid engine, rule citations, style-guide awareness, dialect enforcement, and per-issue severity. This gives an agent useful behavioral expectations beyond the annotation flags, though it does not specify output structure.

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 dense sentence that front-loads the tool's identity and then lists distinguishing capabilities. The category tag at the end is redundant but not harmful. It compresses a lot of information without excessive wordiness.

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 five parameters, full schema documentation, and no output schema, the description provides a solid behavioral overview including citations, severity, style, and dialect. It does not describe the exact return shape, but the feature list sufficiently orients an agent to what the tool produces.

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 input schema already documents text, mode, style, dialect, and include_llm thoroughly. The description's style and dialect mentions mirror schema enums rather than adding new parameter-level meaning; the only slight extra is the Grok reference hinting at the LLM pass.

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 as a grammar checker with a hybrid LanguageTool + Grok engine and lists concrete capabilities (style guides, dialect enforcement, per-issue severity). This is sufficient to distinguish it from sibling analyze_* tools, though it relies on the title phrase rather than an explicit verb phrase like 'check grammar in text.'

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

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

Usage context is implied by the name and category: use this tool when the user wants grammar checking with style and dialect support. However, the description does not state when to prefer it over alternatives or what it is not for, and no sibling alternative is named.

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 declare readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds that four specific hash algorithms are computed, implying the output contains all four, but it does not disclose any other behavioral traits such as output format, size limits, or the file-over-text precedence present in the schema.

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

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

The description is a single tightly-packed sentence that states the action and algorithm list, followed by a category tag. No filler, no repetition of schema details, and the core information is front-loaded.

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

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

The description covers only the file input, leaving the text-hashing capability and the one-of requirement undocumented in the prose. With no output schema, the return shape is left to inference, and the presence of sibling generate_hash creates selection ambiguity that the description fails to resolve.

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

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

Schema description coverage is 100%, with both 'file' and 'text' fully explained including the precedence rule. The main description adds no parameter-level meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description clearly states a specific action and resource: 'Compute MD5, SHA-1, SHA-256, and SHA-512 hashes of an uploaded file.' It enumerates the exact algorithms, which is helpful. However, it omits the text-hashing mode exposed in the input schema and does not differentiate itself from the sibling generate_hash tool.

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 generate_hash or other analyze_* tools. The only context is the '[category: analyze]' tag, which is implicit. There are no exclusions, prerequisites, or alternative recommendations.

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 the description adds behavioral detail by enumerating exactly what the tool computes. It does not discuss output format or file size limits, but for a read-only analyzer these gaps are minor.

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 efficient sentence with the core operation front-loaded and no filler. The leading 'Image Quality Analyzer' phrase slightly duplicates the tool title/annotation, keeping it from a perfect 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?

For a one-parameter, read-only analysis tool, the description sufficiently explains what the tool does and what metrics it returns. It omits the exact return format, but the listed metrics are 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?

Schema description coverage is 100%: the only parameter, 'file', is already documented with accepted formats. The description's phrase 'of an image' adds little semantic value beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb, 'Measure', and names four concrete outputs: sharpness, noise level, compression artefacts, and BRISQUE quality score. This clearly distinguishes it from sibling tools like analyze_image_similarity or analyze_metadata.

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

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

The description provides clear context: use this tool when you need objective image quality metrics. It does not explicitly mention alternatives or when-not-to-use conditions, so it stops just short of full routing 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 cover read-only safety (readOnlyHint=true), and the description adds the algorithmic context that 'similarity' means pHash distance, which is genuinely useful. It also clarifies that file_a and file_b must be separately-named uploads, a non-obvious calling trait. However, it does not disclose the output score's range, direction, or thresholds, leaving result interpretation ambiguous.

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

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

A single front-loaded sentence that leads with the core purpose, then the calling detail, then a category tag — no filler. The only redundancy is restating the exact title 'Image Similarity' at the start, which is a minor deduction.

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 low-complexity, read-only tool with fully documented parameters, inputs and core behavior are adequately covered. The notable gap is the absence of an output schema combined with no description of the score's format or interpretation, which an agent needs to judge how to use the result. Adequate but not fully 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 100%, both binary params are documented with accepted formats (JPG, PNG), so the baseline of 3 applies. The description adds only the minor clarification that the two uploads must be separately named, which is a small enhancement over the schema.

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

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

States a specific verb ('Compute') and resource ('perceptual similarity score between two images'), and pins down the method (pHash distance). The pHash detail implicitly differentiates it from siblings like photo_image_diff (pixel diff) and analyze_image_quality, so an agent can tell them apart without opening any schema.

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

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

No guidance on when to choose this tool over its many related siblings (photo_image_diff, analyze_image_quality, describe_image, etc.). There are no conditions, exclusions, or alternative tool names. The only operational hint — that inputs are two separately-named uploads — concerns calling convention, not tool selection.

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 key behaviors beyond annotations: it returns valid true/false, a non-valid document is not a failed step, and the step passes no file onward. These are concrete operational details not covered by readOnlyHint=false or destructiveHint=false, and there is no annotation 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 purpose is front-loaded and every sentence carries operational value. The If/Else recipe is somewhat long but directly relevant to correct use; it could be tightened slightly but contains 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 3-parameter tool with full schema coverage and no output schema, the description explains result semantics, workflow continuation, stop conditions, and the file-passing limitation. An agent has enough 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?

Schema description coverage is 100%, so the file/text/format parameters are already fully documented. The description adds workflow context like 'passes no file on', but it does not add parameter-level semantics beyond what the schema provides.

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

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

The description opens with 'JSON/XML Validator — Check that text is valid JSON or XML and tidy its layout', which states a specific verb, resource, and outcome. It clearly distinguishes this validation/formatting tool from other analyze_* 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 gives strong workflow guidance: invalid input is still an answer, and it explains exactly how to use an If/Else step with {{step_N.valid}} to stop a workflow. It does not name alternative tools or explicit when-not cases, but the tool's purpose is sufficiently unique among siblings.

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

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

With readOnlyHint=true, the safety profile is already known, while the description adds behavioral context: PDF/HTML are parsed for hyperlinks and other file types are scanned as raw text. This goes beyond the annotations 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 description is two tight phrases plus a category tag, with the main behavior front-loaded and no filler. Every sentence contributes to understanding inputs and 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?

For a simple two-parameter, read-only extractor this is nearly complete: it explains input types, text/file precedence in the schema, and fallback scanning. It doesn't describe the exact return shape, but 'extract all hyperlinks' sufficiently implies a list of links.

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

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

Schema description coverage is 100% and the parameters are named and documented well, including the file-wins precedence. The description mostly restates what the schema already says, so it doesn't add significant parameter-level 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 opens with 'Extract all hyperlinks from a PDF or HTML file, or from pasted text,' giving a specific verb, resource, and accepted source types. It also distinguishes itself from the long analyze_* sibling list by specifying files/text rather than general analysis.

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 clearly indicates the tool is for link extraction from PDF/HTML/text and notes the fallback behavior for other file types. It doesn't explicitly name alternative tools or exclusion conditions, so it stops short of 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?

The readOnlyHint annotation already establishes that this is a safe, read-only operation. The description adds useful scope by enumerating metadata types, but it does not disclose output format, potential limitations of 'all metadata', or how results are returned, leaving a moderate behavioral gap.

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

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

The description is a single, front-loaded sentence with useful examples and no fluff. The 'Metadata Viewer —' prefix is slightly redundant with the annotation title, and the '[category: analyze]' tag adds minimal value, which keeps it from a perfect 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?

For a low-complexity tool with one required parameter, a readOnlyHint annotation, and a simple 'display all metadata' output concept, the description is mostly sufficient. The lack of an output schema and any mention of output format or supported file limitations is a minor gap, but not enough to make the tool hard to invoke.

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

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

Schema coverage is 100%: the only parameter, 'file', is already described as 'Input file (any)'. The description adds the context that the file's metadata will be extracted, but it does not add format, size, or encoding semantics beyond what the schema already provides.

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

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

The description states a clear action ('Extract and display') on a well-defined resource ('all metadata from a file') and gives concrete metadata categories (EXIF, PDF info, document properties, audio tags). It does not explicitly distinguish itself from siblings like photo_exif_viewer or pdf_get_metadata, so it stops short of full sibling differentiation.

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

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

The description implies usage: use this when you need general metadata from a file. However, it provides no explicit guidance about when to choose this instead of the more specialized metadata-related siblings, nor does it mention any exclusions or prerequisites.

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

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

The description is consistent with readOnlyHint:true and openWorldHint:false, and 'inspection' signals no mutation. It adds the scope of what is read but does not disclose potential limits like file-size restrictions, authentication needs, or response format. Because annotations already cover the read-only safety profile, the description meets the baseline but adds limited extra 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 a single, front-loaded sentence with the tool's role followed by an enumerative list of inspection targets and a category tag. It contains no filler, though the phrase 'PDF Inspector' slightly duplicates the title annotation.

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

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

For a single-input, read-only inspection tool, the description is largely sufficient: it names the input type, the operation, and the main output categories. However, since there is no output schema and several overlapping PDF-analysis siblings exist, a brief note on where this tool fits among them would make it fully self-sufficient.

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, file, is fully documented in the schema as 'Input file (PDF)' with binary format. The description repeats the PDF context but contributes no additional constraints or format details. With 100% schema description coverage, a baseline score of 3 is appropriate.

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

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

The description identifies a specific function—deep inspection of a PDF—and enumerates concrete deliverables (page count, fonts, annotations, form fields, embedded files). It clearly places the tool in the analysis category, though it does not explicitly distinguish it from overlapping PDF-analysis siblings like pdf_file_info or pdf_page_count.

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 [category: analyze] tag and the 'deep inspection' phrasing imply the tool is for broad read-only analysis of a PDF. However, the description provides no explicit guidance on when to use this tool instead of alternatives such as pdf_page_count, pdf_file_info, or analyze_metadata, and gives no when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the agent knows this is a safe, deterministic read operation. The description adds the specific metrics computed and the input constraints (five words minimum, 25MB max), which is useful context beyond the annotations. It does not describe output format or edge cases, but the annotations carry the 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 is a single, front-loaded sentence that names the tool, the metrics, and the input type. The '[category: analyze]' tag is a minor addition but does not hurt. Every word earns its place.

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

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

For a simple read-only scoring tool with a complete schema and safety annotations, the description is nearly complete. It could mention the output format (e.g., scores returned), but the absence is minor given the tool's simplicity and 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?

Schema description coverage is 100%, so the schema already documents both parameters well. The description adds the 'five words minimum' constraint and the 25MB limit, which are not in the schema, but it does not need to add much more because the schema is complete.

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 ('Calculate') and resource ('Flesch Reading Ease and Flesch-Kincaid Grade Level for a text'), which clearly distinguishes it from the many sibling analyze_* tools. The title 'Readability Scorer' reinforces the purpose without being a tautology.

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

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

The description implies when to use it: when a readability score is needed, and the schema clarifies the two input modes (paste text or upload a document). It does not explicitly name alternatives or exclusions, but among the analyze_* siblings, none overlap with readability scoring, so the context is clear enough.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe, outbound read. The description adds the returned fields but says nothing about behavior beyond that — no timeouts, no rate limits, and crucially no statement of what happens on an expired, self-signed, or unresolvable certificate.

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

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

One tight, front-loaded sentence that leads with the verb and resource and ends with the payload fields. The bracketed '[category: analyze]' tag is metadata noise that adds no agent-facing value.

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

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

With no output schema, the description responsibly enumerates the return fields, and the single required parameter is fully documented. What's missing is failure-mode behavior, which matters for a network-dependent check against hosts that may not be reachable.

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

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

Schema description coverage is 100% and the hostname field is documented in detail (no scheme, no path, port ignored, 443 forced). The description contributes nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Check) and resource (SSL certificate) and enumerates what it reports: expiry, issuer, validity, cipher suite. No sibling in the analyze_* family touches TLS/SSL, so the tool is unambiguous against its peers.

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

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

Usage is readily inferable from the description (check the certificate of a host), but there is no explicit when-to-use or when-not, no note on prerequisites (network reachability, DNS resolution), and no mention of an alternative for related checks. Adequate but with clear gaps.

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 declare readOnlyHint=true, so the safe, read-only nature is covered. The description adds minor context by listing what is inspected, which hints at output scope, but it does not disclose limitations such as file size constraints, runtime, or what happens with unsupported codecs. Given the annotation coverage, a 3 is appropriate.

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, efficient sentence followed by a category tag. It is front-loaded with the purpose and the properties list is compact. It slightly duplicates the annotation title ('Video Inspector'), but there is no fluff or excessive verbiage.

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

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

For a single-parameter, read-only inspection tool, the description covers the essential information: what it inspects (the file) and what it reports. With no output schema, the property list is helpful. However, it does not explicitly describe the return structure or format, which would make it fully 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 schema describes the file parameter with format: 'binary' and enumerates supported formats, so schema coverage is 100%. The description does not add meaning beyond that; the parameter is self-explanatory. Baseline 3 is correct because the schema does the heavy lifting.

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

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

The description uses a specific verb ('Inspect'), a clear resource ('a video'), and enumerates exact data points (duration, resolution, frame rate, codec, audio tracks, bitrate). This makes it easy for an agent to distinguish it from broad siblings like analyze_file or analyze_metadata, and from analyze_audio, without opening schemas.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The category tag and the video-specific properties imply usage for video inspection, but there are no exclusions or pointer to siblings like analyze_audio or analyze_metadata. The agent must infer the appropriate use case from the tool name and sibling 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 openWorldHint=false. The description adds supported file types and the list of computed metrics, which is useful. It does not disclose output format or how reading time is estimated, but for a simple read-only analyzer this is a minor gap.

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

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

A single efficient sentence that front-loads the tool's purpose and output metrics, followed by supported input types. No wasted words; the category tag is minor and does not detract.

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 low-complexity, read-only analysis tool with fully documented parameters, the description covers inputs, outputs, and file restrictions. It would benefit from a brief note on the response shape, but the tool's behavior is otherwise sufficiently clear.

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

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

Schema description coverage is 100%, with both 'text' and 'file' parameters fully described. The description reinforces the input options ('text or uploaded document') but adds no meaning beyond the parameter descriptions already in the schema.

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

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

The description names a specific verb ('Count') and a clear resource: words, characters, sentences, paragraphs, and reading time. It also specifies input modes (text or uploaded .txt/.pdf/.docx), making it easy to distinguish from siblings like analyze_word_frequency or analyze_readability.

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: this tool is for counting text metrics from pasted text or uploaded documents. It does not explicitly exclude alternatives or state when not to use it, but the intended use case is unambiguous from the description alone.

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

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

The readOnlyHint annotation already signals that this is a safe read operation, and the description's 'Analyse' is consistent with that. However, the description adds no extra behavioral context, such as what happens with large files, performance characteristics, or any side effects. It does not contradict annotations, but it also does not enrich 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 description is a single, focused sentence that front-loads the purpose and includes a category tag. It contains no filler or redundant phrasing, making it highly concise while still conveying the essential function.

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 the description fails to describe what the tool returns (e.g., a list, JSON, or other format). It also omits any mention of edge cases or how the mutually exclusive file/text parameters are handled beyond what the schema implies. For an agent to call this tool confidently, it would need to know the output structure, which is absent.

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

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

Schema description coverage is 100%, with each parameter (file, text, topN, exclude) already explained in the schema. The tool description itself does not mention any parameters or add semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Analyse' and the resource 'word frequency distribution in a text or document file', making the purpose unambiguous. It does not explicitly differentiate from the sibling tool analyze_word_count, but the name and phrasing are specific enough that an agent can infer the core function.

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 analyze_word_count or other analyze_* tools. It neither mentions exclusions nor suggests conditions for choosing this tool. The schema's x-require-one-of constraint is structural, not usage guidance.

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

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

Annotations only declare the safety profile (readOnly=false, destructive=false, openWorld=false). The description adds real value beyond them by disclosing that inputs are detected via filename extension OR file signature, which is a non-obvious behavioral trait (misnamed uploads still work). It does not clarify that output is a newly produced file, leaving one small gap.

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

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

Front-loaded with the purpose, then terse Input/Output format lists, with no filler. The trailing [category: convert] tag is brief metadata that does not bloat the definition.

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

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

With no output schema, the description carries the burden of describing results; it thoroughly covers accepted and produced formats but never states what is actually returned (e.g., a converted file/download). That single gap keeps it from being fully complete for a conversion tool.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the 'to' enum values and the 200MB limit. The description's format lists largely restate the enum and accepted input types, adding little beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb+resource ('Convert between archive formats') and enumerates concrete input and output formats, so the scope is unambiguous. It does not name or differentiate from adjacent siblings such as files_zip, files_unzip, or convert_file, which keeps it at 4 rather than 5.

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

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

The input/output format lists imply the usage context (you have one listed format, want another), but there is no explicit when-to-use guidance, no exclusions, and no pointer to alternatives like files_zip/files_unzip. Usage must be inferred from the format coverage.

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

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

Annotations only declare the safety profile (readOnly=false, destructive=false, openWorld=false). The description adds real behavioral context beyond that: output is a ZIP download, tier-based file caps (5 free / 50 business), and the auto-target mapping rules. It does not cover failure handling, though the schema's per-row skip behavior is disclosed on the files param.

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

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

Front-loaded with the core action and return value in the first clause, followed by target modes and tier limits in a logical order. It is appropriately sized, with only the trailing '[category: convert]' tag adding noise.

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 carries the burden of explaining the return (a ZIP) and does so, plus the auto-target behavior and tier caps. The only gap is the under-explained 'per-extension override map' whose accepted format is left vague.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema by explaining the auto-target mapping (docx→pdf, heic→jpg, mov→mp4) and a 'per-extension override map' mode not reflected in the string-typed target field. That extra mode is mentioned without format detail, which weakens the addition slightly.

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+resource ('Convert many files in one request') and the outcome ('download a ZIP of the results'), which clearly distinguishes it from the many single-file convert_* siblings and from the pdf_*_batch tools. An agent can tell it is the multi-file, mixed-format converter without opening the schema.

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

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

It gives clear in-tool routing ('many files in one request', auto vs global target vs per-extension override) so the agent knows which mode to pick, and the tier limits imply when it is inappropriate (over 5 files on free tier). It does not explicitly name a sibling alternative for single-file conversions, so no exclusion 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 indicate the operation is not read-only and not destructive, so the description adds little behavioral context beyond that. It does not state what happens to the input, how the output is returned, or any side effects. The format list is more about scope/parameters than 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 a single, readable sentence that front-loads the tool's purpose and supported conversions. It contains minor redundancy ('vcf to excel' repeats vCard→XLSX, and 'Contact Converter —' echoes the title), but it is still compact and scannable.

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

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

The schema fully covers the parameters, and the description clarifies the conversion domain, making the tool invocable. However, there is no output schema and the description does not explain what the tool returns or how the converted file is delivered, which is a notable gap for a conversion tool.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds minimal parameter detail. The description repeats valid format pairs that are already documented in the 'to' parameter description, so it does not meaningfully enhance 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 identifies the tool's specific verb ('Convert') and resource ('contact/calendar/email formats'), listing exact format pairs. This distinguishes it from the many generic convert_* siblings like convert_file and convert_document.

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

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

The description gives clear context on when to use the tool by enumerating supported conversions (vCard↔CSV, vCard→XLSX, ICS→JSON/CSV, MSG→EML, EML→PDF). It does not explicitly name alternatives or exclusions, but the domain is specific enough for an agent to route appropriately.

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 essentially blank (false hints), so the description carries the burden. It discloses that the result is a downloadable file, that it chains in workflows, and that inline text is accepted via an 'input' string. Notably, this 'input' string is not present in the schema, which is confusing but still adds behavioral information rather than hiding 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?

Three sentences, front-loaded with the core purpose, followed by usage and an input alternative. There is little waste; the trailing '[category: convert]' is minor metadata that could be dropped, and 'Data Converter' repeats the tool name.

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 3-parameter, no-output-schema tool, the description covers the essential inputs, target selection, and the downloadable-result behavior. The main gap is the undocumented inline-text path: it is referenced but not reconciled with the required 'file' parameter, which could leave an agent unsure how to satisfy the schema.

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

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

Schema description coverage is 100%, and the schema already explains 'to', 'from', and 'file' thoroughly, including format inference and alias definitions. The description adds no per-parameter semantics beyond the schema; in fact it introduces an undocumented 'input' parameter without detailing its structure.

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 begins with a specific verb and resource: 'Convert a data file between formats' and enumerates the exact supported formats (JSON, NDJSON/JSONL, CSV, TSV, XML, YAML, TOML, INI). This clearly differentiates it from the many sibling convert_* tools, which target documents, archives, video, or other media.

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

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

Gives clear operational context: upload a data file, pick a target format, and receive a downloadable result that chains in workflows. It also mentions the inline-text alternative. However, it does not explicitly exclude alternatives like convert_file or data_to_file or state 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?

Annotations declare readOnlyHint=false, destructiveHint=false, openWorldHint=false. The description adds real behavioral context beyond them: the LibreOffice-vs-pandoc routing, the same-category restriction, and the PDF-extracts-to-text-only limitation. It stops short of describing side effects of file creation/output location, which keeps it below a 5.

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

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

Front-loads the primary conversion matrix and constraints before the alternative-tool routing. It is dense and slightly repetitive (the long format list and the 'Pass from' instruction partially restate the schema), but no sentence is wasted.

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

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

For a 3-param, mutation-flagged conversion tool with no output schema, the description covers inputs, conversion limits, engine routing, and alternative tools comprehensively. It does not describe the returned artifact's form, but that is a minor gap given the thoroughness elsewhere.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining converter routing per source ('from' selects the conversion engine; md and ipynb always take their own route) and re-emphasizing the 'Pass from' requirement, though much of the format list duplicates the enum values.

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

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

States a specific verb+resource (document conversion) and enumerates the supported format families and conversion matrices. It explicitly distinguishes itself from sibling tools (convert_file, convert_data) and enumerates the route taken per source (LibreOffice vs pandoc). An agent can tell exactly what this tool does without opening the schema.

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

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

Names alternatives conditionally: 'For images/audio/video use convert_file; for data-text transforms use convert_data', and routes PDF-to-editable output to pdf_to_word / pdf_to_excel / pdf_to_text / pdf_to_images. It also states the exclusion envelope (same-category office only, plus any→pdf; cross-category unsupported), so when-not-to-use is 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 declare the safety profile (non-readOnly, non-destructive, closed-world), so the description's added value is the operational caveats: DRM-protected books always fail, byte sniffing must match 'from' or the call 400s, and pdf→epub reflow quality varies with layout. These are real behavioral traits beyond the annotations, though return format/pagination are not addressed (not applicable without an output schema).

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

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

A single dense, front-loaded paragraph that leads with the action and conversion directions before caveats. Efficient overall, though the bracketed category tag and some format-list redundancy slightly dilute it.

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

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

With 3/3 required params, 100% schema coverage, and no output schema to explain, the description covers everything an agent needs: supported directions, the recommended target, failure modes (DRM, sniff mismatch), and the sibling route for the uncovered direction.

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 parameters are already fully documented; the description largely restates the schema's own guidance (EPUB recommended, older-device fallback). It adds only marginal new meaning, so the baseline of 3 is appropriate.

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

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

States a specific verb (Convert) and resource (ebooks) and enumerates supported directions (mobi/azw3/fb2/lit/pdf → EPUB, epub → mobi/azw3). It also explicitly distinguishes itself from convert_document, which handles epub→pdf, so an agent can route correctly without opening both schemas.

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

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

Gives clear when-to-use guidance (→epub is the recommended direction because modern Kindles accept it), when to pick alternatives (mobi/azw3 only for older devices), and an explicit hand-off to a sibling for the one direction this tool does not cover. Also states an exclusion (DRM-protected books cannot be converted).

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 default false hints (readOnlyHint=false, destructiveHint=false), so the description carries the disclosure burden and adds real behavioral context: source-format auto-detection, alac delivered as .m4a, GIF frame-rate gracefully easing down when width+fps is too heavy, and a 'Business gate' caveat on some video edges. What is missing is the output/return contract (no output schema) and which edges are exactly gated, but the disclosures present are genuine and non-tautological.

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?

Long, but every clause contributes a distinct capability list, a routing rule, or a behavioral caveat — there is no filler. The purpose statement is front-loaded in the first sentence, media-type sections are cleanly grouped, and the trailing [category: convert] tag is lightweight metadata.

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?

High-complexity tool with 5 parameters, two large enums, and no output schema; the description covers the main decision surface exhaustively — what source formats are readable, what targets exist, and which conversions belong to other tools. Remaining gaps are the unspecified shape of a successful conversion result and the vague 'Business gate on some edges' — the exact gated edges are never listed.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns the 4 by adding directional semantics the bare enums cannot express: heic/svg/psd are input-only, alac is delivered wrapped in .m4a, legacy flv/wmv/3gp/mpg/vob/ts/m2ts convert only to mp4, and audio extraction pairs mp4/mov/mkv/webm/avi sources to mp3/wav/aac/m4a/ogg/flac/opus/aiff/alac targets. The gif_fps/gif_width degradation behavior in the description reinforces the schema's own limits note, adding a small incremental layer.

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?

Leads with a specific verb+resource ('Convert a file between formats') and then pins down scope with an exhaustive matrix: image↔image, audio↔audio, video↔video/GIF, audio extraction, subtitles, DOC/DOCX/TXT→PDF, image→PDF, and CBZ→PDF. It explicitly differentiates from siblings by stating that office/document, archive, and data conversions 'live in convert_document / convert_archive / convert_data.' The only weakness is unaddressed overlap with convert_video or photo_format_converter, but the matrix already answers those cases.

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 explicit when-not guidance and named alternatives for the most ambiguous categories: document/office conversions route to convert_document, archives to convert_archive, and data formats to convert_data, plus a 'Business gate on some edges' warning that signals limited availability on some video paths. However, it gives no when-to-use guidance for overlapping siblings like convert_video, media_extract_audio, or photo_format_converter, and the gated edges are never enumerated.

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

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

Beyond annotations, the description discloses the lossy-conversion policy: anything that cannot survive is reported in the X-Conversion-Notes header rather than dropped silently, and strict=true switches to refusal. It also promises preservation of track segments, timestamps, elevations, and polygon holes, giving the agent a clear behavioral model. This does not contradict the annotations.

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

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

The description is compact, front-loaded with purpose, then fidelity guarantees, then failure behavior and the strict option. Each clause earns its place, and the [category: convert] tag adds useful discoverability without clutter.

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

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

For a conversion tool with full parameter schema coverage, the description covers the supported formats, what is preserved, how loss is communicated, and how to make loss fatal via strict. Agents have enough context to select and invoke the tool correctly; an output schema is not needed because the output type is obviously a converted file.

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

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

Schema description coverage is 100%, and the schema already documents file, to, from, and strict with enums, defaults, and conditional rules. The description adds valuable domain context but no new parameter-level semantics, so the baseline 3 is appropriate.

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

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

The description names a specific verb ('Convert') and a precise resource domain ('between GPX, KML, KMZ and GeoJSON'), immediately distinguishing it from generic siblings like convert_file or convert_document. The opening 'GPS & Map Converter' plus the explicit format list leaves no ambiguity about 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?

It clearly establishes the intended context: GPS-track and mapping formats used by Garmin, Strava, Google Earth, and GIS tools. It also explains when data survives conversion and when strict mode is appropriate. However, it never explicitly names alternative tools or states when not to use this tool, so it stops short of full 5-level 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?

The annotations already signal that this is not read-only and not destructive; the description adds that the tool takes one or more images and produces a PDF, which is useful. However, it does not disclose output format details, whether the images are merged in order, side effects, or any limits, so the behavioral context is minimal beyond the basic operation.

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

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

The description is short and front-loaded, with the core action stated immediately. The leading 'JPG to PDF' and the '[category: convert]' tag are somewhat redundant given the tool name and sibling context, but the overall structure is still efficient and scannable.

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

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

For a simple one-parameter conversion tool, the description covers the input and output at a high level. However, there is no output schema and no guidance about how the resulting PDF is returned or how this differs from pdf_images_to_pdf, leaving some ambiguity in a large sibling toolset.

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 the only parameter as 'Input files (JPG, PNG)' with 100% coverage, so the schema carries the parameter meaning. The description adds the phrase 'one or more,' but this is already implied by the array type, so it provides little additional semantic value.

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

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

The description clearly states a specific verb ('Convert') and resource ('one or more JPG/PNG images to a PDF document'), so an agent can understand the core function. However, it does not distinguish itself from the closely related sibling pdf_images_to_pdf, and the leading 'JPG to PDF' essentially restates the tool name.

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

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

The description implies the tool should be used when JPG/PNG images need to be converted to a PDF, and it mentions the acceptable input formats. It does not explicitly say when to prefer this tool over alternatives like pdf_images_to_pdf, convert_file, or convert_batch, so the usage guidance is mostly implicit.

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 annotations by explaining type preservation: numbers stay numeric, blank cells become actual nulls, and identifier strings keep leading zeros. It also discloses a limitation up front, flat schemas only, and states that nested/repeated columns are reported rather than silently flattened rather than claiming unsupported 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 core conversion behavior is front-loaded in the first sentence, and the additional behavioral caveats are compact and purposeful. Minor redundancy exists in the leading 'Parquet Converter' phrase and the trailing '[category: convert]' tag, which add little beyond the tool name and sibling context.

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

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

For a four-parameter file conversion tool with no output schema, the description covers the main operation, supported formats, type-preservation semantics, and schema limitations. It lacks an explicit statement about the output artifact or return shape, but the parameter and schema details cover most invocation needs.

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

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

Schema description coverage is 100%, so the schema already documents every parameter, which establishes a baseline of 3. The description adds meaningful context about type fidelity, but it does not explain specific parameter behavior, formats, or aliases beyond what the schema provides.

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

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

The description states a specific verb and resource: convert Apache Parquet to CSV, TSV, JSON, NDJSON, or Excel, and back. It also adds a differentiating constraint by implying Parquet must always be one side of the conversion, which separates this from generic table-to-table converters like convert_data.

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

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

The description plus schema guidance makes the intended usage clear: Parquet is always one side of the pair. The to-parameter schema explicitly routes table-to-table conversions away to convert_data, and the from-parameter guidance explains when declaring the source format is recommended.

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

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

Although annotations only provide readOnlyHint=false and destructiveHint=false, the description adds significant behavioral context: it details how output adapts per format (CSV zipped when multiple tables, JSON keyed by table, Excel one workbook per sheet) and discloses the strict parameter's partial-export behavior, including what happens on very large databases. This goes beyond the sparse annotations and helps set expectations.

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

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

The description is dense but every sentence earns its place: purpose first, then output adaptation rules, then the optional table parameter, and a category tag. It is front-loaded with the core intent and avoids redundant filler. Despite being slightly long, it packs useful information without confusion.

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 carries the burden of explaining what the caller gets. It explains the output shapes for all three formats and the optional table-scoping and strict partial-export behavior. It does not specify the exact return container type (e.g., whether JSON is a single file or string), but given the parameter richness and schema coverage, the definition is sufficiently complete for an agent to call 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 description coverage is 100%, so the baseline is 3. The description largely mirrors what the schema already says about 'to' (multi-table output shape), 'table' (optional single-table export), and 'strict' (refuse partial answers). It does not add new parameter meaning beyond an organizational overview, so 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 opens with a precise verb and resource: 'Export a SQLite database (.db/.sqlite) to CSV, JSON or Excel.' This clearly states what the tool does and the resource it operates on. The specificity to SQLite inherently distinguishes it from generic siblings like convert_file and convert_data, so an agent can select it correctly without reading schemas.

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 on when to use the tool: when a SQLite database needs conversion to CSV, JSON, or Excel. It also explains the multi-table behavior and the optional 'table' parameter for exporting a single table, which guides usage. It does not explicitly name alternatives or exclusions, but the input resource is specific enough to make usage obvious.

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 behavioral notes beyond the annotations: it warns that the 'to' field must not be set to 'plain text' for Base64/URL operations (which would return input unchanged), and it explicitly states there is no 'conversion_type' field. These details help agents avoid common mistakes. The annotations are minimal (readOnlyHint=false, destructiveHint=false) and the description supplements them 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 a single, information-dense sentence followed by a parenthetical note. It front-loads the core purpose and immediately states the required parameters, then adds a caveat. Every sentence contributes meaning without redundancy, making it 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 tool has no output schema, so the description must convey return expectations, and it does so implicitly (converted text) but does not specify the response format or error handling. However, for a straightforward converter, the key behavioral quirks are covered. The description is adequate for an agent to call the tool correctly, though it could mention output format or failure modes.

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

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

Schema coverage is 100%, so parameters are documented, but the description adds value by clarifying the 'from' and 'to' fields' special behavior for Base64/URL encoding, and by correcting a potential misconception about a 'conversion_type' field. This goes beyond the schema's own descriptions, which are already detailed, so the description earns a slight bonus over the baseline 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 explicitly states it converts text/data formats and lists the specific conversions (Markdown↔HTML, CSV↔JSON, JSON↔XML/YAML, Base64/URL encode-decode). The verb 'convert' plus the resource 'text/data' and the format list make the purpose unambiguous. It also clarifies the exact parameter names, distinguishing it from potential sibling converters.

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

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

The description does not provide guidance on when to use this tool versus alternative converters like convert_data or convert_file. It does not mention exclusions or conditions that would route an agent to a sibling. The only implicit hint is the format list, but no explicit 'use when' or 'don't use when' 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 no behavioral information beyond the schema's own category list. Annotation readOnlyHint=false is questionable for what is conceptually a pure computation with no side effects, and the description does nothing to clarify that no state is mutated. With annotations present the bar is lower, but zero behavioral content is still a real gap.

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

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

One front-loaded sentence with the tool name followed by the concrete action and scope — efficient and easy to scan. The trailing '[category: convert]' tag is internal metadata noise that earns no place in the description.

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 4-parameter, all-required, enum-driven computation tool with no output schema and full schema coverage, the description is sufficient to call it correctly. It is only slightly thin on the edge cases (invalid cross-category pairs, negative values) that the schema partially handles.

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

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

Schema description coverage is 100% (including the 'pick this first' guidance on category and the 1024-byte note on data sizes), so the schema carries all parameter meaning. The description only restates the category domains and adds no syntax, format, or constraint detail beyond it; baseline 3 applies.

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

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

States a specific verb and resource ('Convert between units of measurement') and enumerates the eight supported measurement domains, which cleanly separates it from the file-oriented convert_* siblings (convert_file, convert_data, convert_document). An agent can tell at a glance this is a unit-math tool, not a file format converter.

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

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

Usage is implied by the purpose — the tool is self-evidently for unit conversion — but there is no explicit when-to-use, when-not-to-use, or pointer to alternatives among the many convert_* siblings. The guidance is adequate only because the domain is so narrow that inference is easy.

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 significant behavior beyond annotations: the SSRF-guarded fetcher, server-side asset fetching and inlining, offline rendering, and the static-rendering limitation. This is exactly the kind of behavioral context that helps an agent predict side effects and failure modes.

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 but information-dense: it front-loads the core purpose, then covers mechanism, security, and limitations in a few sentences. Every clause adds value, and there is no redundant filler.

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

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

For a simple one-parameter conversion tool, the description is complete enough: it explains what it converts, how it fetches and renders, the key security trait, and the main limitation. No output schema exists, but the output is clearly implied by 'to PDF', and nothing essential is missing.

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

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

The input schema already fully documents the single 'url' parameter with a clear description, so the baseline is 3. The description adds a small amount of extra meaning by specifying that the URL should be passed as a JSON-body property, but this is marginal 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 names a specific verb (Convert), a specific resource (a live web page/URL), and a concrete output (PDF). It also distinguishes itself from HTML-to-PDF or file-conversion siblings by emphasizing 'live web page' and 'server-side fetcher'.

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

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

The description gives clear context for when the tool is appropriate: converting a live URL to PDF. It also provides an important when-not signal by stating JavaScript is not executed, so SPAs may render sparsely. It stops short of naming an alternative tool explicitly, which keeps it just below 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 only set readOnlyHint=false and destructiveHint=false, so the description carries the burden of behavioral disclosure. It adds several key behaviors: out-of-range CRF values are clamped rather than rejected, CRF is ignored when bitrate or preset is set, format is sniffed from bytes with filename extension as fallback, and Business tier restrictions. It does not describe the output behavior (e.g., return format), but given the annotations are minimal, it provides substantial 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 dense but well-structured: it leads with the core purpose, then formats, controls, presets, legacy support, and pricing. Every sentence adds value without redundancy. It is longer than a simple one-liner but justifies the length given the tool's complexity. Slightly front-loaded with the primary use case.

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 formats, codecs, resolution, bitrate, presets, file size/duration limits, and legacy conversion. It explains failure modes (codec/format incompatibility) and free vs. Business constraints. Without an output schema, it doesn't detail the return value, but for a conversion tool the output is implied. Overall, it gives enough context 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 input schema already has 100% description coverage with detailed explanations for each parameter (e.g., CRF scale, codec compatibility, resolution behavior, preset effects). The description adds some contextual value (e.g., legacy formats, free tier limitations) but does not meaningfully enhance parameter meaning beyond what the schema already provides. Baseline of 3 is appropriate.

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

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

The description clearly states the verb (convert), the resource (video), and the specific purpose: making a video play or import where it currently won't. It enumerates target formats (mp4, mov, webm, mkv, avi, gif) and distinguishes from siblings like media_compress_video by focusing on format/codec conversion rather than compression. It also mentions legacy format conversion, which adds scope clarity.

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 identifies the core use case: videos that fail to play/import/upload due to format incompatibility. It mentions presets for specific platforms (TikTok, Reels, Shorts, Twitter, WhatsApp) and free tier limits, which guide when the tool is appropriate. However, it does not explicitly name alternative tools (e.g., media_compress_video) or state when not to use it, so it lacks explicit 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 carry the safety profile (readOnlyHint=false, destructiveHint=false), and the description adds the LibreOffice engine and accepted formats beyond that. It does not disclose output behavior (returned file vs. link) or limitations like size or .doc fidelity, though the simple schema lowers the burden.

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

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

The description is a single front-loaded sentence that states the action immediately. The '[category: convert]' tag is mild redundancy given the convert_ prefix, but it adds no significant bloat.

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

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

For a one-parameter converter with no output schema, the description covers the input side adequately. It does not state what the tool returns after conversion, and given dozens of convert siblings, a routing hint toward/away from convert_document or pdf_to_word would improve completeness.

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

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

Schema coverage is 100% and the single 'file' parameter is described as 'Input file (DOCX, DOC)' in the schema itself. The description repeats the format scope but adds no new parameter-level meaning, so the high-coverage baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Convert a Word document (.docx, .doc) to PDF using LibreOffice.' The explicit format coverage (.docx/.doc) and target output (PDF) distinguish it from the many convert_* and pdf_* siblings without needing to open the schema.

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

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

Usage is implied by the name and format details — an agent can infer 'when a Word file needs PDF output.' However, no alternatives or exclusions are mentioned, which is a gap given the broad sibling list includes convert_document, convert_file, convert_batch, and pdf_to_word (the reverse operation).

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 the tool writes a file, which goes beyond the basic annotations (readOnlyHint=false, destructiveHint=false). It also mentions the file is downloadable and can be emailed/zipped/converted. The CSV and JSON behavior details are already in the parameter schema, so the description adds some but not extensive behavioral context. 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 well-structured with a clear headline and logical flow. The list of example upstream tools adds length but is directly useful for routing agents. It is not overly verbose, and every sentence contributes to understanding the tool's role.

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

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

Given the tool's simplicity (3 params, 1 required, no output schema), the description covers the essential use case, when to use it, and the output nature (a downloadable file). It does not explain what happens if the file already exists (likely overwrites) but that is not critical. The schema fills in parameter details, so overall the description is complete enough.

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

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

Schema description coverage is 100%, and the tool description largely repeats what the schema already explains about the parameters (CSV tabulation, JSON pretty-printing, name length limit). It does not add significant new meaning beyond the schema, so it stays at the baseline of 3.

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

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

The description states a precise action ('Write the result of an earlier step to a real, downloadable file') with supported formats (.txt, .csv, .json, .md). It clearly differentiates from sibling tools by focusing on saving in-memory results to files, not converting, analyzing, or generating. Specific examples of upstream tools (Color Palette Extractor, Password Generator, etc.) further clarify its role.

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 says 'Use after any step that produces text or data rather than a file' and lists many such tools, providing strong when-to-use guidance. It does not explicitly name alternative tools for when not to use it (e.g., when you already have a file to convert), but the purpose is distinct enough that this is not a major 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?

Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description discloses the write-only nature: 'Only ever writes: it cannot read, list or search anything already in their Drive.' It also surfaces the account-connection prerequisite. It does not describe failure behavior when the account is missing, but the key behavioral boundaries are exposed.

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

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

Four sentences, front-loaded with the core action and followed by trigger, prerequisite, and constraint. Every sentence adds distinct information; there's no filler or redundant restating of the title.

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 simple three-parameter schema and the description's coverage of purpose, trigger, prerequisite, and write-only limitation, an agent has everything needed to decide when to call and what the tool does. No output schema exists, but the return value for a save operation is self-evident.

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

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

The input schema already covers all three parameters with descriptions at 100% coverage, so the description need not repeat them. The main description only implies the folder behavior ('We create this folder...' appears in schema, not the description). Baseline 3 is appropriate since schema carries the semantic load.

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

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

The description opens with the verb-resource pair 'Save to Google Drive' and specifies the exact scope: a finished file into the signed-in user's own Drive. The closing sentence ('Only ever writes: it cannot read, list or search anything already in their Drive') sharply distinguishes it from any file-read/search sibling. This leaves no ambiguity about what the tool does.

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

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

It states explicit trigger conditions: 'Use as the last step of a workflow when the user asks for the result to be put in, saved to, or uploaded to their Drive.' It also gives an exclusion ('cannot read, list or search anything already in their Drive') and a prerequisite (Google account connected on Integrations page). It doesn't name alternative tools like email_file, but the scope is clear enough to route an agent.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true. The description adds real substance beyond that: the mail routes through the user's connected Google account, lands in both Sent and inbox, the recipient is always fixed, and no arbitrary content can be sent. The 5 MB size limit appears in the schema's note field.

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

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

Front-loaded with the action and recipient, then constraints, then the usage gate. Every sentence carries a distinct piece of information with no filler.

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

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

No output schema exists, but the description fully covers what happens after invocation (delivered to the user's own mailbox), the recipient constraint, the content constraint, and when to use it. Nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, so file, note, and subject are all already documented in the schema. The description reinforces the fixed-recipient behavior but adds no syntax, format, or edge-case detail beyond what the schema fields provide. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource (email a finished file) plus the exact recipient scope (the user themselves, via their connected Google account). An agent can distinguish this from any convert/generate/upload sibling without opening a schema.

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

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

Gives an explicit trigger ("Use ONLY when the user explicitly asks to have a result emailed to them") and explicit exclusions (cannot email anyone else, cannot send custom or user-authored content). The when-not conditions are as clear as the when.

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

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

Annotations declare readOnlyHint=false, openWorldHint=false, and destructiveHint=false, so the agent knows this is a write operation confined to the tool's environment. The description adds valuable behavioral context: Free tier limit, Pro+ audit trail feature, and the fact that the tool draws or types a signature. It doesn't mention reversibility or permissions, but with annotations covering the safety profile, this is solid.

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

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

Compact single sentence with key details front-loaded: action, methods, Pro+ feature, and tier limit. It's efficient but could be slightly more structured, as the category tag at the end feels like metadata rather than description.

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

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

For a two-parameter tool with full schema coverage, no output schema, and clear annotations, the description covers the essential: what it does, how to use it, tier constraints, and a distinguishing feature (audit trail). Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so both parameters are fully documented in the schema. The description adds practical guidance by explaining how to build the 'fields' parameter (use the PDF E-Signature page to draw boxes and paste the value) and notes the 100-placement limit, which goes beyond the schema's technical description.

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

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

States a specific verb+resource: placing signature, initial, date, or text fields onto a PDF. It clearly distinguishes itself from sibling tools like esign_prepare and pdf_watermark by naming the exact placement action and the Pro+ audit trail feature.

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

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

Implies when to use it (to add signature fields to a PDF) and mentions the Free tier limit of 3 signed documents per month, which is useful context. However, it does not explicitly state when NOT to use it or name alternatives like esign_prepare for a different signing workflow.

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 clearly states what the tool returns, which is helpful. However, annotations mark readOnlyHint as false, implying possible side effects, but the description does not disclose any state changes, storage, or session behavior. It avoids contradicting the annotations but leaves the side-effect profile ambiguous.

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

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

A single, front-loaded sentence states the action, the resource, the output, and the purpose. The trailing [category: sign] is compact metadata. There is no filler or repetition.

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

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

With one parameter, no output schema, and a simple purpose, the description covers the essential return values and context. It does not specify the exact output format or failure behavior, but for this low-complexity tool the description is largely sufficient for an agent to select and invoke it.

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% for the only parameter, file, which is already documented as 'Input file (PDF).' The description adds nothing about the parameter beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Return page count and per-page point dimensions for a PDF.' It also explains the purpose—positioning signature fields—which clearly distinguishes this from generic PDF tools like pdf_page_count or pdf_file_info and from the sibling esign_place.

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

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

The phrase 'so signature fields can be positioned by the editor' gives clear context for when this tool should be used: in an e-sign workflow before placing signatures. It does not explicitly mention when not to use it or name alternative siblings, but the intended context is apparent.

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?

Adds meaningful behavioral context beyond the sparse annotations: the 200-file extraction limit, the pass-through semantics ('Converts nothing'), and the list-shaped output. No contradiction with readOnlyHint=false or destructiveHint=false; unzipping producing outputs without destroying inputs is consistent.

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

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

Three tight sentences front-load the purpose, then usage, then constraints, with zero filler. The category tag is the only marginal element and it is unobtrusive. Every sentence earns its place.

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

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

For a single-parameter utility with no output schema, the description is complete: it conveys the return shape ('as a list'), the pipeline context (previous step's output), and the operational limit (200 files). Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds modest value by reinforcing that the file must be a .zip and implying a file-count constraint, but the schema already explains the parameter's role as the previous step's output. No substantial new parameter meaning is added.

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

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

States a specific verb and resource ('Open a .zip archive') plus the output shape ('hand the files inside it to the next step, as a list'). 'Converts nothing' explicitly separates it from convert_archive and other transform tools, and the output behavior distinguishes it from the inverse sibling files_zip.

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

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

Gives explicit triggering conditions: 'Use when an earlier step produced a ZIP' and names the exact producers (PDF Thumbnails, PDF to Images, Split PDF, Extract Frames, batch converters) plus the downstream condition ('next step works on the individual files'). It lacks an explicit 'do not use if' clause, but 'Converts nothing' serves as an implicit 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 cover the safety profile (readOnlyHint=false, destructiveHint=false), so the description adds useful context beyond them: files are bundled 'unchanged', nothing is converted, and the 1-50 file limit is stated. It does not describe the return format or what happens if the limit is exceeded.

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

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

Front-loads the core purpose and packs triggers, exclusion, and limits into a compact block. It's dense (em-dash fragments) but every clause carries information; minor redundancy on the file-count limit repeated from the schema.

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

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

For a simple utility with no output schema and full schema coverage, the description covers purpose, triggers, exclusion, and constraints. Only return-value behavior is unaddressed, which is a minor gap 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?

Schema description coverage is 100%, so both parameters (name, files) are already documented, including defaults and accepted id forms. The description echoes the same 1-50 limit and file sources without adding new syntax or format detail — baseline 3 applies.

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

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

States a specific verb (zip/bundle) and resource (files into one .zip archive) and explicitly contrasts with the sibling convert_batch and its non-converting nature. An agent can distinguish it from convert_* and files_unzip without opening schemas.

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 trigger phrases ('zip / bundle / archive / put them all in one file') plus the delivery use case (several results as one attachment), and a named alternative condition ('for converting many files use convert_batch'). Nothing is left 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 only indicate readOnlyHint=false and destructiveHint=false, so the description carries the burden of explaining behavior. It adds mode-dependent logic and the automatic file fallback, going beyond the schema. It does not detail side effects or output format, but for a generator whose output is stated as ASCII art this is sufficient.

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 dense sentences plus a category tag, with the core purpose front-loaded. Every clause adds information about modes or fallback behavior; there is no filler or repetition.

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

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

The description covers the tool's central decision logic (text vs image mode, automatic file fallback), and the schema handles parameter constraints such as width bounds, font enum, file size, and truncation. Since there is no output schema, the output type is clear from 'ASCII art.' Minor gaps like font-only-in-text-mode are covered by schema x-show-when conditions.

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

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

Schema coverage is 100% with descriptive text for all five parameters, setting a baseline of 3. The description adds value by explaining the interplay between text, file, and mode—especially that an attached file is converted even when text mode is selected. This is meaningful beyond the individual field 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 opens with 'Convert text or an image to ASCII art,' naming a specific verb and resource. It clearly distinguishes this tool from the many generate_* siblings by its domain (ASCII art) and by enumerating the two modes, 'text' and 'image'.

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

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

The description explains when each mode applies ('Mode text (the default) draws the words in text; mode image converts file') and the fallback behavior ('With no text and a file attached, the file is converted in either mode'). This gives clear context of use, though it does not contrast this tool with an alternative sibling.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, which already signal a non-destructive creation operation. The description adds the output format (PNG image) but does not disclose behavior like fallback to Code128 for unrecognized input (though that is in the schema) or how the generated file is returned (e.g., file path vs. data URI). With annotations covering the safety profile, the description adds modest value beyond 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 description is a single sentence followed by a category tag. It is concise and front-loads the core purpose and output format. No wasted words; every element earns its place. The category tag is redundant but harmless.

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 relatively simple with 4 well-documented parameters and no output schema. The description covers the output format (PNG). It does not explicitly state what the return value is (e.g., a file path), but for a generate tool of this type, that is often implicit and not a critical gap. The combination of description and schema is sufficient for an agent to call 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 description coverage is 100%, so every parameter (type, height, content, showText) is documented in the schema. The type parameter's description is particularly detailed, covering constraints for each barcode standard. The tool description adds no new parameter-level information, so it relies on the schema. Baseline 3 is appropriate given the high 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 states a specific verb ('Generate') and resource ('a barcode') with explicit output format ('as a PNG image'). It lists example barcode types (Code128, EAN-13, DataMatrix, PDF417) which distinguishes it from the sibling generate_qr_code tool, which is specific to QR codes. The purpose is unambiguous and actionable.

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

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

The description provides no guidance on when to use this tool versus alternatives like generate_qr_code. It does not mention that this is the general-purpose barcode generator and that generate_qr_code is for QR-only needs. An agent must infer the difference from the name and description, which is insufficient.

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

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

With annotations already marking the operation as non-read-only but non-destructive, the description adds limited behavioral context: it discloses that the output is printable and can be PDF or PNG. It does not explain side effects, file handling, or post-generation behavior, but this is partially acceptable given 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 a single front-loaded sentence that communicates the core purpose immediately. The 'Business Card Generator' prefix slightly repeats the tool name, but it does not bloat the description or obscure the actionable content.

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?

All 10 parameters are thoroughly documented in the schema, which carries most of the burden. However, there is no output schema and the description does not mention what the tool returns or where the generated card goes, which is a noticeable gap for a generator tool.

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

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

Schema description coverage is 100%, and the schema already documents default values, enum options, formatting behavior, and constraints such as Latin-1 encoding and omitted lines. The description only summarizes the input categories and adds little semantic value beyond the schema.

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

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

The description states a specific verb ('Generate'), a clear resource ('printable business card'), and the output formats (PDF or PNG). It also lists the main input fields, making it easy to distinguish from the many other generate_* 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 use case is implied strongly by 'Business Card Generator' and 'Generate a printable business card', but there is no explicit guidance about when to use this tool versus alternatives such as generate_certificate or generate_placeholder_image. No exclusions or alternative routing are provided.

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

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

Annotations carry little signal since all hints are false/defaults, so the description bears the disclosure burden. It accurately conveys a non-destructive creation behavior that produces a printable PDF or PNG, which is consistent with annotations. It does not discuss return behavior or edge cases, though the schema's property descriptions document silent fallbacks (e.g., unknown format values returning PDF).

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 is a single short sentence that front-loads the purpose and output formats. Minor deductions for redundancy: 'Certificate Generator' repeats the annotated title, and '[category: generate]' is meta-noise that adds no value for an agent.

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

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

Invocation is well supported because the 100%-covered schema documents every parameter and its quirks, and the description pins down the purpose. However, with no output schema and uninformative annotations, the description gives no expectation of what a successful call returns (file path, download, base64), which is a notable gap for a tool with 10 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 100%, so the baseline is 3 even though the description itself adds no parameter detail. All 10 parameters are richly documented in the schema itself, including naming cautions ('certTitle' not 'title'), fallback behaviors, and conditional rendering, so nothing important is left 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 uses a specific verb and resource ('Generate a printable certificate of achievement or completion as PDF or PNG'), naming both the artifact and its output formats. This cleanly distinguishes it from the many sibling generate_* tools such as generate_barcode, generate_qr_code, and generate_business_card, which target entirely different artifacts.

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 'certificate' resource strongly implies the use case — creating achievement/completion certificates — and the sibling generate_* tools are differentiated by artifact type. However, there is no explicit when-to-use statement, no mention of alternatives, and no exclusions; usage must be inferred rather than stated.

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

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

Annotations already cover the safety profile (readOnlyHint=false, destructiveHint=false). The description adds minimal behavioral context beyond stating it generates a palette; it doesn't mention return format, determinism, or side effects, but given annotation coverage, 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?

Two sentences: the first states the core function, the second provides a sibling contrast. No filler, and the purpose is front-loaded. Efficient 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?

For a simple tool with three fully-described parameters and no output schema, the description covers the essential usage. It could mention the output format (e.g., returns a list of hex colours) but that is not critical given the schema and sibling context. Overall complete enough for correct invocation.

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

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

Schema description coverage is 100% – each parameter has a clear description and defaults. The description only repeats the base_color concept ('starting from one colour you choose') without adding new meaning, so it matches the baseline for fully-documented schemas.

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

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

The description states a specific verb ('Build') and resource ('a set of colours that work together'), and explicitly contrasts itself with the 'Color Palette Extractor' sibling. This makes the tool's function unambiguous and distinct from related palette 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?

It clearly frames when to use this tool vs. the extractor ('starting from one colour you choose' vs. 'pulls a palette out of a picture'), which gives context. However, it does not discuss alternatives among other generate_* tools (e.g., generate_gradient) or exclusions, leaving some selection ambiguity.

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), so the description carries most of the transparency burden. It discloses the output format (ico + png) but not how the generated files are delivered, whether generation creates side effects, or what happens if the source image is invalid. Significant behavioral gaps remain.

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

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

The core action is front-loaded and the overall entry is short. The second sentence explaining what a favicon is and the blank-page consequence is contextual padding rather than invocation guidance, but it does not bloat the description enough to hurt usability.

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 4-parameter tool, the description plus fully documented schema cover inputs and the output format reasonably well. However, there is no output schema and no mention of how the generated favicon set is returned or stored, leaving the result of the call somewhat underspecified.

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

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

Schema coverage is 100%, and every parameter already has a meaningful description, default, and constraints. The description adds only high-level phrasing like 'optional rounded corners' and 'from a source image', which mirrors existing schema fields. It does not meaningfully extend 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?

States a specific verb ('Generate'), a precise resource ('favicon set (ico + png sizes)'), and the source ('from a source image'). The operation is clearly distinct from the many sibling generate_* tools. No ambiguity about what this tool produces.

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

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

No explicit when-to-use guidance or alternative comparisons are given. The favicon explanation implies a use case, but it never tells an agent when to choose this over related image/generation tools. Nothing about exclusions or prerequisites is provided.

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

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

Annotations already indicate non-readOnly and non-destructive, so the description adds context about producing a real picture for later compositing. It does not disclose further behavioral traits such as output format details, file handling, or side effects, but given annotations cover the safety profile, this is adequate.

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

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

Two sentences with zero waste. The main purpose is front-loaded, and the differentiation from the web page is concise. The category tag adds organization without 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?

Given the tool's moderate complexity (6 parameters, no output schema), the description is minimal. It mentions the output is a PNG image and hints at compositing use, but does not explain how the result is returned (e.g., file path or binary) or any additional context about using the tool effectively. The schema covers parameters, but the description lacks output/return information.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the schema. The description adds no parameter-specific information, so the baseline of 3 applies. The description does not need to repeat schema details.

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 blends two or more colours into a PNG image, and distinguishes it from a web-page variant that produces CSS. This is specific and differentiates it from sibling generate_* tools like generate_color_palette or generate_placeholder_image.

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

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

The description explicitly contrasts with the web page alternative, indicating when to choose this tool (when a real raster image is needed for compositing). It does not mention other generate_* tools, but the differentiation from the CSS-writing variant provides clear context for a key use case.

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), so the description carries the burden. It discloses a key behavioral trait: the tool always returns all four hashes and ignores any algorithm-selection request. It also notes that file input wins over text, which is a behavioral quirk beyond the schema. It doesn't mention output format or size limits, but the core non-obvious behavior is disclosed.

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

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

Three sentences with zero waste. The core function is front-loaded, the always-returns-all-four behavior is stated early, and the exclusions (no algorithm selection, no bcrypt) are packed into the final sentence. Every sentence earns its place.

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

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

For a simple two-parameter tool with 100% schema coverage and no output schema, the description is nearly complete. It covers the main behavior, the input precedence, and the exclusions. The only minor gap is the lack of detail on the return format (e.g., whether it returns a JSON object with four hash fields), but the tool's simplicity and the schema's completeness make this a minor omission.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('file' and 'text') with descriptions. The description adds the 'file wins' precedence rule, which is useful, but it doesn't add much beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting and the description adds only marginal value.

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

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

The description states a specific verb ('Compute'), the exact resource (MD5, SHA-1, SHA-256, SHA-512 hashes), and the input types (text or uploaded file). It also explicitly distinguishes itself from a hypothetical algorithm-selection tool by noting there is no algorithm selection and bcrypt is not supported. This clearly separates it from siblings like analyze_hash and generate_password.

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

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

The description gives clear context on when to use the tool: when you need MD5/SHA-1/SHA-256/SHA-512 hashes of text or a file. It explicitly states what it does NOT do (no algorithm selection, no bcrypt), which helps an agent avoid misusing it. However, it does not explicitly name alternative tools for bcrypt or other hash types, so it falls just short of 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 provide little safety context (readOnlyHint: false, destructiveHint: false), so the description carries the burden. It adds that generation is driven by word or paragraph count, but it does not disclose whether the output is plain text, whether it is returned directly to the caller, or whether any file is created. For a simple generator this is a modest but acceptable transparency level.

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

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

The description is a single front-loaded clause followed by a category tag, with no filler or redundant explanation. It is appropriately sized for a simple tool, even though it omits one supported mode, which is an accuracy issue rather than a conciseness issue.

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 generator with fully documented parameters and no output schema, the description covers the core purpose and main modes. Missing details such as exact return format or whether output is a file are not clearly stated, but 'placeholder text' strongly implies the result is returned text, making the definition mostly complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema; it reinforces the concept of count-based generation but does not explain parameter interplay or the startLorem option, which the schema already documents adequately.

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

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

The description clearly identifies the tool as generating lorem ipsum placeholder text and mentions word/paragraph count modes, so the resource and action are specific. However, it does not explicitly differentiate from sibling generators such as generate_placeholder_image, and it omits the 'sentences' mode that the schema supports, making it slightly incomplete.

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 versus related alternatives like generate_placeholder_image or other text-generating tools. There are no when/when-not conditions or explicit exclusions; the intended usage must be inferred from the resource name and context.

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

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

The description adds a meaningful behavioral claim—'cryptographically secure random'—and indicates output configurability. It does not contradict the annotations, but it omits edge-case behavior such as the all-character-sets-off fallback and excluded symbols, which are only explained in the parameter descriptions.

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 behavior is conveyed in a single front-loaded sentence with no wasted explanation. The 'Password Generator —' prefix and '[category: generate]' tag are mildly redundant with the title and category, but they do not meaningfully hurt 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?

For a stateless generation tool with fully documented parameters, the description plus schema covers the essential behavior and constraints. A small gap is the absence of an explicit return-shape statement, though the output of a password generator is reasonably predictable.

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

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

Schema description coverage is 100%, so the schema fully documents all seven parameters. The description's reference to 'length and character sets' adds no semantic value beyond what the schema already provides, earning the schema-rich baseline of 3.

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

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

The description names a specific action ('Generate') and a specific resource ('a cryptographically secure random password'), while also noting configurable length and character sets. This is unambiguous and clearly distinguishes it from the many sibling generate_* 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 no guidance on when to use this tool versus alternatives, nor any exclusion criteria. With siblings like generate_hash, generate_uuid, and generate_barcode nearby, the description leaves the choice entirely 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 (readOnlyHint=false, destructiveHint=false) already signal this is a generating tool. The description adds that it produces placeholder images at arbitrary dimensions with custom colors and text, but it does not disclose output behavior such as how the image is returned or saved, or the clamping behavior for dimensions over 4096.

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 one-sentence description is concise and front-loaded with the tool's identity and action. The leading 'Placeholder Image' title is slightly redundant with the tool name, but the rest of the sentence is efficient.

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

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

For a six-parameter tool with no output schema, the description gives a solid high-level overview but omits the return/save behavior and expected output form. The rich parameter schema compensates for most invocation details, yet the missing output semantics leave a notable gap.

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

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

Schema description coverage is 100%, so the schema fully documents every parameter including defaults, clamping, and hex color expectations. The description only mentions 'background colour' and 'label text' generically, adding no parameter meaning beyond the schema.

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

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

The description states a specific verb ('Generate') and resource ('placeholder image') with concrete customization dimensions, background color, and label text. This distinguishes it from sibling generation tools such as generate_barcode or generate_favicon, even without naming an alternative.

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

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

The term 'placeholder image' implies the intended use case, but the description provides no explicit when-to-use guidance, exclusions, or comparison to sibling tools like generate_favicon or photo_resize. Usage context must be inferred from the tool's name and category.

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

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

Annotations already declare non-read-only and non-destructive behavior; the description adds that output is a PNG image and inputs span URL/text/vCard. However, it does not disclose where the generated PNG is delivered (file path, base64, binary), whether a file is written to the workspace, or how invalid content is handled.

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

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

The core sentence is tight and information-dense, but the leading 'QR Code Generator' repeats the title attribute and the trailing '[category: generate]' tag adds no decision-relevant value for an agent. Two of the three segments are redundant.

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 bears the burden of explaining the result; 'as a PNG image' partially covers this but omits the return mechanism (file reference vs. inline data). For a simple 3-parameter generator whose schema documents all parameters, this is adequate but leaves a real gap.

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

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

Schema description coverage is 100%, so the baseline 3 applies. The description's phrase 'URL, text, or vCard data' merely echoes the schema's own content description ('The URL, text, or vCard data to encode') and adds no parameter-level detail beyond it.

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

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

The description states a specific verb (Generate), resource (QR code), accepted input types (URL, text, vCard data), and output format (PNG image). This clearly distinguishes it from siblings like generate_barcode and generate_placeholder_image without needing to open any schema.

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

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

The input types (URL, text, vCard) imply when the tool applies, but there is no explicit when-to-use guidance, no mention of alternatives, and no exclusionary conditions (e.g., 'for barcodes use generate_barcode'). Usage context is present but left 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?

With only basic annotations, the definition adds valuable behavioral detail: the PNG has a transparent background, invalid colors are refused, out-of-range font sizes are clamped, and an unavailable handwriting font triggers substitution via a response header. It does not mention output encoding/delivery, but no annotation contradiction exists.

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

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

The main description is two sentences that front-load the core behavior and downstream purpose, with a category tag at the end. The longer parameter descriptions are organized by field and each sentence carries semantic value.

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

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

For a generator with six parameters and no output schema, the definition gives the output format (PNG, transparent background) and covers failure behavior via parameter descriptions. It does not state how the PNG is delivered (path, data URL, bytes), which is the main remaining gap.

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

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

Schema description coverage is 100%, so each of the six parameters is documented in the input schema with defaults, constraints, and edge cases. The top-level description adds no additional parameter relationships or examples, matching the baseline for high 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 states a specific verb and resource: write a name in a handwriting style and return it as a transparent-background PNG for later stamping onto a PDF. It clearly distinguishes generate_signature from the many sibling generators and from the esign_* tools that place signatures.

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

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

It gives the intended usage context ('so a later step can stamp it onto a PDF'), which tells an agent this tool produces an intermediate asset rather than a finished document. It does not explicitly name the sibling esign_place/pdf_watermark as the downstream alternative, so there is a small exclusion 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 already signal no destructive behavior, and the description adds little behavioral detail beyond listing formats and the rationale. The schema descriptions elsewhere cover edge-case clamping and refusal behavior. Nothing here contradicts annotations, but the description itself doesn't disclose return shape, randomness guarantees, or side effects beyond what the schema provides.

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, front-loaded with the core action and formats, and each sentence earns its place, including the rationale for why the tool exists. The category tag is small and useful rather than redundant.

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

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

Given the fully documented schema and simple generation purpose, the description is largely complete. The main gap is the lack of an output schema or any statement about the return shape, especially whether count=1 returns a single value or an array. For a generator tool, that missing detail is a minor but real omission.

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 parameters are already fully documented with defaults, ranges, conditional visibility, and enum labels. The tool description itself adds no parameter-level detail, which is acceptable given the complete schema, hence the baseline score of 3.

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

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

The description uses a specific verb–object pair ('Generate unique identifiers') and immediately enumerates the exact formats: UUID v4/v7, ULID, Nano ID, or random hex. This clearly distinguishes the tool from sibling generators like generate_hash or generate_password and leaves no ambiguity about what it produces.

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 application context: use it when a workflow needs real identifiers rather than having a language model invent them. It does not enumerate sibling alternatives or say when not to use it, but the stated purpose is clear enough to guide selection.

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

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

Annotations only declare non-read-only and non-destructive. The file parameter description adds key behavioral context: forces full H.264 re-encode into MP4, audio copied, and is among the platform's slowest ops on long videos. This goes beyond annotations, although the main description does not mention 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 main description is a single efficient sentence front-loaded with the action and key controls. The [category: media] tag is minor metadata but not verbose. 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?

All 5 parameters are well-explained, including defaults and range constraints. With no output schema, return-value documentation isn't required. However, the description doesn't state whether the input is overwritten or a new file is returned, a moderate gap for a transform 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?

100% schema description coverage, and each property has explanatory content beyond the schema type: text escaping and 200-char limit, opacity visual meaning, font size fallback when set to 0, and position enum labels. Substantially helps an agent choose correct values.

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

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

States a specific verb ('Overlay'), resource ('video'), and method ('text watermark using FFmpeg') plus controls ('position and opacity'). The title 'Video Watermark' and [category: media] tag make it distinct from photo/pdf watermark 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?

No guidance on when to use this tool versus alternatives such as photo_watermark or pdf_watermark. The sibling list and title imply video-specific use, but the description itself does not state conditions, exclusions, or preferred scenarios.

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

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

The description adds meaningful behavioral context beyond the sparse annotations by naming FFmpeg, H.264 re-encoding, and quality presets. It does not explain output-file handling or non-destructiveness, but the schema's file parameter already documents the returned MP4 format.

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 short sentence with the key behavior front-loaded. The 'Compress Video —' prefix and '[category: media]' tag are slightly redundant with the tool name and sibling context, but they add minimal overhead.

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

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

For a two-parameter tool with full schema coverage, the description plus schema is sufficient to select and invoke the tool correctly. Although there is no output schema, the file parameter description already specifies the H.264/AAC MP4 result, so the description does not need to repeat it.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already explains the output format for 'file' and the CRF mapping for 'quality'. The description only repeats the high/medium/low preset names without adding new parameter meaning.

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