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

No annotations provided, so description carries full burden. It discloses the return structure (key, confidence, chords list) and prerequisite. Missing: error behavior, side effects (though likely read-only), or performance details.

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

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

Very concise: two sentences for purpose, followed by bullet-style args and returns. No fluff or redundant information.

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

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

Covers parameters and return shape. Missing: error handling, limitations, or performance notes. For a simple analysis tool with 2 params, it is nearly 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 has 0% description coverage, but the description explains both parameters: score_b64 as 'Base64-encoded score file' and input_suffix as 'Input extension, e.g. "mscz".' This adds sufficient meaning beyond the schema's bare property names.

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

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

The description clearly states 'Analyze chord progressions and tonal center using music21,' which is a specific verb and resource. It distinguishes from sibling tools like get_key_signature or transpose, which focus on other aspects.

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

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

No guidance on when to use this tool versus alternatives; only a prerequisite ('Requires pip install music21') is mentioned. No exclusions or context for selection.

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

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

No annotations are provided, so the description carries the full burden. It states that the tool applies a style and re-exports a score, but it does not disclose any side effects, permission requirements, or failure modes. As a transformation, it implies no destruction, but the description could be richer.

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, well-structured with clear sections for Args and Returns. Every sentence serves a purpose, and there is no redundant information.

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

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

The description covers the input parameters and return value adequately. Given the existence of an output schema, it does not need to elaborate on the return format. However, it lacks details on error handling or constraints on the style file, which would improve completeness.

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

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

With 0% schema description coverage, the description compensates by explaining each parameter's purpose and format (e.g., Base64-encoded, input suffix example). However, it does not clarify the role of 'input_suffix' beyond an example, leaving some ambiguity.

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

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

The description clearly states the action (apply), the resource (MuseScore style file .mss to a score), and the outcome (re-export). It is specific and distinguishes this tool from its siblings, which include other operations like batch_convert, change_tempo, etc.

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

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

The description does not provide any guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or situations where it should not be used. It simply describes the operation without 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 reveals the underlying process (using -j flag) and the base64 encoding requirement, but does not disclose side effects, error handling, authentication needs, or performance implications.

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

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

The description is concise (5 lines) and well-structured: first line states purpose, then bullet points for job requirements, then return behavior. No unnecessary words, but could be slightly more compact without losing 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?

Given the existence of an output schema (not shown), the description appropriately omits return value details beyond ordering. It covers input structure well but might benefit from mentioning error handling or concurrency limits for a batch 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 provides no descriptions for parameters (0% coverage), but the description compensates by listing the required keys (in_b64, in_suffix, out_format) with types and examples, adding critical semantic meaning beyond the schema.

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

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

The description 'Convert multiple score files in a single MuseScore process using -j' clearly states the verb (convert), resource (multiple score files), and the specific flag used. It distinguishes itself from the sibling 'convert_score' which likely handles single conversions.

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

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

The description specifies the required fields for each job dict (in_b64, in_suffix, out_format) and notes that results are returned in order. However, it does not explicitly explain when to use batch_convert over convert_score or other alternatives, leaving some ambiguity.

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

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

The description discloses that it replaces all existing tempo markings (destructive behavior) and returns modified MusicXML as a string. With no annotations provided, this is reasonably transparent, though missing details on side effects and 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 concise, with a clear first sentence stating the core action, followed by a structured Args list and return type. No extraneous 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?

The description covers the tool's action and return value adequately for its simplicity, but lacks usage guidelines and error scenarios. With an output schema present, return details are partially covered.

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

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

The 'Args' section repeats parameter names but adds constraints: bpm range (1–400) and beat_unit options. However, it does not elaborate on score_b64 format or input_suffix beyond their names, leaving room for ambiguity.

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

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

The description clearly states it changes tempo by modifying specific MusicXML elements and replaces all existing tempo markings. This distinguishes it from sibling tools like change_time_signature, but does not explicitly mention sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives like change_time_signature or other tempo-related operations. The prerequisites and context of use are not addressed.

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

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

With no annotations, the description fully discloses behavioral traits: it modifies only the time signature, does not adjust notes/beaming, and returns a modified MusicXML string. This exceeds the minimum but could add details like permissions or side effects.

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

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

The description is concise with clear sections: action, warning, args, returns. Every sentence is necessary and front-loaded with key information. No redundancy or fluff.

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

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

Given the tool's moderate complexity and the presence of an output schema (which handles return structure), the description fully covers the tool's purpose, limitations, input parameters, and output format. No gaps.

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

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

The input schema has 0% description coverage, so the description fully explains all four parameters: score_b64 (Base64-encoded file), input_suffix (extension), beats (beats per measure), beat_type (note value). It adds essential meaning beyond the schema.

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

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

The description clearly states the tool changes the time signature by modifying MusicXML <time> elements. This is a specific verb+resource combination that distinguishes it from sibling tools like change_tempo.

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 warns that only the time signature element is changed and notes/beaming are not adjusted, but it does not provide explicit guidance on when to use this tool versus alternatives or any exclusions. Usage is implied but not fully contextualized.

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

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

No annotations provided, so description carries full burden. It explains output format variations but does not disclose potential destructive behavior, error handling, or limitations like file size constraints.

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

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

The description is well-structured with clear Args and Returns sections, using bullet points for output format variants. Every sentence adds value without redundancy.

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

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

Given no output schema, the description covers conversion purpose, all input parameters, and return structure thoroughly. Minor gaps such as file size limits or source prerequisites prevent a perfect score.

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

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

Schema coverage is 0%, but the description fully compensates by explaining each parameter: score_b64 as base64 content, input_suffix as extension without dot, and output_format with specific allowed values and examples.

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

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

The description clearly states the tool converts a score file to another format, specifying input arguments and output formats. It distinguishes from sibling tools like batch_convert and other conversion-specific 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?

No explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or common use cases for other 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 full burden. It explains the conversion action and return format (Base64-encoded mscz file). It does not mention error handling for invalid input, but for a simple conversion tool, the behavior is sufficiently disclosed.

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

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

The description is concise, with three short sentences covering purpose, use case, and return value. No redundant or irrelevant 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 tool with one parameter and no nested objects, the description covers all essential aspects: input, output, and purpose. The output schema is described verbally as 'Base64-encoded mscz file', which is sufficient given the simplicity.

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

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

The schema provides no description for the 'musicxml' parameter (0% coverage). The description compensates by specifying it is 'MusicXML content as a UTF-8 string', clarifying that it expects content, not a file path, and the encoding.

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

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

The description clearly states the tool converts a MusicXML string into a MuseScore .mscz file. The verb 'convert' and specific input/output resources differentiate it from sibling tools like midi_to_score or convert_score.

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

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

The description explicitly mentions it is useful for creating MuseScore files from externally generated MusicXML, indicating the appropriate use case. It does not discuss when to avoid using it or name alternatives, 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 full burden. It discloses the process (converts to MusicXML first, uses JSON job format), the return format (list of dicts), and that it discovers part names and counts. It does not address authorization or rate limits but adequately describes 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 concise: a brief purpose summary, a short technical overview, and a structured Args section. No wasted sentences 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 presence of an output schema, the description does not need to detail return values but does anyway. It covers the internal process, but lacks error handling, supported formats, or size constraints. Overall, it provides sufficient context for an AI agent.

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

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

Schema coverage is 0%, but the description's Args section explains each parameter: score_b64 is base64-encoded score, input_suffix is the input extension, output_format is format with default pdf. This adds significant meaning beyond the bare schema.

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

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

The description states a specific action ('Export each instrument part from a score as a separate file') clearly identifying the resource (instrument parts from a score) and the operation (export). It distinguishes from sibling tools like 'export_png_pages' and 'convert_score'.

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 (to export parts) but does not explicitly state when not to use it or suggest alternatives. No direct comparison to sibling tools like 'export_png_pages' or 'convert_score'.

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 describes the output (list of base64 PNGs per page in order) and mentions a trim option to remove whitespace. However, it could disclose more about performance or file size limits.

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

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

The description is compact, uses a clear docstring format, and front-loads the main action. Every sentence adds useful information without redundancy.

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

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

Given there is an output schema (though not shown), the description explains the return type as a list of base64 strings. It covers the essential aspects of a conversion tool, though could mention page ordering or all pages guarantee.

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

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

Schema coverage is 0%, meaning no parameter descriptions in the input schema. The description fully compensates by explaining each parameter: score_b64 (Base64 score), input_suffix (extension like 'mscz'), dpi (1-2400, default 150), trim (default false). This adds significant value beyond the schema.

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

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

The description clearly states 'Export each page of a score as a PNG image', with a specific verb and resource. It distinguishes from sibling tools like convert_score or export_parts by focusing on page-by-page PNG output.

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

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

The description does not explicitly state when to use this tool versus alternatives or when not to use it. The usage is implied but lacks explicit guidance on tool selection among siblings.

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

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

The description details the return format and ordering, and the read-only nature is implied by 'Return all key signature changes.' No side effects are mentioned, but the absence of annotations puts the burden on description, which adequately covers expected 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 a single-line summary followed by a structured docstring for Args and Returns. Every sentence adds value, and the key information is front-loaded.

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

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

For a simple retrieval tool with two parameters and an output schema, the description covers purpose, inputs, and output format. It could mention if the score is modified (it is not), but overall it is complete enough.

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

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

Schema descriptions are missing (0% coverage), but the description's docstring explains both parameters: 'score_b64: Base64-encoded score file' and 'input_suffix: Input extension, e.g. mscz.' This adds clear semantics beyond the raw schema.

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

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

The description explicitly states 'Return all key signature changes in the score with their measure positions,' using a specific verb and resource. It clearly distinguishes from sibling tools like change_key_signature or transpose_by_key by focusing on retrieval of existing key signatures.

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

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

The description implies usage when key signature information is needed, but does not explicitly state when to use this tool versus alternatives like analyze_harmony or transpose_by_key. No guidance on prerequisites or exclusions is provided.

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

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

No annotations are provided, so the description carries full burden. It states 'detected' but does not explain how detection works (e.g., PATH, registry), what happens if MuseScore is not installed, or any side effects. The output schema exists but is not 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 a single concise sentence that front-loads the action and resource. Every word is necessary and 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?

Given the tool's simplicity (no parameters, presence of output schema), the description is largely complete. It could be improved by mentioning behavior when MuseScore is not detected, but the output schema likely covers that.

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

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

There are zero parameters, and schema description coverage is 100% (trivially). Per guidelines, 0 parameters warrants a baseline of 4. The description adds no extra parameter information, but none is needed.

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 verb 'Return' clearly indicates a retrieval action, and 'MuseScore executable path' specifies the exact resource. The tool's purpose is distinct from sibling tools, which focus on score manipulation or 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 does not provide any guidance on when to use this tool versus alternatives, nor does it mention when not to use it. However, the tool is simple and its use case is self-evident from its name and description.

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

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

With no annotations, the description carries full burden. It explicitly lists the return fields (title, composer, etc.), giving agents a clear picture of behavior. However, it does not explicitly state the tool is read-only or has no side effects, which is a minor gap.

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

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

The description is concise, with a clear purpose sentence followed by structured Args and Returns sections. Every sentence adds value, and the key information is front-loaded.

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

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

For a simple metadata retrieval tool with no output schema, the description is complete. It explains both parameters and enumerates all return fields. The tool's simplicity is matched by adequate documentation.

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

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

Schema coverage is 0%, so description compensates. It explains 'score_b64: Base64-encoded score file' and 'input_suffix: Input extension, e.g. "mscz"', adding meaningful context beyond the schema's titles. The example for input_suffix is helpful.

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 'Return basic metadata and structural info about a score.' It specifies the action (return) and resource (score). The detailed list of returned fields distinguishes it from sibling tools like analyze_harmony or get_key_signature.

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

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

The description implies usage for retrieving metadata but provides no explicit guidance on when to use this tool versus alternative tools (e.g., get_key_signature for only key info). No exclusions or when-not-to-use information is given.

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

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

No annotations are provided, so the description carries full burden. It describes inputs and outputs but does not disclose any behavioral traits such as whether the operation is read-only, permissions required, error handling, or performance implications. The 'Return instrument/part info' suggests a read operation, but without explicit mention of side effects or limitations, transparency is low.

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, structured into Args and Returns sections, and each sentence is necessary. No redundant information. It efficiently conveys the tool's purpose and usage in a few lines.

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 two parameters and the description includes both input semantics and output structure (list of dicts with fields), it is reasonably complete. The output schema is indicated as present but not shown; the description compensates by listing return fields. Minor gap: no examples or error handling notes.

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

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

The input schema has 0% coverage (no descriptions in schema), so the description must compensate. It explains score_b64 as 'Base64-encoded score file' and input_suffix as 'Input extension, e.g. "mscz"', providing semantic meaning beyond the raw parameter names. This adds significant value for correct parameter usage.

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

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

The description clearly states it returns instrument/part info including transposition and pitch range. It uses specific verbs ('Return') and resource ('instrument/part info'), and the tool name 'list_instruments' aligns well. Among siblings (e.g., analyze_harmony, get_key_signature), this is uniquely about extracting instrument details from a score.

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

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

The description lists required arguments but does not explicitly specify when to use this tool versus alternatives like get_score_info. No direct guidance on prerequisites or when to avoid. The context of siblings implies distinct purpose, but the description itself lacks explicit usage guidelines.

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 describes the inputs and output (base64 mscz) but does not disclose potential side effects, file size limits, error behaviors, or processing constraints. The description is adequate but lacks depth for a full behavioral profile.

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

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

The description is very concise with two sentences for the main purpose, a structured Args section, and a Returns line. No unnecessary words or redundancy. 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?

The tool is straightforward with 3 parameters and a clear output. The description covers the essential aspects: what it converts, what arguments are needed, and the return format. However, it lacks information about error handling, restrictions, or performance characteristics, which would make it more complete.

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

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

The description provides clear explanations for all three parameters beyond the schema: midi_b64 is described as 'Base64-encoded MIDI (.mid) file content', quantization includes example values, and midi_import_options_b64 explains its purpose. Since schema has 0% description coverage, this adds significant meaning.

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

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

The description explicitly states 'Convert a MIDI file to a MuseScore .mscz file.' This is a specific verb+resource pair that clearly indicates the action and output format. It distinguishes from sibling tools like 'create_from_musicxml' which handle different input formats.

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 specifying the conversion from MIDI to mscz, but it does not provide explicit guidance on when to use this tool versus alternatives like 'convert_score' or 'create_from_musicxml'. No usage context or exclusions are mentioned.

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

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

With no annotations, the description must disclose behavioral traits. It mentions plugin execution and return of modified score, but does not address potential destructive actions, error handling, or permission requirements, leaving gaps in transparency.

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

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

The description is concise and well-structured: a single-line summary, followed by a brief paragraph on prerequisites, then a clear Args and Returns list. 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?

Given the tool's complexity (running external plugins) and the presence of an output schema, the description covers the core workflow and prerequisites. It could include more on error scenarios or plugin dependencies, but overall it is sufficient for typical use.

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

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

The schema has 0% description coverage, but the description's Args section adds meaning for all three parameters (e.g., 'Base64-encoded score file' for score_b64, 'without .qml' for plugin_name). This compensates well for the lack of schema-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 action: 'Run a MuseScore QML plugin on a score.' It uses specific verb and resource, and is distinct from sibling tools like analyze_harmony or export_parts, which perform 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 provides context by noting plugins must be installed and gives examples of plugin types. However, it does not explicitly state when to use this tool over alternatives or provide exclusions, though the sibling tools are different enough that confusion is unlikely.

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?

Describes invoking MuseScore CLI and returning Base64 mscz, but with no annotations, it doesn't disclose error handling, side effects, or limitations such as file size constraints.

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

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

Well-structured with summary, requirement note, and list of args. Concisely covers core info, though the requirement line could be slightly tighter.

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

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

Given existing output schema (not shown but indicated), description adequately covers purpose, requirements, and parameters. No major gaps for a 4-parameter tool.

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

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

Input schema has no description coverage (0%), but the description compensates by documenting each parameter (score_b64, input_suffix, semitones range 1-24, direction up/down), adding meaning beyond schema.

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

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

Clearly states transposing a score by a fixed number of semitones via MuseScore CLI. Distinguishes from sibling tools like transpose_by_key which use key signatures.

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

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

Mentions MuseScore 3.3+ requirement but lacks explicit guidance on when to use this tool versus alternatives like transpose_by_key or transpose_for_instrument. No 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?

No annotations are provided, so the description carries the full burden. It discloses the dependency on MuseScore CLI, the direction default, and the return value (Base64-encoded mscz). It does not mention permissions or side effects, but the tool appears non-destructive as it returns a new file.

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

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

The description is structured with Args and Returns sections, making it easy to parse. It is detailed without being verbose, though the key list could be abbreviated. Every sentence serves a purpose.

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

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

Given the tool has 4 parameters, no annotations, and an output schema exists, the description covers the core functionality, prerequisites, and return format. It lacks error handling details or non-happy-path behavior, but it is complete enough for typical use.

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

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

Schema coverage is 0%, but the description adds meaning to all parameters: explains target_key with a list of major keys, direction with allowed values and default, and input_suffix with an example. score_b64 is mentioned but could benefit from format constraints. Overall, it compensates well for the lack of schema descriptions.

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

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

The description clearly states 'Transpose a score to a target key using the MuseScore CLI,' providing a specific verb and resource. It lists target key options and direction, distinguishing it from siblings like transpose_by_interval and transpose_for_instrument.

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

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

The description mentions the prerequisite 'Requires MuseScore 3.3+ with --score-transpose support,' but does not provide guidance on when to use this tool versus sibling transpose tools. Implied usage is clear but no explicit exclusions or comparisons.

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

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

With no annotations, the description carries full transparency burden. It discloses that the tool modifies the <transpose> element, returns modified MusicXML, and affects the specified part(s). However, it does not mention potential side effects, required permissions, or whether the operation is reversible.

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

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

The description is well-structured with a concise intro, an example list, and an Args table. It avoids redundancy and is front-loaded with purpose. The list of known instruments is useful but could be shortened; overall efficient.

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

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

Given the 6 parameters, lack of schema descriptions, and no annotations, the description covers the core functionality, return type, and parameter interactions. It omits error handling, input validation, and performance constraints, but is adequate for typical use.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining each parameter in the Args section: score_b64, input_suffix, instrument shorthand, chromatic/diatonic offsets, and part_index with default behavior. It clarifies the mutual exclusivity of instrument vs explicit offsets.

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

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

The description clearly states it adjusts transposition offsets for transposing instrument parts via the MusicXML <transpose> element. It provides concrete examples (Bb clarinet, alto sax) and distinguishes from sibling tools like transpose_by_interval by offering instrument shorthand as an alternative to explicit intervals.

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 how to use the tool (pass instrument or chromatic+diatonic) and lists known instruments, but does not explicitly state when this tool should be preferred over transpose_by_interval or transpose_by_key, nor does it warn about non-transposing instruments or prerequisites.

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

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

The description explicitly states that only non-None fields are changed, implying a partial update behavior. It also specifies the return type (modified MusicXML as UTF-8 string). Given no annotations are provided, this level of detail adequately conveys the tool's behavioral traits without contradiction.

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

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

The description is exceptionally concise: a one-line summary, a key behavioral rule, a clear Args list, and a Returns line. Every sentence earns its place, and the structure front-loads the most critical information. There is no redundant text.

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

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

Considering the tool's complexity (7 parameters, partial update logic, output type) and lack of annotations, the description covers the essential aspects: what it does, which fields are updated, and what it returns. It does not cover error handling or input validation, but for a metadata update tool, this is 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?

Schema description coverage is 0%, so the description must compensate. While the Args list names each parameter and gives brief explanations (e.g., 'Base64-encoded score file'), it does not elaborate on expected formats, constraints, or relationships between parameters. The partial update note adds value, but overall the parameter descriptions remain superficial.

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 that the tool updates score metadata fields and returns the modified MusicXML. The verb 'update' plus the resource 'metadata' is specific. It is distinct from sibling tools like 'apply_style' or 'convert_score' which handle other aspects.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, typical use cases, or scenarios where another sibling tool would be more appropriate. This omission leaves the agent without usage direction.

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 fully disclose behavior. It explains the monitoring duration (max 300s) and the return structure. However, it does not clarify whether existing files are ignored, if the tool is read-only or destructive, or if it blocks the process. This leaves some ambiguity.

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

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

The description is well-structured: a brief summary sentence, then a short paragraph, followed by Args and Returns. It is front-loaded with the purpose and every sentence contributes useful information without redundancy.

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

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

Given 4 parameters and no output schema, the description covers inputs and outputs thoroughly, including a detailed JSON return structure. It addresses error handling via an 'errors' list. No critical gaps are present.

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

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

Schema description coverage is 0%, but the description includes a full Args section with explanations for all four parameters, adding meaning beyond the schema's titles and types. It clarifies default values and expected formats (e.g., 'list of output formats, e.g. ["pdf", "musicxml"]').

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: watch a folder for new .mscz files and auto-convert them. This is a specific verb ('watch', 'auto-convert') and resource ('folder for .mscz files'), and it distinguishes from siblings like batch_convert or convert_score by introducing the monitoring aspect.

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

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

The description does not explicitly state when to use this tool vs alternatives like batch_convert or convert_score. It implies usage for monitoring new files over a duration, but lacks guidance on when not to use it or what distinguishes it from similar tools.

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