Scoreproof

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds real behavioral context: the comparison is granular to the bar and tolerates mismatched formats. It says nothing about limits on very large pieces or how differences are summarized, which would have been valuable beyond the annotations.

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

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

A single sentence with no filler, front-loaded on the action and finished with the qualifier that matters most. It is efficient, though it leaves the agent with very little to work with given the operation's nuance.

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?

An output schema exists, so the return shape need not be explained, and annotations carry the safety profile. What is present covers inputs, granularity, and cross-format tolerance. Minor gaps remain around size limits and what 'piece' covers, which keeps it below 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 description coverage is 100%, with both 'a' and 'b' documented as links to versions, so the baseline is 3. The description contributes modestly by implying the two inputs are versions of the same piece and may be in different formats, which clarifies that mismatched formats are acceptable.

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

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

States a specific verb and resource: 'Show what changed between two versions of a piece', with the added scope of 'bar by bar, even across formats'. This clearly distinguishes a diff operation from siblings like convert, render, or transpose. It stops short of naming a sibling it could be confused with, which keeps it from a 5.

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

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

Usage is only implied: an agent infers it should call this when it needs a difference between two versions. The phrase 'even across formats' implicitly tells the agent it does not need to call convert first, which is a useful hint. There is no explicit when-not guidance or named alternative.

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

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

Annotations declare a non-read-only, non-idempotent, open-world operation, and the description goes further by disclosing the verification behavior and the exact result signals (confidence level, share of notes kept, lost features, repaired exporter quirks). That is meaningful context beyond the annotations, though it never states whether a file is created/persisted server-side or any cost/latency implications of open-world fetches.

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

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

Front-loaded with the core action, split into a purpose line and a result line, with zero filler sentences. Slightly dense phrasing ('exporter quirks that were repaired on the way in') but nothing that should be cut.

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?

An output schema exists, so return values need not be re-explained, and the description already frames the verification semantics well. The gap is input-path ambiguity: for a tool where the score can arrive by URL, by upload link, or inline text, the description never says which of `file`/`content` is needed, which is the main thing an agent could get wrong.

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 explains `to`, `file`, `content`, and `filename`; the description only loosely restates the target-format set. It adds no help on the important choice between `file` and `content` (mutually alternative input paths) or how `filename` interacts with `content`, so it does not 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 gives a specific verb+resource ('Convert a score between formats') and enumerates the two output modes (notation formats vs. sheet music/audio), which makes the tool's function immediately graspable. It stops short of distinguishing itself from the overlapping sibling `render` (which plausibly also produces pdf/png/svg/wav), so the agent must infer the boundary.

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

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

Usage is implied by describing what the conversion does plus the note-by-note verification, but there is no explicit when-to-use vs. when-not guidance. With siblings like `render`, `validate`, and `compare` present, an agent gets no rule for choosing `convert` over those; the verification clause in particular muddies the line with `validate`.

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

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

The annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description's 'save ... as new files' usefully corroborates that this writes new output rather than modifying the source, but it says nothing about where files land, naming/collision behavior, or cost/limits of an open-world operation.

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

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

A single tight sentence with the action and the two selectable dimensions front-loaded and no filler. Nothing in it is redundant or wasted.

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

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

Although an output schema exists and the schema is fully documented, the tool has seven optional parameters and zero required ones, yet the description never explains that a source must be supplied via either 'file' or 'content' nor how each_part changes the output cardinality. For a file-producing tool that distinction is material, so the definition is adequate but incomplete.

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

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

Schema description coverage is 100%, so every one of the seven parameters is already documented, including bar-range syntax and the 1-based parts convention. The description adds only the general notion of selecting parts and bars, not new semantics beyond the schema, so the baseline of 3 applies.

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

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

The description gives a specific verb ('save ... as new files') and a specific resource ('chosen parts and/or bars of a score'), so the operation is unambiguous. It stops short of distinguishing itself from siblings like convert or render, which also produce new output files, leaving the agent to infer the boundary.

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

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

Usage is only implied by the phrase 'chosen parts and/or bars' — it suggests extraction of a subset, but there is no explicit statement of when to pick this over convert, transpose, or render, and no prerequisites or exclusions are 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?

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety and remote-access profile is covered. The description adds that the response is part summary and part ABC notation excerpt, which is useful framing beyond the annotations. It does not disclose the source-selection rule (file vs content) or what happens when neither is supplied, which is the main behavioral unknown.

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

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

A single front-loaded sentence with the core action first and the summary contents enumerated after the colon; no filler. The list of fields is dense but each item earns its place by telling the agent what comes back. Slightly long as a raw enumeration, which keeps it from 5.

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

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

An output schema exists and all five parameters are schema-documented, so the description needn't restate return values or argument syntax. However, with zero required parameters and both file and content optional, the description omits the crucial constraint that a score must be supplied via one of them, and says nothing about how the two sources interact. That leaves a real gap for a 5-parameter open-world 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 every parameter is already documented with defaults and examples such as '1-8' and 'tune.abc'. The description reinforces that bars are rendered as ABC notation but adds no new meaning about file, content, filename or parts. Baseline 3 is appropriate when the schema carries the semantics.

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

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

States a specific verb (summarise) and resource (a score), and enumerates exactly what the summary contains: title, parts with instruments and ranges, key, meters, tempos, bar count, plus ABC notation for a bar range. That is far more concrete than the vague name/title 'inspect'/'Look at a score'. It stops short of differentiating itself from siblings such as extract or render, so it lands at 4 rather than 5.

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

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

There is no when-to-use guidance at all: nothing says this is the orientation step before compare/transpose/validate, and no sibling is named as an alternative. The only implied usage comes from the word 'inspect' and the summary framing. An agent must infer routing from the enumerated output fields alone.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real content beyond that: the listing covers both read and write directionality and per-format capability gaps, telling the agent the response carries lossiness caveats rather than just names. It does not discuss freshness or whether the list is static.

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

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

A single short clause with zero padding, front-loaded on the formats themselves. It is a noun phrase rather than a full sentence, which leaves the action slightly implicit, but nothing is wasted or buried.

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 zero-parameter, read-only discovery tool with an output schema already documenting the return shape, this is sufficient: scope (reads and writes) and the most decision-relevant nuance (formats' limitations) are both stated. No further information is needed to call it correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is 100% and the empty schema matches the description's no-argument framing.

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

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

The description identifies the resource precisely: the set of formats Scoreproof reads and writes, plus per-format limitations. Combined with the title 'List supported formats', an agent can tell this is a catalog/discovery tool distinct from the action-oriented siblings (convert, validate, render). It stops short of naming a sibling or stating the verb itself in the description body.

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

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

There is no explicit when-to-use or when-not-to-use instruction. Usage is only implied: mentioning 'what each one cannot hold' hints that this should be consulted before choosing a target format for convert or validate, but the agent must infer that ordering itself.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, and the description is consistent with them: it labels the output 'download links', which explains the non-read-only profile. However it omits link lifetime, whether artifacts are persisted, and any cost/rate limits for the WAV path, which is what an agent would still want to know.

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

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

Two short sentences, zero filler, with the primary engraving mode front-loaded and the audio variant trailing. Nothing could be removed without losing 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?

With an output schema present, return-value detail is rightly omitted, and the description covers both output families adequately. The notable gap is that with 0 required parameters, nothing states that one of 'file' or 'content' must be supplied, or how they interact — a real omission for a 5-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?

Schema coverage is 100% and each parameter already carries a description (including the enum meanings for 'to' and 'page_size'), so the schema does the heavy lifting. The description only restates the format list, adding no new semantics such as the relationship between 'file' and 'content' or when 'filename' matters.

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?

Uses a specific verb ('Engrave sheet music') plus the alternative audio mode, and enumerates the concrete output formats (PDF, PNG, SVG, WAV). It never distinguishes itself from the sibling 'convert', which an agent could plausibly reach for on the same input, so it stops short of a 5.

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

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

'to print or view' versus 'audio preview' implies the two use cases, but there is no explicit when-to-use/ when-not guidance and no mention of the alternatives among siblings (convert, transpose, extract). The agent must infer routing from the format list alone.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the agent knows this is a non-idempotent operation that may reach outside the server. The description adds the mode-exclusivity constraint but never says what is actually produced or whether the input score is modified, which matters given readOnlyHint=false. No contradiction, but limited added 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?

Two sentences, front-loaded with the capability and closed with the constraint. Every clause earns its place and nothing is repeated from the schema.

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

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

With seven optional parameters and a defaulted output format, the description covers the mode choice but is silent on the parallel exclusivity between file and content as the score source, and on the to parameter that controls output format. The output schema covers return values, so that omission is acceptable, but the input-side ambiguity remains.

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

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

Schema coverage is 100%, so the per-parameter docs (interval formats like "M2" / "-3", key examples, pitch enum, content formats) already carry most meaning. The description nevertheless contributes the one rule the schema cannot express — that interval, key and pitch are mutually exclusive — which is genuine added value beyond the structured fields.

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

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

"Transpose a score by an interval, into a key, or between concert and written pitch" names a specific verb and resource and enumerates the three operational modes, which map cleanly onto the interval/key/pitch parameters. It does not explicitly distinguish itself from siblings like convert or render, so an agent must infer the boundary itself.

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

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

"Give exactly one of interval, key or pitch" is a concrete invocation rule that selects among the three modes and is not enforced structurally by the schema (every property is nullable and nothing is required). There is no guidance on when to prefer this over convert, nor on choosing between file and content as the score source.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered without description help. The description usefully adds what gets inspected, but says nothing about behavior an agent needs to reason about - notably what happens if both 'file' and 'content' are omitted, or whether findings are advisory only. No contradiction with annotations.

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

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

A single front-loaded sentence with the verb and resource first, then the specifics. Every clause earns its place; the only small cost is that the enumerated list is dense and slightly runs together, but nothing is padded.

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

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

An output schema exists, so return values need not be described, and the annotations cover safety. What remains missing is exactly the thing an agent must get right to invoke it: how 'file', 'content' and 'filename' combine, given zero required parameters. Adequate but with a real operational gap.

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

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

Schema description coverage is 100%, so all three parameters are documented in the schema itself, establishing the baseline of 3. The description adds no meaning about the file-vs-content relationship despite all parameters being optional, leaving the mutual-exclusivity/at-least-one rule unstated in both places.

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

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

Names a specific verb ('check') and resource ('a score') and enumerates the three defect classes it looks for (exporter quirks, bars that do not fill their time signature, out-of-range notes). It does not explicitly distinguish itself from the sibling 'inspect', which an agent could reasonably read as an overlapping diagnostic tool.

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

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

Usage is implied by the enumerated checks - an agent can infer it should call this when it wants correctness problems found rather than a score transformed or rendered. There is no explicit when-to-use statement, no exclusion, and no pointer to 'inspect' or 'compare' as the alternative when the goal is descriptive rather than diagnostic.

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