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

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses important security behaviors ('Paths like "../.." are defused', 'an archive that expands out of all proportion to its size is refused') and input constraints ('Accepts application/zip, application/x-zip-compressed, .zip; up to 100 MB per file'). This adds valuable context beyond the schema, though it doesn't cover all possible behaviors like error handling.

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

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

The description is brief and front-loaded, starting with the core action. However, there is slight redundancy: 'Unzip files. Get the files out of an archive.' conveys the same idea twice. The rest is focused and to the point, making it mostly efficient.

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

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

For a simple tool with two parameters and no output schema, the description provides sufficient context: purpose, accepted formats, size limit, and security features. The outputDir parameter's behavior is documented in the schema. It doesn't explain extraction details like folder structure preservation, but this is not critical for a basic unzip 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%, with both parameters (paths, outputDir) having descriptive text. The tool description does not add additional meaning to the parameters themselves; its mention of file types and size limits relates to the input domain, not parameter semantics. Baseline 3 is appropriate since the schema already documents the parameters well.

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 starts with 'Unzip files' and 'Get the files out of an archive', clearly stating the tool's action and resource. It distinguishes itself from sibling archive_zip (which zips) and other file converters, making the purpose unambiguous.

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

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

The description provides a clear usage context: unzip files. It does not explicitly mention alternatives or when not to use, but the tool's name and siblings make the intended use obvious. No exclusions are stated, so this is a clear context without explicit alternative guidance.

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

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

With no annotations, the description carries the full burden. It discloses important traits: processing happens in the browser (files never reach a server), accepts any file type (*/*), and has a 100 MB per-file limit. This adds behavioral context beyond the schema, though it doesn't detail side effects on source files or output 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 very concise, with four short sentences each adding value: purpose, use case, privacy, and limits. It is front-loaded with 'Create a ZIP' and wastes no words.

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

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

For a simple tool without an output schema or annotations, the description covers the core purpose, a key use case, privacy, and file size constraints. It doesn't explain where the output goes (schema covers outputDir) or return value, but these are not critical for such a basic operation.

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

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

The schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds a bit of context (e.g., 'put several files into one archive' hints at paths) but does not explain level or outputDir beyond what the schema already states.

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 'Create a ZIP' with a specific verb and resource. It also explains the purpose (bundling files for a single attachment) and distinguishes itself from siblings like archive_unzip by focusing on creation rather than extraction.

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

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

The description implies a clear use case (sending multiple files as one attachment) and provides context such as browser-based processing and file size limits. It does not explicitly mention alternatives or exclusions, but the context is sufficient for this simple tool.

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

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

With no annotations, the description carries the transparency burden. It discloses accepted input types (audio/*, .m4a, .opus, .aac, .wma) and the 200 MB per-file size limit, but does not mention side effects like whether original files are preserved, output location behavior, or error handling. This is adequate but not fully transparent.

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

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

The description is three sentences and mostly front-loaded. The first sentence has minor redundancy ('Audio converter' followed by 'Convert audio'), but the rest is efficient, providing key options and constraints without fluff.

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

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

For a tool with 6 parameters and no output schema, the description covers the essential input constraints, format options, and file size limit. It omits output-directory behavior, but that is documented in the schema. The description is reasonably complete for the tool's complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explicitly explaining the purpose of bitrate, mono, and sample rate options ('Pick a bitrate, drop it to mono, change the sample rate'), and the input format/size constraints for paths. This goes beyond the schema's field-level descriptions.

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

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

The description clearly states the tool's purpose with a specific verb ('Convert') and resource ('audio between MP3, AAC, OPUS, FLAC, WAV and OGG'). It distinguishes itself from sibling audio tools like audio_extract or audio_trim by focusing on format conversion.

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

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

The description provides clear context for when to use the tool—whenever audio format conversion is needed—and lists supported formats. It does not explicitly mention alternatives or exclusions, but sibling differentiation is implicit through the conversion-focused wording.

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

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

No annotations are provided, so the description carries the burden. It discloses a lossless guarantee when the track is lifted as-is, and gives format/size constraints. However, it does not mention what happens to original files or the behavior when re-encoding is required (e.g., potential quality loss), leaving gaps.

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

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

Three sentences, front-loaded with purpose. The second sentence ('Pull the soundtrack out of a video file') is a redundant restatement of the first, which wastes a sentence. The third sentence adds useful constraints, keeping it otherwise concise.

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

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

For a 4-parameter tool with 100% schema coverage, the description adds critical constraints (supported formats, size limit) and a lossless note. It lacks details on output naming or side effects, but those are not required given the schema and straightforward nature.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides; the lossless note mirrors the 'format' parameter description. The size limit is an input constraint, not a parameter semantic.

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

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

The description clearly states 'Extract audio from video', a specific verb and resource. It also lists supported video formats, which differentiates it from audio-only tools like audio_convert and video processing 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 makes clear it accepts video files only, implying when to use it. However, it does not explicitly name alternatives or exclusions, such as using audio_convert for audio files. The format list provides context but no explicit when-not.

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

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

With no annotations, the description must carry the transparency burden. It does disclose a key behavior—matching files are joined without re-encoding, instantly and losslessly—and lists accepted formats and size limits. However, it omits what happens when files do not match (presumably re-encoding) and does not mention whether original files are modified or how output is named. These gaps prevent a higher score.

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

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

The description is remarkably concise: three sentences that front-load the core purpose, then add key behavioral details and constraints. Every sentence earns its place—there is no fluff, repetition, or unnecessary jargon. This is an exemplary structure for a tool 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 merge tool with four parameters and no output schema, the description covers the essential aspects: what it does, when it is lossless, and what inputs are acceptable. It does not explain the re-encoding fallback behavior or output naming, but the schema covers parameter defaults and non-overwrite behavior. Overall, it is sufficiently complete for an agent to select and invoke the tool.

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

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

The input schema already describes all parameters (100% coverage), so the baseline is 3. The description adds meaningful context: it clarifies that the order in 'paths' matters ('in the order you picked') and specifies accepted file types and size limits, which inform valid values for 'paths' and 'format.' This extra semantic value justifies a 4.

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

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

The description opens with 'Merge audio' and then specifies the result: 'Join several recordings into one, in the order you picked.' This clearly states the verb, resource, and outcome, making it distinct from sibling tools like audio_convert or audio_trim. The purpose is immediately understandable and not a tautology.

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

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

The description clearly indicates the intended use case: joining multiple recordings in a chosen order. It also provides constraints (accepted formats, size limit) that help decide if the tool is appropriate. However, it does not explicitly mention alternatives or include a 'when not to use' statement, so it stops short of a full 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?

With no annotations provided, the description carries the behavioral disclosure burden. It adds useful detail about the two-pass processing and the EBU R128 standard, but does not disclose whether original files are modified, what the output structure is, or any side effects. The outputDir parameter hints at new files, but the main description lacks a clear statement about in-place vs. new-output 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 two sentences, front-loaded with the primary action, and every clause adds value. It covers the standard, two-pass behavior, accepted formats, and size limit without unnecessary words.

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

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

Given the lack of an output schema and annotations, the description should clarify what the tool returns or produces. It implies normalized output files but does not state return values, error behavior, or whether multiple files are processed in one call. The parameter schema fills some gaps, but return semantics remain unclear.

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

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

Schema coverage is 100% with descriptive parameter details for target, truePeak, and outputDir. The description does not add much beyond the schema, but the baseline of 3 is appropriate because the schema already provides sufficient semantics for each parameter.

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

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

The description states a specific verb ('Normalize loudness') and identifies the resource (audio files) and the standard (EBU R128). It distinguishes from sibling audio tools by focusing solely on loudness normalization, not conversion, extraction, trimming, or merging.

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

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

The description implies the tool is used for loudness normalization but does not explicitly state when to use it over alternatives or provide exclusions. It provides input constraints (formats, size) but no guidance on selecting between audio tools or when not to use normalization.

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

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

With no annotations, the description carries the full burden. It discloses the key behavioral trait that internal pauses are preserved and specifies accepted file types and size limits. However, it does not mention how output files are handled (e.g., whether originals are modified, naming conventions) or what the tool returns. The schema covers outputDir, but the description lacks side-effect disclosure.

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

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

The description is front-loaded with the core purpose, and each sentence adds value: the first identifies the action, the second specifies scope, the third justifies the behavior, and the fourth lists input constraints. The first two sentences are mildly redundant but not overly verbose.

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

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

For a tool with no annotations or output schema, the description covers the primary behavior and input constraints but leaves gaps around return values and potential side effects on original files. The schema compensates for outputDir and 'never overwritten', but the agent still lacks clarity on what the tool returns after processing.

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

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

Schema coverage is 100%, with all four parameters having informative descriptions. The tool description adds no parameter-specific meaning beyond the schema; it only restates the overall purpose and input constraints. Baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description states 'Trim silence' and specifies cutting silence at the start and end of a recording, which is a specific verb+resource+scope. It distinguishes from sibling audio_trim by explicitly noting internal pauses are left alone, making the tool's purpose unmistakable.

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

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

The description clearly implies when to use this tool: for removing edge silence while preserving internal pauses. It does not explicitly name alternatives or exclusions, but the behavioral distinction (internal pauses untouched) provides clear context without needing to mention other 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?

With no annotations provided, the description carries the burden of disclosing behavior. It states that the audio itself is copied untouched (non-destructive) and 'takes no time', which is valuable behavioral context. It also specifies accepted MIME types and file size limit. It does not mention side effects related to 'clear' or output directory, but those are covered in the schema, so this is a solid disclosure.

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

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

The description is three short sentences: first states the main purpose, second adds a key safety and performance trait, third lists accepted formats and size limit. Every sentence earns its place, and the most important info is front-loaded. No filler or redundancy.

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

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

Given the tool's complexity (7 params, required paths, no output schema), the description covers input constraints (formats, size) and non-destructive behavior, which helps an agent decide when to use it. It does not explain return values or results, but the schema covers outputDir behavior, and the tool is straightforward. Slightly more detail about batch processing (paths array) would be helpful, but not critical.

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

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

The input schema has descriptions for all 7 parameters (100% coverage), so the baseline is 3. The description adds marginal value by naming 'title, artist and album' as examples of editable tags, but does not explain relationships, provide examples, or clarify ambiguity beyond what the schema already offers. Thus it hits the baseline without exceeding 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 opens with 'Edit audio tags', clearly stating the tool's purpose with a specific verb and resource. It further specifies 'Change the title, artist and album', which distinguishes it from sibling tools like audio_convert or audio_trim that manipulate audio content rather than 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: it is for editing tags, not altering audio content, and emphasizes the audio is 'copied untouched' so nothing is lost and it is fast. It also lists accepted formats and size limits, offering practical constraints. However, it does not explicitly mention alternatives or when not to use this tool (e.g., for actual audio processing), so it misses the explicit exclusion criteria for 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It adds useful context: 'By default the stream is copied, so the cut costs no quality' and format/size limits. However, it does not disclose output behavior (e.g., whether new files are created, how results are returned) or the impact on original files, which the parameter descriptions partially cover.

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 three sentences long, with the primary purpose front-loaded, followed by a key behavioral detail and then constraints. Every sentence contributes meaning, and there is no redundant or vague 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 tool with six parameters and no output schema, the description gives sufficient context for the agent to understand the operation: trimming audio fragments. Parameter descriptions fill in details like start/end format and output directory behavior, but the description does not mention return values or batch processing nuances, though these are reasonably inferable from the schema.

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

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

Schema description coverage is 100%, as all six parameters have descriptions. The tool description itself adds no additional parameter semantics 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 clearly states the tool trims audio by cutting a fragment out of a recording using timecodes. It specifies the verb 'trim' and resource 'audio', and the focus on timecode-based cutting distinguishes it from siblings like audio_silence-trim and video_trim.

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 about what the tool does and its constraints (e.g., stream copy, accepted formats, 200 MB limit), but it does not explicitly mention when to use this tool over alternatives or provide exclusions. This corresponds to clear context without exclusions, hence a 4.

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

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

With no annotations, the description carries the transparency burden. It reveals useful behavioral traits: runs in the browser, keeps data local, robust parsing for commas/line breaks, and a 20 MB file limit. However, it omits output behavior, such as whether files are written to outputDir and that existing files are never overwritten, leaving gaps in side-effect disclosure.

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

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

The description is very concise, fitting key information into two sentences and a leading fragment. It front-loads the core purpose and includes constraints without waste, making it easy to scan.

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 conversion tool, the description covers input formats, size limit, parser behavior, and privacy, but it lacks any explanation of return values or output behavior. Since there is no output schema, the description should note whether results are returned or written to files, which is a notable gap.

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

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

Schema description coverage is 100% for all three parameters, setting a baseline of 3. The description adds some value by listing accepted MIME types and file size limits, which relate to 'paths', but it does not elaborate on 'format' or 'outputDir' beyond what the schema already states.

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

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

The description clearly states the tool converts tabular data between CSV, JSON, and YAML formats, using a specific verb ('Convert') and resource ('a table'). It also distinguishes itself from sibling conversion tools by naming the exact data formats and mentioning browser-side execution.

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: for converting tabular data between CSV, JSON, and YAML, with format and size constraints. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for selection among sibling tools.

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

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

No annotations are provided, so the description carries the burden of disclosing behavioral traits. It does mention a file size limit (50 MB) and claims layout preservation, which adds some context. However, it does not describe output behavior, error handling, permissions, or whether files are overwritten (though the schema does mention existing files are never overwritten). The disclosure is partial.

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 front-loads the core purpose ('Documents to PDF') and then provides a structured list of supported formats and size limit. It is somewhat lengthy but every sentence contributes useful technical detail, and the organization makes it easy to scan. It earns a solid 4.

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

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

The tool has 3 parameters with full schema coverage, but no output schema. The description explains input formats and constraints but does not describe what the tool returns (e.g., whether it returns a list of generated PDFs, or how success is indicated). It also does not clarify default output location beyond what the outputDir schema states. The description leaves gaps in output behavior, making it adequate but not 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 value by specifying accepted file formats and the 50 MB limit, which enriches understanding of the 'paths' parameter. However, it does not clarify the 'archival' or 'outputDir' parameters beyond the schema's own descriptions, so it does not significantly exceed the baseline.

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

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

The description clearly states the tool converts documents to PDF, enumerates supported input formats (Word, Excel, PowerPoint, OpenDocument, RTF, TXT), and distinguishes it from sibling conversion tools like image_convert or video_convert. The verb+resource pair 'Documents to PDF' is specific and actionable.

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

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

The description provides clear context by listing accepted formats and the 50 MB limit, implying when to use this tool. However, it does not explicitly state when not to use it or mention alternatives among sibling tools, such as pdf_from-image for images or data_convert for other formats. Usage guidance is implied rather than 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?

With no annotations, the description carries the burden. It discloses the main behavior (conversion to PDF, compression), the accepted formats, and the 50 MB file size limit. It does not explicitly state whether originals are preserved or results are written to outputDir, but the transformation is clearly described.

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 behavior, then lists accepted formats and size limits. The format list is long but necessary; it is clearly separated and not redundant overall. The structure is logical and efficient.

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

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

Given no output schema and a simple 2-parameter tool, the description adequately covers what the tool does, accepted inputs, and constraints. It does not explain output return values, but for a file conversion tool, the output is typically written to files, which is partially covered by the schema. It is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds value beyond the schema by specifying acceptable file types (MIME types and extensions) and the 50 MB limit, enriching the meaning of the 'paths' parameter. No extra detail on outputDir is needed since the schema describes it.

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

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

The description clearly states the tool's purpose: converting Word, Excel, PowerPoint (and other document formats) to PDF and compressing them for email. It specifies the exact transformation (becomes a PDF and is compressed) and distinguishes from sibling tools like document_convert and pdf_compress by focusing on email readiness.

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

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

The description implies usage context ('for sending', 'fits through mail') and lists accepted file types and size limits, which guides when to use the tool. It does not explicitly name alternatives or state when not to use it (e.g., for already-PDF files), but the context is clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses accepted formats and the 50 MB file limit, which is useful. However, it omits whether original files are preserved or overwritten, and does not describe output behavior, leaving some ambiguity for a compression tool.

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

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

The description is two sentences, front-loaded with the main action, and contains no redundant wording. Every word adds value, making it highly concise and well-structured.

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

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

Given the rich schema covering all 6 parameters and the tool's moderate complexity, the description provides enough context for selection and invocation. It lacks details about return values, but the schema and annotations (or their absence) do not require further explanation.

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% parameter coverage with descriptive fields, so the baseline is 3. The description only broadly refers to 'size limit or quality', which maps to existing parameters (targetKb and quality), adding little 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 identifies the tool's function with a specific verb ('compress') and resource ('image'), and differentiates it from siblings like image_resize or image_convert by mentioning compression both to a size limit and by quality. This makes the purpose unambiguous.

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

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

The phrase 'Handy when a form refuses a large file' provides a concrete use case, making it clear when to use this tool. It does not explicitly name alternatives, but the context is sufficient for an agent to distinguish it from related 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?

With no annotations provided, the description carries the full burden. It discloses accepted inputs, size limits, and the ability to resize/strip EXIF, but omits crucial side effects like output location, whether original files are modified, and overwrite behavior. Moreover, listing HEIC as a target format contradicts the schema's enum (jpeg, png, webp, avif, tiff), adding confusion.

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

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

The description is compact, front-loaded with 'Image converter,' and every sentence adds information. It is appropriately sized for the tool's complexity, avoiding fluff. The redundancy of 'Image converter' and 'Convert images' is minor and does not harm 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?

The tool has six parameters with a nested object, no output schema, and no annotations. The description fails to explain return values, output handling, or side effects, and the format contradiction creates a gap. It provides some input constraints but is incomplete for a conversion tool of this complexity.

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

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

Schema coverage is 100%, so baseline is 3, but the description provides contradictory information about the format parameter by including HEIC, which is not in the schema enum. It does add useful context for paths (accepted types/size) and resize/stripMetadata, but the misleading format list diminishes reliability.

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

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

The description clearly states the tool converts images between specific formats (JPG, PNG, WebP, AVIF, HEIC), using a specific verb+resource. This distinguishes it from siblings like image_resize or image_compress, even though the format list conflicts with the schema enum (which includes tiff instead of heic).

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 through the phrase 'Image converter' and the file type/size constraints ('Accepts image/*, .heic, .heif, .avif; up to 50 MB per file'). However, there is no explicit guidance about when to use this versus alternatives like image_resize or image_compress, nor any 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It adds important context not in the schema: accepted file types ('image/*, .heic, .heif, .avif'), file size limit ('up to 50 MB'), and the 'Nothing gets scaled down' behavior. This goes beyond the schema, though it does not mention output file handling, which is already covered by schema descriptions.

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

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

The description is three concise sentences. It leads with the action, provides clarifying examples, states a key behavioral constraint, and lists input constraints — every sentence earns its place. No filler or redundancy.

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

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

For a tool with 6 parameters, no annotations, and no output schema, the description provides a solid overview of purpose, behavior, and input constraints. Combined with the schema's detailed parameter descriptions, it is sufficiently complete for an agent to understand and invoke the tool correctly. It stops short of covering edge cases (e.g., what happens when the source is smaller than the aspect), but that is not essential.

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 enriches the aspect parameter by giving practical examples ('square for an avatar, 16:9 for a cover') and clarifies input file type expectations that relate to the paths parameter. This adds semantic value beyond the schema.

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

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

The description opens with 'Crop image' — a specific verb and resource. It further clarifies the operation with 'Cut a photo to a ratio' and gives concrete use cases ('square for an avatar, 16:9 for a cover'). The explicit 'Nothing gets scaled down' differentiates it from sibling tools like image_resize, so purpose is unmistakable.

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 suitable use cases through examples (avatar, cover) and notes that no scaling occurs, which suggests use over image_resize for cropping needs. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide any 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?

The description discloses the key behavioral traits: it strips geotag and camera data, resizes to 1600px long side, and encodes WebP. It also discloses accepted file types and size limits. There are no annotations to lean on, so the description carries full burden; while it doesn't explicitly say original files remain unchanged, the conversion language implies new output files.

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 three sentences long and front-loads the core purpose ('Photo for a website'). Each sentence adds distinct information: purpose, operations, and input limits. No filler or 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 fully captures the tool's main behavior: input, transformation, and output format. It handles the lack of an output schema by describing the output as WebP with a 1600px long side, and it notes privacy-sensitive data stripped. Combined with a high-coverage schema, the description is contextually 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% for both parameters (paths and outputDir), so the schema already defines them. The description adds no additional parameter semantics beyond showing that files are processed; it doesn't refine the meaning of 'paths' or 'outputDir.' 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 specific action verbs 'strips', 'fits', and 'encodes' with a clear resource ('Photo for a website'). It distinguishes from sibling tools by combining metadata removal, resizing, and WebP conversion into one operation, explicitly called out as 'one step instead of three settings'.

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 tells the agent when to use this tool: whenever a photo needs to be prepared for a website, it provides the combined operation. It also states input constraints (image/*, .heic, .heif, .avif; 50 MB max), which helps the agent decide if the tool is applicable. However, it doesn't explicitly name alternative tools or state when not to use it, aside from implying the combined need.

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

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

With no annotations provided, the description discloses that files are cleaned byte-by-byte without altering the picture itself, which is valuable. But it omits key behaviors such as whether output is written to new files or overwrites originals, and what the return value is. This is a significant gap for a tool with no annotations.

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

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

The description is compact, with two sentences that front-load the main purpose and then provide key constraints. Every sentence adds information without waste, making it highly 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?

The description covers the core action, supported formats, and size limit, but it does not mention the tool's output or return value, which is essential given no output schema exists. It also omits the effect of the keepIcc parameter. While sufficient for the main task, it leaves notable gaps.

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

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

All three parameters have descriptions in the schema (100% coverage), so the schema documents them thoroughly. The description adds no additional parameter-specific meaning; it only reiterates the overall action. Thus it meets the baseline but provides no extra value.

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

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

The description clearly states the tool's function with a specific verb ('Remove') and resource ('EXIF and location'), and lists the exact data stripped (camera model, date, coordinates). This distinguishes it from sibling tools which handle conversion, compression, resizing, etc., none of which deal with metadata removal.

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 about supported formats (image/*, .heic, .heif, .avif) and a size limit (50 MB), which helps an agent decide when to use the tool. However, it does not explicitly compare it to alternatives or state exclusions, but the uniqueness of the purpose makes it obvious enough.

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

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

With no annotations, the description carries the full burden. It discloses that processing happens in the browser (privacy), accepted file types and size limit, and output format (CSS variables). It does not mention file-writing behavior or overwrite policy, but those are partially covered in the schema, and the description provides solid 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 concise and front-loaded. Three sentences cover purpose, output, privacy, formats, and size limit without unnecessary words. Every sentence adds value.

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

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

For a simple 3-parameter tool with no output schema, the description is quite complete. It explains the core operation, output format, operational context (browser), and limitations. It lacks explicit mention of output file creation and overwrite behavior, though the schema covers that, so overall completeness is strong.

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 context about output being CSS variables and file constraints, but does not fundamentally enhance the parameter meanings already provided in the schema. It meets the baseline without exceeding it.

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

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

The description clearly states the tool's function: extracting a colour palette from an image and producing CSS variables. It uses a specific verb ('pull') and resource ('colours out of a picture'), distinguishing it from sibling tools like image_metadata or image_convert.

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

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

The description implies usage context (e.g., privacy-focused because it runs in the browser, supported formats, size limit) but does not explicitly contrast with alternatives or state when to use this tool over others. It gives clear context but no exclusions or alternative mentions.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It mentions input constraints (formats, 50 MB limit) and a no-enlargement behavior, but fails to explain output handling, such as whether original files are modified or new files are created. This is a significant gap for a resizing tool.

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

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

The description is short and mostly efficient, with purpose front-loaded. However, 'Change the dimensions of a photo or picture' is redundant with 'Resize image,' adding a bit of filler. Still, the rest of the sentences provide meaningful constraints, so it earns a high score for conciseness.

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

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

Given the tool has 7 parameters and no output schema, the description provides core purpose and key constraints (formats, size limit) but omits workflow specifics like output directory behavior (covered in schema) and multi-file handling. It is adequate but not fully comprehensive for a tool with this complexity.

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

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

The input schema covers all parameters with descriptions, but the tool description adds valuable information not present in the schema, including accepted file types and the 50 MB size limit. It also clarifies the default 'fit' behavior with 'without enlarging.' This enriches understanding beyond the structured 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 'Resize image' with a specific verb and resource, and elaborates 'Change the dimensions of a photo or picture.' This distinguishes it from sibling tools like image_crop and image_rotate, which handle different 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 implies a use case through 'Fits within your numbers without enlarging' and notes accepted formats and size limits, but it does not explicitly compare to alternatives or state when not to use this tool. It offers contextual guidance but no clear exclusions or alternative references.

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

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

No annotations are provided, so the description must convey behavioral traits. It mentions accepted formats and the 50 MB size limit, which is helpful. However, it does not disclose whether original files are modified, where output files are written, or that existing files are never overwritten (the latter appears only in the schema's outputDir description). This is a partial but incomplete behavioral picture.

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 four short sentences that front-load the verb and resource, then add concrete details on angle options, a relatable use case, and input constraints. No unnecessary words or repetition.

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

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

The tool has 6 parameters and no output schema. The description covers the core functionality and input constraints, but leaves out output behavior (how results are returned or saved) and whether multiple files are processed independently. The schema provides some of this via the outputDir description, but the description alone is not 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 schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds context beyond the schema by specifying accepted input formats (image/*, .heic, .heif, .avif) and a per-file size limit (50 MB), which helps agents select valid input files. It also confirms the typical rotation angles from the angle enum.

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

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

The description explicitly states 'Rotate image' and details rotation by 90/180/270 degrees or mirroring, which clearly distinguishes it from sibling tools like image_convert, image_resize, and image_crop. The use case 'Sideways phone shots get fixed' further clarifies the intent.

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 a clear use case ('Sideways phone shots get fixed') and scope (rotation/mirroring), but it does not explicitly mention when to use this tool instead of alternatives or when not to use it. The purpose is clear enough for an agent to infer usage, but there is no direct comparison to sibling tools.

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

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

With no annotations, the description carries the disclosure burden and does well: it reveals the compression method (re-encoding images), the fallback behavior ('If the result is not meaningfully smaller, you get the original back — untouched'), and a hard input limit ('up to 100 MB per file'). It does not mention output naming or permissions, but the added behavioral detail is substantial beyond a simple 'compress' statement.

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

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

Only two sentences, front-loaded with the action. Each clause adds useful information (method, fallback, input constraints) without redundancy or fluff. Excellent conciseness.

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 tool with full schema coverage and no output schema, the description covers the core purpose, processing approach, fallback output, and size limits. The schema already details preset, grayscale, and outputDir. Minor gaps like explicit output file naming do not significantly detract from completeness.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable constraints for the paths parameter by stating accepted MIME/extension (application/pdf, .pdf) and maximum file size (100 MB), which are not present in the schema. This extra clarification justifies a higher score.

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

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

The description opens with 'Compress PDF', a specific verb+resource pair, and explains the mechanism ('re-encoding the images inside it'). This clearly distinguishes it from sibling PDF tools like pdf_merge and pdf_split, as well as image_compress/video_compress which target different resource types.

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

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

The intended use is clear: compress a PDF to make it lighter. It also implies suitability for image-heavy PDFs via 're-encoding the images inside it'. However, it does not explicitly name alternatives or exclusions, so context is present but not exhaustive.

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

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

With no annotations provided, the description carries the full burden. It adds useful behavioral context: accepted formats (image/*, HEIC, HEIF, AVIF), a 50 MB per-file limit, and preservation of selected order. However, it does not disclose output-side behavior such as file naming, default output directory, or overwrite prevention (though overwrite is noted in the schema). Thus it adds some context but is 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 two concise sentences, front-loaded with the purpose ('Images to PDF') followed by concrete details. No filler or redundant content; every clause adds value (order preservation, HEIC support, file types, size limit).

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

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

Given the tool's moderate complexity (5 params) and full schema coverage, the description is largely complete: it specifies input constraints and ordering behavior. It does not explain return values, but no output schema exists and it is not essential for a conversion tool. The schema handles parameter-level details, and the description adds enough context 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 coverage is 100%, so the baseline is 3. The description adds extra meaning for the paths parameter by specifying supported image formats and the per-file size limit, which are not in the schema. This enhances the agent's understanding of acceptable inputs beyond the schema's basic 'Paths to the files to process.'

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

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

The description opens with 'Images to PDF,' clearly stating the verb (turn) and resource (images) with a specific output format. It further specifies 'photos and scans into one PDF, in the order you picked,' which distinguishes this from sibling tools like pdf_to-image (reverse conversion) and pdf_merge (merging existing PDFs).

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

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

The description implies the tool is for converting images (photos/scans) into PDF, but it does not explicitly state when to use it versus alternatives like pdf_to-image or image_convert. There are no exclusions or alternative tool mentions, so the usage context is implied rather than 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?

No annotations are provided, so the description carries the burden. It discloses key behaviors: pages are copied as-is without re-rendering, order is preserved, and files have size/type limits. It does not detail output naming or error handling, but the core behavior is transparent.

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

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

Three concise, front-loaded sentences with no redundancy. Every sentence contributes meaningful information.

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

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

For a simple merge tool with no output schema and no annotations, the description covers the essential inputs, behavior, and constraints. It lacks edge-case details but is sufficiently complete for normal use.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying that paths determine the merge order and by imposing the 100 MB per file limit, which are not in the schema descriptions.

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

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

The description 'Merge PDF. Join several PDF files into one' clearly states the function with a specific verb and resource, and distinguishes it from siblings like pdf_split and pdf_pages.

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 implies when to use (merging multiple PDFs) and clarifies ordering behavior, but it does not explicitly list alternative tools or when not to use it. The context is clear but exclusions are missing.

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

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

No annotations are provided, so the description must carry the transparency burden. It discloses input limits (application/pdf, 100 MB) and claims 'one pass over the document,' but it does not state whether the original PDF is modified in place or a new file is produced, nor does it mention any irreversible effects beyond deleting pages. This is a significant gap for a destructive-capable tool.

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

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

Two sentences, front-loaded with the key verb, and no filler. The description efficiently covers the core action, common use cases, and file constraints in a compact form.

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 5 parameters and no output schema or annotations, the description leaves critical context unstated. It does not explain how the rotate and delete operations interact, whether the output is written to new files, or how the rotatePages parameter differs from the global rotate. The tool is more complex than the description acknowledges.

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

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

Schema coverage is 100%, with each parameter already described in the input schema. The description adds no parameter-specific semantics beyond the high-level 'rotate and delete' concept. The baseline of 3 is appropriate because the schema does the heavy lifting.

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

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

The description opens with a specific verb+resource: 'Rotate and delete PDF pages.' It immediately clarifies the tool's purpose and differentiates it from siblings like pdf_merge and pdf_split. The use case (scanned sideways, unneeded pages) reinforces the intended operation.

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

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

The description implies when to use the tool: when pages need rotating or deleting. It also provides practical constraints (accepted MIME types, file size limit). However, it does not explicitly contrast with alternatives like pdf_split or pdf_rotate, so it stops short of full 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?

With no annotations, the description carries the burden of behavioral disclosure. It adds useful traits: 'Existing files are never overwritten' and file size/type limits. However, it does not mention whether original files are modified, output naming, or what the tool returns, leaving gaps.

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

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

The description is extremely concise: three sentences, front-loaded with the action verb, and every sentence provides necessary information. No redundancy.

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

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

Given no output schema and no annotations, the description should explain what the tool returns and overall behavior. It explains core usage and constraints, but lacks details on return values, error handling, and whether original files are preserved. This is moderately complete but has clear gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context about modes ('a range, a few ranges, or every page') and the non-overwrite behavior, but does not significantly elaborate on individual parameters 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 uses a specific verb ('Split') and resource ('PDF'), and further clarifies the scope by detailing modes: pulling a range, a few ranges, or every page as its own file. This clearly distinguishes it from siblings like pdf_merge and pdf_pages.

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 by stating what the tool does, but it does not explicitly state when to use it over alternatives or provide any exclusions. It lacks guidance like 'use this instead of pdf_pages when...'.

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

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

With no annotations provided, the description carries the full burden of disclosure. It adds useful behavioral details such as 'one image per page' and the 100 MB file size limit, plus accepted MIME type. However, it does not explain output naming, whether the original PDF is preserved, or how errors are handled, leaving some uncertainty.

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

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

The description is concise and front-loaded with the core purpose, followed by a use case and input constraints. All sentences contribute meaning. It is slightly fragmented with a one-sentence opening, but overall it is efficient and well-structured.

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

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

The description covers input format, size limit, output format, and per-page behavior. Given the tool has no output schema and no annotations, this is fairly complete. However, it omits details about the return value or any side effects, so it does not fully cover all contextual aspects.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents each parameter with practical guidance (e.g., DPI values for screen/print, page ranges). The tool description itself does not add additional parameter semantics beyond what the schema provides, so the baseline score is appropriate.

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

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

The description clearly states the tool converts PDF pages to JPG or PNG images, one image per page. This specific verb+resource combination distinguishes it from sibling tools like pdf_merge or pdf_split. The phrase 'Turn PDF pages into JPG or PNG' is unambiguous and precise.

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: 'Handy when the document has to be shown where PDF is not opened.' This implies the primary use case, though it does not explicitly mention alternatives or when not to use this tool. Therefore it earns a 4 rather than a 5.

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

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

With no annotations, the description must carry the transparency burden. It discloses that processing happens in the browser and a 5MB file size limit, but does not mention whether source files are modified, how output files are named, or what the function returns. Key safety traits like not overwriting existing files are only found in the schema, not the description.

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

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

The description is brief and immediately front-loaded with the main verb 'Convert.' It packs essential information into two succinct sentences, avoiding redundancy with the schema. The only minor imperfection is the slightly list-like second sentence, but overall it is highly 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?

The schema provides detailed parameter semantics, but without an output schema or annotations, the description should clarify output behavior and post-conversion effects. It does not mention return values or that new files are created, leaving some ambiguity. However, the tool is relatively simple and the schema covers the key output location and overwrite policy, making it minimally 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 covers all parameters with descriptions, meeting the high coverage baseline of 3. The description adds value by specifying accepted input MIME types/types and the 5MB file size restriction, which are not present in the schema. This goes beyond the schema's parameter documentation.

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

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

The description clearly states the tool's purpose: converting subtitles between SRT and VTT formats and shifting timing. It names specific verbs and resources, and the mention of browser-side operation and accepted text formats distinguishes it from video-related subtitle tools, though it does not explicitly name siblings.

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

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

Usage context is implied through the offered conversions and supported file types, but no explicit 'when to use' or alternative tool references are given. The browser-execution note provides some context but does not clarify when to prefer this over video_subtitles or other 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?

With no annotations, the description carries the transparency burden. It discloses useful constraints (auto-direction, size limit, MIME acceptance) but omits how decode input is provided (via file path?) and what the tool returns (string vs. written file), leaving ambiguity for a bidirectional utility.

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

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

The description is compact, front-loaded with the core purpose, and uses four short sentences. The phrase 'or say' is slightly awkward, but overall every sentence earns its place.

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

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

The description covers the main purpose, file type and size constraints, but lacks clarity on how decoding receives a base64 string (a critical ambiguity given the bidirectional nature). With no output schema, this omission makes the description less complete for an agent.

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

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

Schema description coverage is 100%, so the schema already explains all four parameters. The description adds only use-case context (paste into CSS) and doesn't clarify parameter-specific behaviors beyond schema, justifying the baseline score of 3.

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

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

The description clearly states the tool encodes a file as base64 and decodes a base64 string back into a file, with the direction auto-detected. This specific verb-resource pairing distinguishes it from siblings like utility_hash (hashing) and data_convert (general conversion).

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 a concrete use case (pasting an image into CSS) and specifies accepted types (*/*) and size limit (20 MB). However, it doesn't explicitly mention when not to use it or name alternative tools, though no sibling appears to offer base64 functionality.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It adds meaningful traits: 'The file never leaves your device' (privacy) and limits ('Accepts */*; up to 500 MB per file'). However, it doesn't disclose whether the tool modifies files or how results are returned (e.g., output file vs. direct return), though the schema's outputDir hints at file output.

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 three sentences, each earning its place: purpose, use case, and constraints. It is front-loaded with 'File checksum' and contains no fluff, making it highly concise and structured.

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

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

For a utility with no output schema, the description covers purpose, use case, and constraints adequately. However, it omits details about the output format or return behavior, which is partially addressed by the outputDir schema description but not fully explained. Given the tool's simplicity, it's adequate but not 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 baseline is 3. The description adds valuable parameter constraints not in the schema: MIME type acceptance ('Accepts */*') and file size limit (up to 500 MB), which help the agent judge parameter suitability. It also lists the algorithm options available, reinforcing the enum.

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

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

The description clearly states the tool computes MD5, SHA-1, SHA-256, or SHA-512 checksums of files, using the specific verb 'work out' and identifying the resource (file). It distinguishes itself from sibling tools by specifying the integrity-checking use case, unlike utility_base64 or conversion 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 a clear use case ('to check that what you downloaded is what was published'), which implies when to use it for file integrity verification. It does not explicitly name alternatives or exclusions, but the context is sufficient for an agent to differentiate from sibling utilities.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the two-pass encoding process, automatic bitrate calculation, supported input formats, and the 500 MB file size limit. However, it does not state whether original files are preserved, what output format is used, or how output paths are determined, which are important behavioral details for a compression tool.

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

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

The description is extremely concise, consisting of two sentences that immediately convey the tool's purpose, method, and constraints. Every phrase adds value: the compression goal, the two-pass encoding, and the accepted formats/size limit. There is no redundancy or filler.

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

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

Given the tool has 4 parameters, no annotations, and no output schema, the description covers the core purpose, method, and input constraints well. However, it omits expected output behavior (e.g., whether new files are created, how results are returned) and does not clarify the relationship to similar sibling tools like video_for-messenger. This leaves some gaps for an agent invoking the tool.

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

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

The input schema has 100% description coverage for all four parameters, so the baseline is 3. The tool description adds minimal parameter-specific meaning—it mentions a 'given number of megabytes' (targetMb) but does not elaborate on audio bitrate, output directory, or paths. The schema already handles parameter semantics adequately.

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

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

The description clearly states the tool compresses video and specifies the goal of fitting a recording into a target size in megabytes for email or messenger. It uses a specific verb and resource, but does not explicitly differentiate from the sibling video_for-messenger tool, which may also be intended for messenger-sized outputs.

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

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

The description provides clear context for when to use this tool: when you need to compress a video to a specific size limit for email or messenger. However, it does not explicitly state when not to use it or mention alternative tools (e.g., video_convert or video_for-messenger), so there is no explicit 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?

With no annotations, the description carries the disclosure burden. It adds behavioral constraints by specifying accepted MIME types/extensions (.mp4, .mov, .mkv, etc.) and a 500 MB per-file limit. It does not explicitly state that originals are untouched or describe return behavior, but the schema's outputDir description already covers output location and overwrite policy.

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 concise sentences, front-loaded with the primary action. Every sentence provides distinct information: the conversion action, format selection tips, and input constraints. No filler or redundancy.

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

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

Given no output schema, the description still provides essential constraints (input types, size limit, format options). The schema's outputDir field explains where results go and that existing files are never overwritten. It lacks explicit mention of multi-file processing behavior or error cases, but overall is adequate 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 baseline is 3. The description enriches the 'format' parameter by explaining which format to choose for different use cases, adding value beyond the schema's terse 'Output format' label. Other parameters are adequately documented in the schema.

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

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

The description uses a specific verb 'Convert' and names concrete output formats (MP4, WebM, MKV), clearly distinguishing it from sibling tools like video_compress, video_resize, and video_trim. It also lists accepted input formats and file size limit, making the tool's scope unambiguous.

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

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

It provides clear context on when to use each output format ('MP4 plays everywhere, WebM is for the web, MKV is what you usually need to open somewhere else'), guiding format selection. It does not explicitly name alternative tools or when-not-to-use, but the format guidance implies usage context.

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

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

No annotations are provided, so the description carries the full burden. It discloses useful traits like adaptive bitrate, audio preservation, and input format/size limits. However, it does not mention potential lossy re-encoding, output container format, or behavior for inputs already under 24 MB, leaving some behavioral gaps.

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

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

The description is two sentences, front-loaded with purpose, and every clause carries meaningful information. No fluff or redundant repetition of the tool name.

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

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

The description is fairly complete for a 2-parameter tool: it covers purpose, target size, bitrate strategy, audio handling, input formats, and size limits. It lacks an explanation of the return value or output details, but since there is no output schema, this is not critical. Minor gaps like output file naming/overwrite behavior are already covered by the schema.

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

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

Schema coverage is 100%, so the schema already documents both parameters thoroughly. The description adds contextual constraints (up to 500 MB, accepted formats) but does not add parameter-specific semantics 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?

The description clearly states the tool's purpose: to compress video to 24 MB for messenger and email use. It distinguishes itself from general compression tools like video_compress by specifying a target size and use case, using a specific verb 'squeezes' plus the resource.

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

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

It provides clear context for when to use the tool: when a video needs to fit within mail and messenger size limits. However, it does not explicitly mention alternatives or exclusions, such as 'for general compression use video_compress', so it lacks explicit when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the operation is lossless ('pictured is copied as is'), fast ('no waiting'), and includes format/size limits. It does not explicitly state whether source files are modified or output naming behavior, but the schema covers overwrite safety, and the overall behavioral context 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?

Three short sentences, front-loaded with the core purpose, then supplementary constraints. Every sentence earns its place: statement of action, losslessness/speed, and acceptance criteria. No fluff.

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

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

For a simple two-parameter tool with well-described schema and no output schema, the description provides all necessary context: what it does, key behavioral guarantees, and input constraints. The schema already covers output location and overwrite behavior, so 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?

Schema coverage is 100%, so the baseline is 3. The description adds valuable constraint info for the 'paths' parameter: accepted MIME types and file size limit (video/*, specific extensions, 500 MB). This goes beyond the schema's generic 'Paths to the files to process' and helps the agent validate inputs.

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

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

The description opens with a clear action: 'Remove audio from video. Drop the sound track.' This is a specific verb+resource that unmistakably states the tool's function, and it distinguishes itself from siblings like video_compress or audio_extract by emphasizing the mute operation.

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

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

The description implies when to use this tool: whenever you need to remove audio while preserving the video stream perfectly. It also contrasts with 'no quality loss and no waiting', hinting at advantages over re-encoding. However, it does not explicitly name alternatives or state when NOT to use it, so it falls short of a 5.

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

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

With no annotations provided, the description fully discloses key behavioral traits: aspect ratio is preserved (no stretching), upscaling is explicitly refused, and there are format/size constraints. These details go beyond the schema and are essential for correct invocation and expectation-setting.

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 three sentences, front-loaded with 'Resize video.' Every sentence adds valuable information (resolutions, aspect ratio, upscaling behavior, accepted inputs, size limit) with no wasted words.

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

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

For a video resizing tool with four parameters and no output schema, the description is highly complete. It covers the input constraints, behavior, resolution options, and edge cases (upscaling refusal). It adequately compensates for the lack of an output schema by setting expectations about what happens to the video.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema: it clarifies that 'height' corresponds to the output resolution and that width follows original proportions, which directly relates to the 'height' parameter. It also gives input format/size constraints relevant to the 'paths' parameter.

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

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

The description opens with a clear verb+resource: 'Resize video.' It specifies the exact output resolutions (1080p, 720p, 480p, 360p) and states the key behavior of preserving aspect ratio. This distinguishes it from siblings like video_compress or video_convert, which have different purposes.

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

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

The description gives strong contextual guidance: it tells the agent the tool is for resizing to specific lower resolutions, that upscaling is refused (so not for upscaling), and lists accepted formats and file size limits. It does not explicitly name alternative tools, but the context makes the appropriate use case clear.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It transparently notes that burning re-encodes the picture, attached subtitles are user-switchable, and limits input types and size (up to 500 MB). This goes beyond the basic schema, though it stops short of detailing output behavior or file handling edge cases.

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 three well-structured sentences. The first states the core action, the second contrasts the two modes, and the final sentence lists accepted formats and the size cap. No wasted words, and the most relevant 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 tool with 4 parameters and no output schema, the description covers the essential context: what it does, how the modes differ, accepted file types, and size limits. The schema handles parameter details like outputDir defaults and non-overwriting, so the description is complete for this tool's complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds genuine meaning to the 'mode' parameter by explaining the real-world consequences of 'burn' vs. 'attach', and it clarifies that 'paths' accepts both video and subtitle file formats. The rest of the parameters (fontSize, outputDir) are adequately described in the schema, so this added context earns a 4.

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 starts with a specific verb+resource ('Add subtitles to video') and clearly distinguishes two modes (burn vs. attach). It differentiates from sibling tools focused on conversion, compression, or thumbnails, so the purpose is unmistakable.

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

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

The description explains when to choose burned-in versus attached subtitles by detailing trade-offs (burned-in always visible, attached can be switched off and avoids re-encoding). It does not explicitly compare against 'text_subtitles' or other alternatives, so it stops short of a full 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It does add useful performance context ('Exactly one frame is decoded, so an hour of video costs no more than a minute') and format/size constraints. However, it does not disclose output file behavior (e.g., naming, overwriting) or side effects. While the schema mentions 'Existing files are never overwritten' for outputDir, the tool description itself lacks this transparency, and such safety details are not covered by annotations. This is adequate but incomplete.

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

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

The description is extremely concise: two sentences in the body followed by format/size constraints. It is front-loaded with the essential purpose ('Video thumbnail. Grab a frame for a cover or preview.') and each subsequent sentence adds distinct factual value. No wasted words.

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

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

Given the tool's moderate complexity (5 params, no output schema, no annotations), the description covers purpose, formats, size limit, and performance. It omits details about return values or output file naming, but these are largely inferable from tool name and schema. Overall, it is reasonably complete for an agent to select and use the tool, but not exhaustive.

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

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

Schema description coverage is 100%, so per rubric the baseline is 3. The tool description adds no extra meaning beyond the schema; it does not explain how parameters like 'at', 'width', or 'format' interact. Since the schema fully documents parameters, the description need not repeat them, but it also does not add value, so the baseline stands.

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 'Video thumbnail. Grab a frame for a cover or preview.' This clearly identifies the tool's purpose with a specific verb ('grab') and resource (frame from video), distinguishing it from sibling video processing tools like video_to-gif or video_trim. The purpose is unambiguous and immediately understood.

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 to use: 'Grab a frame for a cover or preview.' It also sets expectations with accepted formats and size limits. However, it does not explicitly state when not to use it or mention alternatives, such as video_to-gif for animated outputs. This is clear context without exclusions, matching a 'clear context, no exclusions' level.

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

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

With no annotations, the description carries the full burden. It discloses the critical palette requirement (separate pass, otherwise noise) and accepted file formats/size limit. No contradictions with structured data.

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

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

Two concise sentences front-load the purpose, then add the important palette warning and format constraints. No filler.

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

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

The description covers key constraints (formats, size, palette behavior) and the output directory default is in schema. It doesn't elaborate on output naming or failure modes, but for a straightforward converter, it's reasonably complete.

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

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

Schema covers 100% of parameters, and descriptions in schema are already informative. The tool description doesn't add extra parameter semantics beyond the 'fragment' reference, but 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 states the tool builds a GIF from a video fragment, distinguishing it from sibling tools like video_trim or video_convert. It also specifies accepted formats and size limits, reinforcing the scope.

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

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

The description implies usage for creating GIFs from video segments, with a note about the palette pass. However, it doesn't explicitly compare with alternatives or state when not to use it, so it's clear context without exclusions.

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

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

With no annotations to rely on, the description carries full weight and excels: it discloses the stream-copy behavior (fast and lossless), the keyframe caveat (may re-encode and notify), accepted formats, and file size limit. This is rich behavioral detail beyond the schema and annotations.

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

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

The description is tightly written: first sentence states the action, second clarifies the fragment, third explains the lossless fast path, fourth covers the re-encode edge case, and the last lists accepted formats/size. No wasted words, each sentence earns its place, and key information is front-loaded.

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

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

Given the tool has 5 parameters, no output schema, and no annotations, the description covers the essential aspects: purpose, method, keyframe behavior, supported formats, and size limit. It relies on the schema for output directory behavior and does not explicitly describe what the output files look like, but that is inferable. A small gap in explaining potential edge cases (e.g., invalid timecodes) keeps it from a 5.

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 each parameter already has clear descriptions (e.g., 'from' accepts '1:30 or 90'). The description adds semantic value by explaining the keyframe/re-encode behavior that directly affects the 'precise' parameter and the meaning of timecodes, which is not fully captured in the schema.

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

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

The description opens with 'Trim video' and immediately specifies the exact action: 'Cut out a fragment by timecodes.' This clearly distinguishes it from sibling tools like video_compress or video_resize, and the verb+resource+method structure leaves no ambiguity about what the tool does.

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

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

The description provides clear context for when to use the tool (to trim by timecodes) and even notes the fast/lossless nature and re-encoding conditions, which helps decide between quick trimming vs precise cutting. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full exclusionary guidance.

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