John's Essentials

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

Annotations already declare readOnlyHint=true, and the description adds the specific set of extracted audio properties, including waveform data. This gives the agent a concrete sense of what will happen without contradicting the read-only annotation. It stops short of describing output format or limits, but annotations lower the bar here.

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

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

The description is a single, compact sentence with the action and resource front-loaded, followed by a useful property list. The 'Audio Analyzer —' prefix is redundant with the title, but the remaining text earns its place without 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 single-parameter, read-only analysis tool with no output schema, the description provides the expected return dimensions and the schema handles input format documentation. It could mention output format or file-size constraints, but nothing essential is missing for correct selection and 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%: the file parameter is already documented as an input file with accepted formats (MP3, WAV, AAC, FLAC, OGG). The description adds no additional parameter-level meaning 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 states a specific verb ('Analyse') and resource ('audio file'), then enumerates concrete output dimensions: duration, sample rate, bit rate, channels, codec, and waveform data. This clearly distinguishes the tool from generic analyze_file and sibling tools like analyze_video.

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: use this tool when audio properties are needed. It does not explicitly name alternatives or exclusions, but the strong audio-specific framing and property list make the intended use obvious among the many analyze_* 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?

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 declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the two operating modes and the pairing constraint, but it omits the 2,000-line truncation behavior (that detail lives only in the strict parameter's schema text), so it contributes limited behavioral context beyond structured fields.

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, front-loaded with the action and the two supported input shapes, with no filler. The category tag adds no value, and the trailing 'Provide one complete pair' sentence is slightly clipped, keeping it short of a 5.

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

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

With no output schema, the description carries some burden for describing return values, yet it only says 'line-by-line diff' without indicating the format (unified, split, etc.). Input modes are adequately covered, but output expectations for a diff tool remain underspecified.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters, including the pairing rule and the 2,000-line/strict behavior. The description's reference to (file_a + file_b) and (text_a + text_b) restates what the schema already conveys, 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 and resource ('Show a line-by-line diff between two text files... or two pasted texts'), which is far clearer than a generic name restatement. It does not explicitly differentiate itself from the closest sibling, photo_image_diff, 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?

'Provide one complete pair' gives a useful mutual-exclusivity constraint (file mode vs. text mode), which is real usage guidance. However, there is no explicit when-to-use, when-not-to-use, or pointer to any alternative tool, so it remains implied rather than stated.

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

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

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 declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds meaningful behavioral context such as the two-engine hybrid design that 'catches wording and context problems the rule checker cannot see' and the per-issue severity output. It stops short of describing permissions, limits, or return 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?

A single dense sentence front-loads the tool category ('Grammar Checker —') and then enumerates differentiating features without redundancy. The trailing '[category: analyze]' tag is minor metadata clutter but the rest 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 five-parameter read-only analysis tool with no output schema, the definition covers capabilities well but omits return shape (e.g., structured issue list vs text) and the 50k character limit lives only in the schema. Adequate but not complete for an agent that needs to know what comes back.

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

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

Schema description coverage is 100% and all five parameters carry detailed descriptions, enums, and UI labels, so the schema does the heavy lifting. The description names the style guides and dialects but adds no syntax or format detail beyond what the schema already provides, matching the baseline for full coverage.

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

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

States a clear verb-resource pair (grammar checking of text) and enriches it with concrete capabilities: hybrid LanguageTool + Grok engine, rule citations, style-guide and dialect enforcement, and per-issue severity. The purpose is unambiguous, though it never distinguishes itself from the sibling analyze_grammar_check_batch.

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

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

The description lists features but gives no when-to-use or when-not-to-use guidance. It never explains how this single-text checker relates to analyze_grammar_check_batch, leaving the agent to infer which tool to pick.

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=true and openWorldHint=false, so the safety profile is covered externally. The description adds the 20-text cap and the hybrid nature of the checker, which is useful. It does not disclose latency, rate limits, or output shape beyond what the schema hints.

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 names the tool, its scope, and the per-item flexibility without padding. Efficient, though the 'hybrid' qualifier and category tag add marginal 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 batch read-only tool with full schema coverage and no output schema, the description covers the essentials. However, it does not describe the return shape (per-item results keyed by id) or failure behavior for invalid items, leaving a small gap an agent would benefit from knowing.

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 schema already documents id, mode, text, style, dialect, and include_llm with enum semantics. The description only restates that per-item style/dialect/mode are supported, adding no meaning 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: run the hybrid grammar checker across up to 20 texts. The batch scope and per-item override are clear. It does not explicitly distinguish from the singular sibling analyze_grammar_check, but the 'Batch' label and 'up to 20 texts' phrasing implies the distinction.

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

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

The 'up to 20 texts in one call' implies batch usage, but the description never says when to prefer this over analyze_grammar_check or what to do beyond the 20-item limit. Usage context is only implied.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds that hashing accepts files of any size, but says nothing about output format, performance on large files, or how it differs behaviorally from generate_hash.

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

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

Single dense sentence with no waste, title prefixed at the front and algorithms listed inline. The bracketed '[category: analyze]' tag is metadata noise 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?

Covers the core operation and the algorithm set for a 2-param, no-output-schema tool. But with a confusingly similar sibling (generate_hash), the definition should clarify the file-vs-generated-text distinction to be 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 coverage is 100%, and the schema descriptions are actually richer than the tool description (they document the file-vs-text precedence rule: 'the file wins'). The description adds no parameter meaning beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific verb (compute hashes), resource (uploaded file), and enumerates the algorithms (MD5, SHA-1, SHA-256, SHA-512). It does not differentiate itself from the sibling 'generate_hash', which is a near-identical name, leaving the agent to guess which to pick.

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

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

No guidance on when to use this vs. the sibling 'generate_hash', nor any prerequisites. The only hint is the '(File)' suffix in the title, which is not framed as an explicit routing rule.

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

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

Annotations already 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety and locality are covered. The description adds one genuine behavioral trait beyond the annotations — that non-PDF/HTML files are scanned as raw text — but says nothing about return format, link deduplication, or error behavior. With annotations carrying the safety profile, this is adequate but thin.

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 primary purpose front-loaded before the fallback caveat. Efficient and easy to scan. The trailing '[category: analyze]' tag is minor filler rather than useful 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?

For a two-optional-parameter tool with no output schema, the description covers what is extracted and how non-target formats are handled, which is most of what an agent needs. It omits expected output shape, but with no output schema present and a simple read-only operation, the gap is minor.

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

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

Schema description coverage is 100%, so both parameters are fully documented in the schema, including the 'file wins over text' precedence rule. The description adds only the raw-text fallback framing, which is already implied by the file parameter's own description. Baseline 3 is correct 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 (extract) and resource (hyperlinks) plus the input scope (PDF, HTML, or pasted text), so the agent knows exactly what this tool produces. It does not explicitly distinguish itself from adjacent siblings like pdf_to_text or web_scrape_page, which is the only thing keeping it from a 5.

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

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

The description implies when to use it by listing accepted input types and the raw-text fallback for other files, which is useful. However, it never names an alternative (e.g. pdf_to_text, web_scrape_page) or states when another tool would be preferable, so usage routing 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?

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?

The readOnlyHint and openWorldHint=false annotations already establish this as a safe, local, non-mutating computation, so the bar is lower. The description adds only the implicit fact that two numeric scores are returned; it says nothing about determinism, language limitations, or error behavior for very short input.

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 tool and its two exact output metrics; the category tag is the only inert token. Nothing is padded or repeated.

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 deterministic two-input calculator with fully documented parameters and read-only annotations, the description covers what the agent needs to invoke it. The lack of any output-format or edge-case note is a minor gap given there is no output schema.

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

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

Schema description coverage is 100% — the file field explains accepted formats and the 25MB cap, and the text field explains the ~5 word minimum and the upload alternative. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

Names a specific verb (Calculate) and precise resources (Flesch Reading Ease, Flesch-Kincaid Grade Level) applied to a text, so the agent knows exactly what it produces. It does not differentiate itself from adjacent siblings such as analyze_grammar_check or analyze_word_count, which is the only thing keeping it from a 5.

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

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

The description is a pure capability statement: it never says when to reach for this tool versus analyze_grammar_check, analyze_word_count, or analyze_word_frequency, and states no prerequisites or exclusions. Nothing about alternative selection 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=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?

Annotations already declare readOnlyHint=true, and the description reinforces this with 'Inspect' and 'Video Inspector'. The description adds value by specifying the exact behavioral scope—what properties are examined—without claiming any side effects. No contradictions with annotations exist.

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

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

The description is one tight sentence with a clear title prefix, an action verb, and a comma-separated list of outputs. Every word earns its place, and the key information is front-loaded.

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

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

For a read-only tool with one binary input and no output schema, the description sufficiently conveys what the tool returns by listing the inspected video properties. The agent can select and call the tool with confidence without missing critical context.

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

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

The schema has 100% description coverage for the single 'file' parameter, including supported formats. The tool description does not add additional parameter-level meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Inspect') and resource ('a video') and enumerates the exact properties inspected: duration, resolution, frame rate, codec, audio tracks, and bitrate. This clearly distinguishes it from sibling tools like analyze_audio or analyze_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 description implies this tool is for inspecting video metadata and properties, so an agent can infer when it is appropriate to use. However, it does not explicitly state when to prefer it over related tools such as analyze_file, analyze_metadata, or media_extract_audio, nor does it provide exclusion 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 supported input modes (pasted text or uploaded .txt/.pdf/.docx) and the metric set, which is useful context, but says nothing about limits, failure modes, or output behavior beyond what the schema states.

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

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

A single front-loaded sentence that names the tool and enumerates its outputs immediately. Efficient, with only the trailing '[category: analyze]' tag as mild 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 counting utility with two optional, fully documented parameters, the description covers inputs and metrics adequately. The only gap is that no output schema exists and the shape of the returned counts is never described.

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 with their formats and the file size limit. The description's mention of the same file types duplicates the schema rather than adding syntax or precedence guidance, 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 (Count) and resource (words, characters, sentences, paragraphs, reading time) across two input modes, so the agent knows exactly what the tool produces. It does not, however, differentiate itself from close siblings like analyze_word_frequency or analyze_readability, which is what a 5 would require.

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 never says when to reach for this tool instead of analyze_word_frequency, analyze_readability, or analyze_grammar_check, which all operate on text. Usage is only implied by the 'Count' verb; there are no named alternatives or exclusions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds only that input may be a text or document file, which the schema already states; it discloses nothing about ordering of results, edge cases (e.g. words under two letters being ignored), or usage limits beyond the structured fields.

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 states the tool's function with no wasted prose. The appended category tag is mildly redundant but does not impede comprehension.

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

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

For a simple read-only analysis tool with full schema coverage and no output schema, the description is minimally adequate — it names the function and input sources. It omits any hint about output shape or result ordering, which the absent output schema leaves unexplained.

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 (file, text, topN, exclude) is already documented in the schema, and the baseline is 3. The description adds no syntax, formatting, or mutual-exclusivity detail 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 — analysing word frequency distribution — and clarifies the input can be either a text or a document file. It is clear enough to distinguish from generic analysis siblings, though it never explicitly contrasts with close relatives like analyze_word_count 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as analyze_word_count or analyze_duplicate_detector. The agent must infer that this tool is for frequency distribution rather than simple counting purely from the name and description.

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

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

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?

Adds real behavioral context beyond the annotations: the result is returned as a downloadable file ('so it chains in workflows') and inline text can be supplied instead of a file. Annotations already establish the write/non-destructive profile. It still omits failure behavior (e.g. what happens when source == target), which keeps it below 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?

One front-loaded paragraph that leads with verb+resource, then the format list, then the two notable behaviors. Every sentence carries information; the trailing '[category: convert]' tag is minor noise but the body 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?

With no output schema, the description steps in to explain that output is a downloadable file, and it covers both input modes. It is nearly complete for a converter, with the only gap being the undocumented 'input' path and no statement of conversion failure 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 covers all three parameters at 100%, so the baseline is 3. The description adds some meaning (inline mode, chaining) but also references an 'input' JSON-body string that does not appear in the schema, creating a mild mismatch rather than enriched semantics for the actual parameters.

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

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

States a specific verb and resource ('Convert a data file between formats') and enumerates the exact format set (JSON, NDJSON/JSONL, CSV, TSV, XML, YAML, TOML, INI). That format list implicitly distinguishes it from sibling converters like convert_video, convert_archive, photo_format_converter or convert_word_to_pdf, but no sibling is named explicitly, so it stops short of a 5.

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

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

It explains the mechanics of invocation (upload a file and pick a target format, or pass inline text) which implies usage, but gives no when-to-use/when-not guidance and never names an alternative such as convert_file, convert_text or convert_parquet. Usage is inferable 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 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 declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the agent knows it's a non-destructive, closed-world mutation. The description adds useful format-edge notes (alac delivered as .m4a, heic/svg/psd input-only, legacy video formats normalized to mp4, GIF capping behavior) that go beyond annotations. But the 'Business gate on some edges' is mentioned without explanation of what triggers it or how to handle a gated failure.

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 first sentence front-loads purpose well, but the remainder is a dense single-paragraph enumeration of formats that is hard to parse. Separating the format-direction ranges and the sibling routing into distinct sentences or lines would improve scanability without losing 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?

Given 5 params, 100% schema coverage, and no output schema, the description does a good job covering conversion scope, direction constraints, and sibling routing. Gaps remain around the undefined 'Business gate', error/response shape (no output schema), and whether conversions are free or billed, but the core callable information is present.

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%: 'to', 'file', 'from', 'gif_fps' and 'gif_width' are all documented in the schema with enums and defaults. The description adds format-direction hints (image↔image, audio↔audio, video↔video/GIF) that hint at valid edge combinations, but does not enumerate which combinations are actually supported, leaving the agent to infer from the enums.

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 the resource families (image, audio, video, subtitle, document-to-PDF), and names the sibling converters (convert_document, convert_archive, convert_data) it is not. The enumeration is exhaustive but front-loaded well enough that an agent can identify the tool's 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?

Explicitly routes non-matching formats to convert_document, convert_archive, and convert_data, which is strong sibling differentiation. However, it does not mention the 'Business gate on some edges' cause or what an agent should do if a conversion is rejected by that gate, and overlap with convert_video, photo_format_converter, and media_extract_audio is not addressed.

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 substantial behavior beyond the annotations: it discloses what metadata survives conversion, how non-convertible content is reported via X-Conversion-Notes, and how strict=true changes failure behavior. These are exactly the operational details an agent needs for a lossy conversion tool with readOnlyHint=false and destructiveHint=false.

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 purpose is front-loaded in the first sentence, followed by preservation behavior and error handling. Every sentence contributes useful selection or invocation information, with no significant redundancy.

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

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

The description covers format scope, data preservation, loss reporting, and strict mode, which is strong for a conversion tool with no output schema and rich parameter descriptions. It stops short of explicitly describing the exact response shape or how the converted file is returned, so a minor gap remains.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including format detection and strict behavior. The description reinforces strict=true but does not add parameter syntax or constraints beyond what the schema provides, so baseline 3 is appropriate.

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

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

States a specific verb and resource: convert between GPX, KML, KMZ, and GeoJSON. It names the exact formats and the domain, so an agent can distinguish it from generic siblings like convert_file or convert_data 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?

Provides clear context for when this tool applies: GPS tracks and mapping data from Garmin, Strava, Google Earth, and GIS tools. It does not explicitly exclude other tools or name alternatives, so it falls short of full when/when-not guidance.

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

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

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?

Annotations only declare this as a non-readonly, non-destructive, closed-world operation; the description goes well beyond that by disclosing fidelity guarantees (numbers stay numbers, blank cells become real nulls, leading zeros preserved) and a failure mode (nested/repeated columns reported rather than flattened). This is substantive behavioral context not derivable from 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?

Front-loads the verb and resource before the format list, then layers behavioral guarantees and the flat-schema limitation. Every sentence carries distinct information with no redundancy or filler.

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

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

For a four-parameter conversion tool with no output schema and full annotation coverage, the description covers directionality, supported formats, type-fidelity guarantees, and schema limits. An agent has everything needed to invoke it correctly and anticipate the nested-column outcome.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including the jsonl alias and the parquet-on-one-side rule. The description adds no additional parameter-level syntax or format detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb (Convert) and resource (Apache Parquet) plus the full set of target/source formats, and the 'and back' framing makes the bidirectional scope explicit. An agent can distinguish this from convert_data or convert_csv 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?

The description gives a clear operating constraint ('Flat schemas only; nested or repeated columns are reported rather than silently flattened') that defines when the tool applies. Alternatives are only routed in the schema text ('table→table pairs belong to convert_data'), not the description itself, so it stops short of full when-vs-which guidance.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false). The description adds the multi-table output adaptation (zipped CSV, one workbook with a sheet per table), which is genuinely useful, but that same behavior is already spelled out in the 'to' schema description, so the added value over structured data is limited.

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

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

Front-loaded with the tool's identity and purpose, then the output-shape behavior, then the optional table argument. Efficient single paragraph, though a couple of clauses re-state schema content and could be trimmed.

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

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

For a four-parameter conversion tool with no output schema and light annotations, the description is largely complete: format options, multi-table behavior, and single-table export are all covered. It omits where/how output files are returned and naming, but this is a minor 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 input schema already documents 'to', 'file', 'table', and the nuanced 'strict' flag. The description's recounting of format-specific output shapes largely duplicates the schema, adding little beyond 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?

States a specific verb (export) and resource (SQLite database .db/.sqlite) plus the exact output formats (CSV, JSON, Excel). The resource is clearly named, so an agent can distinguish it from generic siblings like convert_data or convert_parquet 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 notes the optional 'table' argument to export a single table, which implies a use case, but gives no explicit when-to-use/when-not guidance or named alternatives (e.g., convert_data, convert_parquet) that an agent could route against. Usage is implied rather than stated.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, which already tells the agent this is a safe, non-destructive, closed-world transformation. The description adds a warning that selecting 'txt' as the target currently returns the input untouched, which is a useful behavioral quirk not present in annotations. However, it doesn't explain side effects (e.g., whether any state is persisted) or the exact return 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, well-structured sentence followed by a brief clarifying note. It is front-loaded with the tool's core capability and contains no filler words; every clause adds distinct information.

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

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

Given three required parameters, 100% schema coverage, and no output schema, the description covers the essential operational guidance: supported conversions and the explicit parameter names. It is nearly complete but lacks details on error handling or return structure, and it doesn't reference sibling alternatives.

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

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

Schema description coverage is 100%, and the schema already provides detailed parameter descriptions, enum values, and defaults. The description reinforces that fields are 'text', 'from', and 'to' and explicitly denies the existence of a 'conversion_type' field, which is a minor addition. Baseline 3 is appropriate when schema carries the bulk of parameter documentation.

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

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

The description states a specific verb (convert) and enumerates the exact format pairs supported (Markdown↔HTML, CSV↔JSON, JSON↔XML/YAML, Base64, URL encode/decode). It also distinguishes itself from the similarly named sibling convert_data by proclaiming 'there is no conversion_type field,' steering the agent away from a wrong parameter guess.

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 hints at usage through the format list and a critical caveat for Base64/URL operations, but it never explicitly says when to pick this tool over siblings like convert_data, convert_file, or analyze_encoding_detector. The guidance is implied rather than stated.

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

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

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 provide readOnlyHint=false, destructiveHint=false, and openWorldHint=false, indicating a non-destructive write operation with local scope. The description adds valuable context about free vs. Business tier limitations, format support, and preset behavior. It does not contradict annotations. Missing some detail on output format or processing time.

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

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

The description is front-loaded with the core purpose and then details formats, presets, legacy support, and tier restrictions. It is somewhat lengthy but every sentence adds useful information for an agent to select and invoke the tool correctly.

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

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

Given no output schema, the description covers what the tool does, its limitations, and parameter effects. It doesn't explain return values or output format, but it provides enough for an agent to call it correctly. The tier restrictions and preset overrides are particularly important context.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds meaning by explaining the practical implications of settings (e.g., free tier format/resolution restrictions, preset behavior, legacy format support) that complement 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 gives a specific verb (convert) and resource (video), states the goal clearly ('so it PLAYS or IMPORTS where it currently will not'), and lists formats and presets. It distinguishes from siblings like media_compress_video by emphasizing format conversion rather than compression.

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

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

The description clearly explains when to use this tool: when a video won't play or upload elsewhere. It lists supported formats and presets. However, it doesn't explicitly differentiate from sibling tools like media_compress_video or media_trim_video, leaving the agent to infer that those are for other purposes.

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?

Annotations declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the bar is lower. The description still adds that this yields a 'real, downloadable file' suitable for emailing/zipping/converting, which frames persistence and downstream consumability beyond annotations — though the CSV header row and pretty-printed JSON details are largely duplicated from 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?

Front-loads verb and resource in the first sentence, then usage, then format behavior. Slightly heavy with the eight-tool em-dash list and restated CSV/JSON details, but every sentence is oriented toward routing or output shape.

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, and the description compensates by describing the artifact produced (a downloadable file in the chosen format) and its downstream uses. Format semantics are covered, so an agent has enough to invoke it correctly; only the exact return payload/URL is 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 description coverage is 100%, so name, text and format are already fully documented (including the 80-char truncation and CSV/JSON behavior). The description's parameter-related content ('Point this at the earlier step...') restates the schema, so baseline 3 applies.

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

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

States a specific verb ('Write the result of an earlier step') plus the exact resource produced (a real, downloadable .txt/.csv/.json/.md file). An agent can distinguish this 'materialize output as a file' tool from save/convert/octopus_write siblings 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?

Explicitly says when to use it ('after any step that produces text or data rather than a file') and names the concrete upstream tools it pairs with (Colour Palette Extractor, Password Generator, Photo to Text, EXIF Viewer, Scrape Page, Word Frequency, Describe Image, PDF to Text), plus the downstream reasons (download, email, zip, convert).

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?

Even though readOnlyHint=false already signals a write operation, the description adds valuable behavioral detail: the tool writes only and cannot read, list, or search existing Drive itemsikuha. It also highlights the account-connection requirement NH the folder-creation side effect described in the folder_name parameter. This adds context beyond 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 core description is three focused sentences: purpose, usage trigger, and write-only scope. It is front-loaded and free of redundancy, aside from the trivial trailing '[category: utility]' tag. This is concise without losing key operational constraints.

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

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

For a simple uploader with one required parameter, the combination of description and schema covers the full call contract: what it does, when to use it, authentication need, write-only nature, and parameter semantics. The only absence is a return-value description, but a simple upload operation does not need one, especially without an output schema.

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

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

Schema description coverage is 100%, so the plain description does not need to explain the parameters. The description does not add anything about the file, filename, or folder_name beyond what the input schema already specifies. Per the rubric, baseline 3 is appropriate when the schema fully documents parameters.

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

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

The description says exactly what the tool does: 'Save a finished file into the signed-in user's own Google Drive.' It also explicitly scopes the tool as write-only ('Only ever writes: it cannot read, list or search anything already in their Drive'), which clearly distinguishes it from read/search siblings and storage tools.

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

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

The description gives an explicit usage scenario: '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 states a clear prerequisite: 'Needs their Google account to be connected on the Integrations page.' However, it does not name alternative tools or give a when-not-to-use statement, so it is not fully explicit about exclusions.

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

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

Addresses key traits beyond annotations: the email always goes to the connected Google account, appears in Sent and inbox, cannot target others, and cannot send custom/user-authored content. It also notes the 5 MB limit in the schema's note parameter, giving agents important constraints before calling.

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?

Well-structured with the action first, then constraints, then usage guidance; every sentence earns its place. The 'Email My File' lead-in and '[category: utility]' suffix add minor redundancy but don't 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?

Complete for a simple delivery tool: describes destination, constraints, and when to use it; annotations plus schema cover safety and parameters. No output schema is present, and a success message isn't critical to avoid misuse, so the description is sufficient but not exhaustive.

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

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

Schema has 100% coverage and already documents file, note, and subject, including the 5 MB limit and account context in note. The description reinforces overall behavior but doesn't add parameter-specific meaning beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb ('Email... to the user themselves') and resource ('a finished file'), and clearly defines the recipient as the current user. This distinguishes it from sibling tools in the file/delivery space without needing schema inspection.

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 instructs 'Use ONLY when the user explicitly asks to have a result emailed to them,' and rules out emailing anyone else or sending custom content. This leaves no ambiguity about when to invoke it vs alternatives.

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

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

Annotations 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 already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the bar is lower. The description adds the default mode and gating rules, but says nothing about whether the result is returned inline or written to a file/attachment despite readOnlyHint=false, and no rate or size behavior beyond what the schema already states.

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

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

A single compact line with the core action front-loaded, followed by the mode/parameter rules. Nothing is redundant, and the '[category: generate]' tag is standard metadata rather than filler.

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

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

With five parameters, zero required fields, and no output schema, the description supplies the critical gating rules an agent needs to call it correctly. The one remaining gap is that it never states the form of the returned art (inline text vs. file), which matters given there is no output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description goes one step further by documenting the cross-parameter conditional requirements (which parameter each mode demands), which the per-field schema descriptions and x-show-when hints only imply.

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

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

States a specific verb-and-resource pair ('Convert text or an image to ASCII art') and immediately enumerates the two operating modes, so the agent knows exactly what the tool produces. No sibling in the list overlaps this capability, and the two-mode framing makes the tool self-distinguishing.

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 conditional usage: mode 'text' (default) requires 'text', mode 'image' requires 'file'. That tells the agent which configuration to pick, but it names no alternatives or exclusions (e.g., when to prefer another generator or converter for the same input).

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 safety profile is largely covered by structured data. The description adds that the output is a PNG and that multiple symbologies are supported, but never says whether the image is returned inline or written to storage — the key behavior implied by readOnlyHint=false.

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

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

Single front-loaded sentence with the verb, resource, formats and output type; no filler. It is arguably too terse rather than bloated, which slightly suppresses the score.

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

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

No output schema exists, so the description should clarify the return shape (image bytes vs. file path/URL) — a meaningful gap for a tool with readOnlyHint=false. Parameter coverage is otherwise complete via the schema, so this is an adequate but not complete definition.

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 enum already labels every symbology with its digit requirements, so the schema carries the semantic load. The description's parenthetical format list is a partial duplicate of the enum rather than added detail.

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

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

States a specific verb+resource (generate a barcode) and the output artifact (PNG image), plus examples of supported symbologies. It does not, however, disambiguate from the sibling generate_qr_code, which matters because 'qr' is also a valid type here.

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

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

No when-to-use guidance and no alternative named. With generate_qr_code in the sibling list, an agent gets no help deciding between the two even though their scopes appear to overlap.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the output artifact types (PDF/PNG) but does not disclose the delivery mechanism — whether the file is written to disk, returned inline, or where — which is the one behavior an agent would most want here, especially with readOnlyHint=false and no output schema.

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

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

A single front-loaded sentence that states purpose, output, and inputs with no filler; the trailing [category: generate] tag is minor metadata noise but not wasteful. Very tight, though arguably minimal for a 10-parameter tool.

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

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

For a generator with 1 required parameter out of 10, full schema coverage, and no output schema, the description covers the essentials of what is produced. The main omission is how the generated artifact is returned or saved, which the absence of an output schema leaves 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 description coverage is 100%, so the schema already documents all 10 parameters in detail, including enum values, defaults, Latin-1 limitation, and hex-color formatting. The description only echoes the top-level fields (name, job title, company, contact details) without adding syntax or format meaning beyond the schema, so the baseline of 3 applies.

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

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

The description gives a specific verb (Generate), a concrete resource (printable business card), the output formats (PDF or PNG), and the key inputs (name, job title, company, contact details). No sibling tool produces a business card, so the resource alone disambiguates it from generate_qr_code, generate_barcode, generate_invoice, etc.

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 or when-not-to-use guidance and no named alternative. The reader must infer that it is used when a business card artifact is desired; nothing explains when another generate_* tool would be preferable.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the output formats (PDF/PNG), which is useful context, but does not say how the artifact is delivered (file path, download link, base64) — a real gap for a generation tool with no output schema.

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

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

A single front-loaded sentence that leads with the resource and immediately covers the output formats; nothing is padded. The '[category: generate]' tag is redundant metadata rather than substance, which keeps it from a full 5.

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

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

For a ten-parameter generation tool with no output schema, the description omits what the caller receives back and how the file is returned, which an agent needs to chain this call. Annotations cover the mutability profile, but the return-handling gap leaves it only adequate.

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

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

Schema description coverage is 100%, so all ten parameters are fully documented in the schema itself, making the baseline 3 appropriate. The description adds no parameter-level detail beyond restating the PDF/PNG option, and nothing about the required recipientName or the interaction between issuerName and issuerTitle.

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') and resource ('certificate of achievement or completion'), and names the two output formats. This is clearly distinguishable from nearby siblings like generate_invoice or generate_business_card, and no schema inspection is needed to know 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?

No explicit when-to-use, when-not-to-use, or alternatives are given, but the purpose is narrow and self-evident among the generate_* siblings, so usage is implied. It stops short of any guidance such as prerequisites or inputs required before calling.

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 establish readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that the output is a multi-file set (ico plus png sizes), which is useful, but it says nothing about how the result is delivered, whether anything is stored, or processing limits beyond the schema's 20MB note.

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 first sentence is tightly front-loaded and does the real work. The second sentence is a long, marketing-flavored explanation of what a favicon is that adds little for an agent selecting a tool, so the description is somewhat padded.

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

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

With no output schema, the description does name the returned set (ico + png sizes), and all four parameters are fully documented in the schema. The main residual gap is how the generated files are surfaced to the caller, which is left unstated for a file-producing tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description only restates the optional rounded corners and the ico-plus-png output; it adds no syntax or behavior beyond what the schema already documents for file, background, includeIco, and borderRadius.

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), resource (favicon set), the output composition (ico + png sizes), and the input (a source image) plus an option (rounded corners). An agent can distinguish it from generate_placeholder_image or generate_qr_code 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?

The second sentence explains what a favicon is and why it matters, which implies the use case, but it never states when to reach for this tool versus sibling generators nor any exclusions (e.g. square vs non-square source handling). Usage is implied rather than directed.

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

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

Annotations (readOnlyHint=false, openWorldHint=false, destructiveHint=false) already define the safety profile, so the bar is lower. The description adds genuinely useful behavior: it always returns all four digests regardless of input, there is no algorithm parameter, and bcrypt is unsupported — output-shape information the annotations do not convey.

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 resource and algorithm list, with the constraints appended immediately after. It is well-structured, though the trailing '[category: generate]' tag is metadata overhead rather than useful 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?

With no output schema and only two optional parameters, the description correctly fills the return-value gap by stating all four hashes are always returned. The main omission is sibling routing against analyze_hash, but for a zero-required-param pure-compute tool it is otherwise 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's input guidance (text or an uploaded file; 'the file wins') restates what the parameter descriptions already say, adding no new syntax, limits, or format detail.

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

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

Starts with a specific verb+resource ('Hash Generator — Compute ... hashes') and enumerates the exact algorithms produced (MD5, SHA-1, SHA-256, SHA-512). It goes further by ruling out two plausible expectations ('no algorithm selection', 'bcrypt is not supported'), which sharply bounds 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?

There is no when-to-use guidance and no mention of the obvious sibling analyze_hash, so an agent cannot tell from this text which of the two hash tools to pick. The only routing-ish information is input-related (text vs file), which is covered by the schema rather than the description.

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

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

Annotations already establish a safe, non-destructive, closed-world generator (readOnlyHint=false, destructiveHint=false, openWorldHint=false). The description adds genuinely useful context beyond them: the required JSON-body invocation contract with camelCase keys, and that the output is a rendered PDF. It stops short of describing where the PDF is delivered or any size/limit constraints.

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

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

Three short sentences, front-loaded with the core purpose before the invocation detail. Only the '[category: generate]' metadata tag is low-value noise in an otherwise efficient 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 15-parameter tool with no output schema, the description states the output type (PDF invoice) and the invocation contract, which is enough for an agent to call it correctly. It omits how the resulting PDF is returned (download link, file path, inline bytes), which is a minor gap given the otherwise complete picture.

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 per-field schema text is highly detailed (required flags, print-only behavior, enum, defaults), so the description does not need to carry parameter meaning. The only added value is the camelCase convention hint, which is marginal since field names already show 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 gives a specific verb and resource: 'Generate a professional PDF invoice from line items, client details, and company info.' It also names the output medium (PDF) and category. However, it does not explicitly distinguish itself from the many other generate_* siblings (business card, certificate, barcode), relying on the unique resource name to differentiate.

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 an implicit usage note about invocation format ('Takes a JSON body (camelCase fields), not form fields'), which tells the agent how to call it. But there is no explicit when-to-use/when-not guidance and no named alternatives, leaving usage largely implied by the invoice 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 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?

Annotations already declare destructiveHint=false, openWorldHint=false and readOnlyHint=false, covering the safety profile. The description adds one genuinely useful behavioral claim — that the output is cryptographically secure — which the annotations do not convey. It says nothing, however, about determinism, whether generated values are persisted, or what is actually returned when count > 1.

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 states the action, the security property, and the configurability, plus a short category tag. Nothing is padded and the most important information comes first.

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

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

With no output schema and seven parameters, the description should ideally sketch what comes back (e.g., an array of passwords sized by count) and note the secure-randomness guarantee's practical implications. It covers the essentials for calling the tool but leaves the return shape implicit; the singular 'a password' wording also sits slightly awkwardly against count up to 50.

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

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

Schema description coverage is 100%, so every one of the seven parameters is already documented in detail by the schema. The description only restates two parameter concepts ('length and character sets') without adding format, range, or exclusion semantics, so the schema carries the weight and 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 names a specific verb ('Generate') and resource ('random password') and adds a qualifier ('cryptographically secure random password with configurable length and character sets'). The resource is unambiguous and naturally distinct from siblings like generate_hash or generate_qr_code, though no sibling is named explicitly.

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

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

Usage is only implied: the mention of 'configurable length and character sets' tells the agent the tool is parameterizable, but there is no statement of when to reach for this tool versus alternatives (e.g., generate_hash) or any preconditions. For a self-evident generator this is tolerable, but it is not explicit guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the agent knows this produces rather than reads. The description adds nothing behavioral: it does not say a file is written, where it is written, or what is returned. "Any dimension" also overstates behavior the schema explicitly clamps at 4096, though this is a schema understatement rather than an 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?

A single front-loaded sentence that names the resource first and then the configurable attributes, with no filler beyond the trailing category tag. Efficient, though the category tag adds little for selection.

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 generation tool with no output schema, the definition is minimally viable: purpose is clear and all parameters are covered by the schema. The notable gap is the result side — where the generated image goes and what the caller receives — which matters because nothing else in the structured data supplies 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 width, height, text, bgColor and fgColor are all documented in the schema; the description only restates dimensions, background colour and label text and omits fgColor and format. With the schema doing the heavy lifting, 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+resource ("Generate a placeholder image") and names the attributes it can vary (dimension, background colour, label text), which is enough to separate it from siblings like generate_qr_code or generate_favicon. It never explicitly names or contrasts an alternative, so it stops short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as generate_favicon or photo_resize when an image already exists. The "any dimension / custom colour / label" phrasing only hints at the 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 provide readOnlyHint=false and destructiveHint=false, which already signal that this is a non-destructive operation. The description adds the output format (PNG) but says nothing about whether the image is returned inline, saved to a path, or how large the payload might be. With annotations only covering the basic safety profile, more behavioral context would be expected.

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 covers purpose, inputs, and output format without filler. The bracketed category tag at the end is administrative noise rather than useful description content, keeping it from a 5.

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

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

For a simple generate tool with only three parameters and full schema coverage, the description covers the essentials. However, with no output schema to explain the return value and no annotations beyond basic safety hints, the description should say more about what the agent receives back.

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

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

Schema description coverage is 100%, so all three parameters (content, size, level) are documented in the schema itself. The description marginally reinforces the content parameter by listing accepted input types, but adds no syntax or format guidance beyond the schema. Baseline 3 is appropriate 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 clear verb+resource (generate a QR code) and enumerates the accepted input types (URL, text, vCard) plus the output format (PNG). It does not explicitly differentiate itself from the sibling generate_barcode, which is the nearest competitor, 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 guidance, no mention of prerequisites, and no routing to alternatives such as generate_barcode. The description only says what the tool produces, leaving the agent to infer selection criteria.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, and the description is consistent with them. However, the description itself discloses nothing beyond safety: it omits that the operation requires a full H.264 re-encode, that output is a new MP4 with audio copied, and that it is one of the slowest operations (the schema carries that detail, so the description gets no credit for 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?

A single front-loaded sentence with the resource, mechanism, and controls in order, plus a harmless category tag. Nothing is padded, though it is arguably under-specified rather than optimally 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 five parameters, 100% schema coverage, and no output schema, the description covers the essentials an agent needs to select the tool, but it leaves the result shape and processing cost unstated at the description level. Adequate but not complete for a re-encoding media mutation.

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 file, text, opacity, fontsize, and position, including units, defaults, and edge behavior. The description only gestures at 'position and opacity control' and adds no syntax or constraints beyond what is already structured, which is the baseline 3 case.

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

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

The description states a specific verb and resource ('Overlay a text watermark onto a video'), names the mechanism (FFmpeg), and scopes the controllable knobs (position and opacity). It is clearly a video-domain complement to the pdf_watermark and photo_watermark siblings without naming them, so it is a strong but not fully differentiated statement of purpose.

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

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

There is no when-to-use guidance, no prerequisites, and no pointer to alternatives such as photo_watermark or pdf_watermark for other media types. An agent must infer the usage context entirely from the tool name and the word 'video'.

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.

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

The description states a specific verb-resource pair ('Compress Video') and explains the outcome (reduce file size) and method (H.264 re-encoding with FFmpeg). It is easy to tell apart from convert_video and media_trim_video, though it does not explicitly name 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 phrase 'Reduce video file size' implies the obvious use case, but there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives. In a large media/convert sibling set, an agent gets limited help choosing between this and convert_video or other compression tools.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the available output formats as context but says nothing about where the resulting file is written or that a new artifact is produced, so it stays at a baseline 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?

A single front-loaded sentence that leads with the verb and resource, with no wasted clauses. The trailing '[category: media]' tag is minor noise but does not impair readability.

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 full schema coverage this is largely complete, but with no output schema the description should ideally state what is returned or where the extracted audio is saved. It leaves that gap for what is a file-producing (non-read-only) operation.

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

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

Schema description coverage is 100%, and the schema already documents both parameters, including the re-encode-never-copy behavior. The prose format list merely restates the enum, adding no syntax or constraint detail beyond structured data, 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 audio track from a video file') and enumerates the output formats, so the tool's function is unambiguous. However, it does not differentiate itself from close siblings like media_merge_audio, media_trim_audio, or media_mute_video, which an agent could confuse for audio-track operations.

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

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

The description gives no when-to-use guidance, prerequisites, or alternatives; usage is only inferable from the name. In a sibling set containing media_merge_audio and media_trim_audio, the absence of any routing cues leaves genuine ambiguity about which audio tool applies.

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 state readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds the return packaging ('returned as a ZIP') which is real behavioral value given there is no output schema, but it says nothing about size/time limits, frame-count caps, or what happens on very long videos.

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 wastes nothing; the only filler is the name echo and the '[category: media]' tag. Efficient, though not maximally information-dense.

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 three-parameter extraction tool with full schema coverage and annotations, the description covers what is extracted, in what format, and how it is returned (ZIP of JPEGs), which substitutes for the absent output schema. The gap is routing guidance against the many media/pdf/image siblings, which the description never addresses.

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 parameter docs are unusually good (fps min/max semantics, max frames, the explicit 'no PNG option' note). The description only alludes to 'a specified frame rate' and adds nothing the schema does not already say, 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?

Specific verb+resource combination ('Extract frames from a video') with an explicit qualifier ('at a specified frame rate') and output format (JPEGs in a ZIP). It is clearly distinguishable from siblings like convert_video or analyze_video by the framing of its output, but it never names an adjacent tool to route the agent, so it stops short of a 5.

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

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

There is no when-to-use guidance, no exclusion (e.g. 'does not decode audio'), and no pointer to alternatives such as analyze_video, media_trim_video, or media_compress_video. Usage is only implied by the verb.

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

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

Annotations already indicate the operation is not read-only and not destructive. The description adds that the output is MP3 and that FFmpeg is used, but it does not disclose side effects, mixed-format handling, or output delivery behavior. This is a modest addition beyond annotations, not comprehensive.

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 essential constraint front-loaded and a useful category tag. There is no filler or redundant explanation.

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 tool with annotations and a fully descriptive schema, the description provides enough information to invoke the tool correctly. A note about output/return behavior or ordering would make it fully complete, but 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 schema already documents the files parameter fully, including accepted formats and the at-least-2 constraint. The description only restates 'at least 2' and adds no new parameter-level semantics, 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 identifies the operation (merge/concatenate), the resource (multiple audio files), the minimum count (at least 2), and the output format (one MP3 via FFmpeg). This distinguishes it well from sibling tools like media_trim_audio and media_extract_audio.

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