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

The description confirms the destructive nature (replace entire notes) which aligns with the destructiveHint annotation. It adds behavioral context beyond annotations by specifying the operation replaces all notes.

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 efficient sentences: purpose, alternative, parameter format and precondition. No fluff, front-loaded with action.

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 output schema exists and the tool's simplicity, the description covers purpose, parameter details, precondition, and alternative. 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?

With 0% schema coverage, the description adds significant meaning for the 'notes' parameter by detailing its structure (pitch, start_time, etc.). However, 'clip_index' and 'track_index' lack additional semantics beyond their 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 'REPLACES the clip's entire note content', providing a specific verb and resource. It distinguishes itself from the sibling 'edit_notes' by contrasting replacement vs. subset modification.

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

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

Explicitly contrasts with 'edit_notes' for subset operations, and includes a precondition (clip must exist). This gives clear when-to-use and 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?

Annotations already mark readOnlyHint=true. The description adds that analysis is offline and requires no Live, confirming no side effects. No contradictions.

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?

Description is detailed but front-loaded with key purpose ('Full offline analysis'). Every sentence contributes value, listing specific outputs. Slightly verbose but efficient for the information conveyed.

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 and that an output schema exists, the description covers all necessary aspects: purpose, usage, parameter, and expected outputs. 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?

Schema has 0% description coverage for the single 'path' parameter. The description implies it is the file path but does not specify format or constraints. However, with only one parameter, the description adds sufficient 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 specifies 'Full offline analysis' of .adg or .adv files, listing exact outputs (macros, device tree, samples, etc.). It clearly distinguishes from siblings like adg_summary or adg_edition by detailing a comprehensive analysis.

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

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

Explicitly states 'No Live required,' indicating when to use offline. However, it does not contrast with sibling tools like adg_summary or suggest when not to use this tool.

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

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

Description details the offline classification logic and return of verdict plus driving devices, adding value beyond the readOnlyHint annotation. It explains the tool is a read-only analysis without mutation.

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?

Concise and well-structured: starts with the primary purpose, provides details on the classification criteria, and ends with the returned information. 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 simple classification tool with one parameter and an output schema, the description is complete. It explains the classification logic, criteria, and output content, enabling the agent to use 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?

Only one parameter (path) with schema description coverage at 0%. The description does not clarify that path should be a file path to a .adg/.adv file, leaving ambiguity. The tool expects the agent to infer the parameter's purpose from context.

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 the tool classifies the Live edition needed for a .adg/.adv file based on devices present. Lists specific device examples for suite, standard, and intro, and mentions returning verdict and driving devices. Distinguishes from siblings like adg_analyze or adg_summary by focusing on edition classification.

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?

Implicitly guides when to use: to check if a preset will load on the user's edition before loading it. No explicit when-not-to-use or alternatives mentioned, but the context of compatibility checking 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?

Annotations already mark this as readOnlyHint=true. The description adds important behavioral context: the tool operates offline on saved files, not on a running Live instance. It also details the output fields, helping the agent understand return 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: three sentences front-loaded with the core purpose, followed by a list of output fields and a brief parameter explanation. Every sentence serves a purpose without waste.

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 purpose, parameter meaning, output content, and a key usage constraint (offline). It lacks error handling or format details (e.g., path encoding) but is adequate for a single-parameter tool with an output schema.

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

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

The schema has 0% description coverage, but the description explains the 'path' parameter as 'a filesystem path to a .adg or .adv file'. This adds meaning beyond the raw type (string) and clarifies acceptable file formats. No additional constraints are given, but the explanation suffices.

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: 'Summarize a saved .adg rack or .adv device preset WITHOUT Live running'. It lists specific output fields (name, rack type, etc.), making the function unambiguous. The verb 'summarize' and resource 'adg/adv preset' are specific, and the 'WITHOUT Live running' distinguishes it from sibling tools that may require Live.

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 states the tool works 'WITHOUT Live running', which is a key usage condition. It does not mention alternatives or when not to use it, but the context is clear: for offline summary of preset files.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds further context: 'offline' and 'reviewing a mix without Live', reinforcing the non-destructive, offline nature. No contradictions, and it provides behavioral context beyond annotations.

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

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

The description is a single sentence that is front-loaded with the action ('Read mixing and arrangement detail') and efficiently conveys purpose, scope, and relationship to siblings. No extra words, every part 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?

Given the presence of an output schema (not shown), the description need not detail return values. It sufficiently lists the data read (locators, track volume/pan/automation lanes). While it lacks mention of error conditions or limitations, the tool is simple and the description is adequate for its 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?

There is only one parameter (path) with no description in the schema (0% coverage). The tool description does not add details about the parameter, such as expected format or constraints. However, the parameter is intuitively the file path to the .als file, so the omission is partially mitigated.

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 reads mixing and arrangement details from a saved .als file, listing specific data (locators, track volume/pan/automation lanes). It distinguishes itself from sibling als_summary as a complement, 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 indicates the tool is for offline review of a mix without Live, and it complements als_summary. While it doesn't explicitly state when not to use it or list alternatives beyond als_summary, the context is clear enough for an agent to infer usage scenarios.

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

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

Annotations provide readOnlyHint=true, so no destructive behavior. The description adds that it works without Live running and uses a specific algorithm (Krumhansl-Kessler). This is meaningful beyond annotations. It does not mention error handling or 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 sentences with no redundancy. First sentence states purpose and condition, second explains note pooling behavior, third details parameters. Every sentence is essential and front-loaded.

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

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

The tool is simple and has an output schema (not shown). The description covers input semantics well but does not mention return format or error cases. Overall adequate for the 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 description coverage is 0%, so the description carries full burden. It explains path as filesystem path, weight with listed options (duration, velocity, product, count), and track_index for optional single-track pooling. This adds value beyond schema titles and defaults.

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 detects key/scale of a saved .als file without Live running, using Krumhansl-Kessler algorithm. It specifies the resource (.als file) and action (detect key), and distinguishes from siblings like detect_clip_key which operate on live session. The exclusion of 'WITHOUT Live running' adds specificity.

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 use: for saved .als files offline, with options to pool from all clips or a specific track. It does not explicitly mention alternatives or when not to use, but the context is clear. More detailed guidance on weight selection would improve.

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 (no modification) and destructiveHint=false. The description adds value by specifying it works offline and detailing what differences are reported, enhancing transparency beyond 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 concise (two sentences), front-loaded with the core action, and every part adds 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 has an output schema, the description does not need to explain return values. It covers the key inputs and what the diff includes. Slightly incomplete in not mentioning if there are any prerequisites (e.g., files must exist).

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 coverage, the description must explain parameters. It implies path_a and path_b are file paths to .als files but provides no details on format, validation, or use (e.g., relative vs absolute paths). This is minimal compensation.

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 the tool diffs two .als files and lists specific changes it detects (tempo, time-signature, tracks, per-track deltas). This clearly distinguishes it from sibling tools like als_summary or als_details.

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 indicates it works 'offline' and is 'great for logging what changed between versions', implying when to use it. However, it does not explicitly state when not to use it or compare to alternatives.

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

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

The description adds value beyond annotations by clarifying that extraction is from saved files, per clip, and that no Live installation is required. It does not contradict annotations (readOnlyHint: true). However, it omits potential edge cases like file version compatibility or multiple clips.

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 with critical information front-loaded: the core function in sentence one, a key parameter detail in sentence two. No extraneous 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 output schema exists, description covers return format and prerequisite (track_index from als_summary). Minor gaps: no mention of file size limits or encryption state, but adequate for a simple extraction 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 0%, so description must compensate. It explains track_index as 'the track's position in the set (see als_summary)', adding context. However, path is left without description beyond its type, missing explanation of expected format (e.g., full file path).

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 (extract MIDI notes), the source (track in a saved .als file), and the output format (dictionaries per clip). It distinguishes from sibling tools like 'get_clip_notes' (which requires Live) by noting 'No Live required' and by targeting offline .als files.

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 through the reference to 'see als_summary' for track_index, but does not explicitly state when to use this tool versus alternatives (e.g., get_clip_notes for live sessions). No exclusion criteria or alternative tool names 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 indicate readOnlyHint=true, so the description reinforces that the tool is offline and non-destructive. It adds specific behavioral details about the checks performed (no master limiter, empty tracks, etc.), which provides useful context beyond the annotations.

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

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

The description is very concise at two sentences, with the purpose and key checks front-loaded. 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 the simplicity (one parameter, readOnly annotation, output schema exists), the description is reasonably complete. It explains the tool's purpose, specific checks, and that it returns machine-readable issues. The presence of an output schema reduces the need to describe return values.

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

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

The single parameter 'path' has no description in the input schema (0% coverage). The tool description does not elaborate on the parameter, such as file format constraints or whether relative paths are acceptable. The meaning is only inferred from the tool name and usage context.

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 lints a saved .als file for likely-unfinished work, listing specific checks (no master limiter, MIDI track without instrument, etc.). It distinguishes itself from sibling als_ tools by focusing on identifying unfinished work before rendering.

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 before rendering by mentioning 'returns machine-readable issues so an agent can decide what to fix before rendering.' However, it does not explicitly state when not to use this tool or provide alternatives among the many sibling tools. The guidance is implied but not explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be safe. The description adds value by disclosing that no Live runtime is required and what data is extracted, enhancing the agent's understanding.

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-loaded with the main action, no extraneous words. Every sentence earns its place by stating the purpose and the key constraint ('No Live required').

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

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

For a read-only listing tool with one parameter and an existing output schema, the description fairly covers what the tool does and what it returns. It could mention file existence requirements, but those are typical and implied.

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 must compensate, and it does by implying the 'path' parameter refers to a '.als file' and listing the extracted clip attributes. It could explicitly state the file format expectation, but the context is sufficient.

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 specifies the exact action ('List every track') and resource ('saved .als file') with detailed attributes of clips. It clearly distinguishes from sibling tools like 'als_summary' by noting 'No Live required' and the scope of listing all tracks with clips.

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 (when needing to enumerate tracks and clips from an .als file without Live). It implicitly excludes other ALS tools by its specificity, but could explicitly mention alternatives for contrast.

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

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

Annotations already indicate read-only; the description adds that it works without Live and details what information is extracted, providing useful behavioral context beyond annotations.

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

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

The description is a single sentence with a follow-up on the parameter, efficiently covering the tool's purpose and key detail 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 presence of an output schema, the description adequately covers input and functionality. It lacks mention of prerequisites or side effects, but for a static analysis tool this is acceptable.

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, but the description clarifies that 'path' is a filesystem path to a .als file, adding necessary meaning that the schema lacks.

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 summarizes a .als file without Live running, listing specific fields. It implies a distinction from tools that require Live, but does not explicitly name alternatives like 'als_details'.

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 context for use (when Live is not running), but does not provide guidance on when not to use it or how it compares to similar tools such as 'als_details' or 'als_list_tracks'.

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

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

Beyond the readOnlyHint annotation, the description discloses no upload, no file modification, no normalization, partial-result marking for truncated analysis, and the caveat that decoding compressed files does not recover lost audio. This is exemplary 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 dense but efficient: supported formats and measured metrics come first, followed by limits, caveats, and safety guarantees. Every sentence adds meaningful information with no filler.

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

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

With an output schema available, return-value documentation is already covered. Description addresses input requirements, analysis scope, safety behavior, and known limitations. An agent has enough context to decide when and how to call this tool correctly.

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

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

Schema description coverage is 0%, so the description carries the parameter documentation burden. It explains max_seconds thoroughly: default 30, maximum 120, only the first segment analyzed, and partial results marked. It also clarifies that 'path' refers to a local file path, though it never names the parameter directly.

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 strong verb, 'Measure', and specifies the exact resource: local audio files in named formats with a precise set of metrics. The phrase 'without Live' helps differentiate it from in-session analysis tools like analyze_mix.

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 scopes when the tool applies: local files, certain formats, and a max_seconds window. However, it does not explicitly name alternatives or state when NOT to use this tool, such as pointing to analyze_mix for live session analysis.

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

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

Annotations declare readOnlyHint=true, and the description reinforces this by stating 'Reads the session; changes nothing.' It also adds useful behavioral context: results are heuristic, machine-readable 'finding leads,' and external routing or Arrangement audio may explain the reported states. This goes beyond the minimal annotation coverage.

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 tight sentences with no filler. The key differentiator ('NOT audio, peak, LUFS...') is front-loaded, and each sentence earns its place by covering scope, examples, interpretation context, and read-only behavior.

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

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

For a no-parameter, read-only analysis tool with an output schema, the description is complete. It states what it checks, what patterns count as findings, what external conditions may explain them, that results are machine-readable, and that the tool mutates nothing.

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 accepts zero parameters, so there are no parameter semantics for the description to clarify. With schema description coverage at 100% on an empty schema, nothing additional is required.

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-resource pairing: it scans the current live set for heuristic session-state inspection leads. It explicitly distinguishes itself from audio analysis by stating 'NOT audio, peak, LUFS or headroom measurements' and names concrete patterns it detects, so it is clearly separable from siblings like analyze_audio_file.

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

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

The description gives clear context for when the tool is appropriate: use it to find inspection leads in the current session rather than to measure audio levels. It states an explicit exclusion ('NOT audio, peak, LUFS...') but does not name an alternative tool or provide a when-not-to-use recommendation beyond that, so it falls just short of full routing guidance.

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

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

The description adds behavioral context beyond annotations: it adds new tracks, does not overwrite existing ones, and attempts to load instruments. The destructiveHint annotation is consistent with adding tracks being a permanent change.

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, front-loaded with the key action, and every sentence adds 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?

The description covers input, behavior, side effects, and relationship to list_recipes. An output schema exists, so return details are not needed. It is nearly 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?

With 0% schema coverage, the description compensates by explaining `name` is a recipe from list_recipes, giving examples, and stating tempo/key/scale/bars override defaults. 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 clearly states the tool scaffolds a genre starter, listing specific actions: set tempo, add Drums/Bass/Chords MIDI tracks, load instruments, write parts. It distinguishes from sibling tools like generate_bassline by being a one-call composite.

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 use the tool (for quick genre template) and mentions `name` comes from list_recipes. It also notes it adds tracks without overwriting, providing context. However, it lacks explicit when-not-to-use or alternative 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?

The description explains the behavioral state (orange 'Back to Arrangement') and the action of returning control, which adds value beyond the annotation 'destructiveHint=false'. It does not contradict annotations.

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

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

The description is a single, clear sentence that immediately states the purpose and context. Every word is necessary and 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?

Given the tool has no parameters and an output schema exists, the description adequately explains the purpose and usage context. It could optionally mention that the action is reversible, but it is sufficient as is.

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 no parameters, and schema coverage is 100%. The description does not need to add parameter information; a baseline of 4 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 action (return playback control to the Arrangement) and specifies the resource (Arrangement) and the context (after Session clips have overridden arrangement content, the orange state). It distinguishes itself from siblings like 'switch_to_arrangement_view' by focusing on control return rather than view switching.

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 (after Session clips have overridden arrangement content). However, it does not explicitly state when not to use it or mention alternatives, though the context is sufficient for an informed decision.

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

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

Beyond the destructiveHint annotation, description adds atomic-like behavior details: stops at first error, completed steps are a single undo away. Also mentions auto-translation of command names. Does not cover full error response format.

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

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

Well-structured and front-loaded with key idea. Slightly redundant with examples but overall efficient. 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?

Covers main points: purpose, usage, limitations (non-batchable tools), format. With output schema present, return value explanation is not needed. Could mention batch size limits or more error details.

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?

Despite 0% schema description coverage, the description fully defines the commands structure with examples: array of objects with 'type' and 'params', and notes auto-translation of names. Compensates completely for schema gap.

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

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

Description clearly states the tool runs several commands in one round-trip and undo step. It uses specific verbs 'run' and 'batch', and distinguishes from sibling tools by being a batch operation vs individual commands.

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

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

Explicitly says when to use (prefer for multi-step edits) and when not to use (composite tools are not batchable). Provides alternatives by listing non-batchable tools by name.

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 'snapshot ... into a new scene' is non-destructive, consistent with destructiveHint: false. It adds context about capturing current playing clips but does not detail edge cases (e.g., no clips playing) or naming conventions.

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 immediately conveys the action and context. No 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 tool has zero parameters and an output schema exists, the description provides essential information. It could mention what happens if no clips are playing or how the new scene is named, but overall it is fairly 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?

No parameters are present (schema coverage 100%). The description adds meaning by explaining the tool's purpose, which is sufficient since no parameter details are 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 description clearly states the tool's action: 'Snapshot the currently playing Session clips into a new scene'. The phrase 'keep that combination' workflow distinguishes it from siblings like 'create_scene' (which creates an empty scene) and 'fire_scene' (which triggers playback).

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 via 'keep that combination' workflow, suggesting it is for preserving current clip arrangements. However, it does not explicitly state when to use this over alternatives like 'create_scene' or when not to use it.

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 set destructiveHint=false, indicating a non-destructive operation. The description adds context about the prerequisite (armed/monitored track) and implies the tool reads MIDI playback without side effects. It does not contradict annotations and provides useful behavioral context beyond the annotation.

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 core action, and every word is meaningful. No wasted 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?

For a simple parameterless tool with an output schema, the description adequately covers the action and prerequisite. The output schema handles return values, so no further detail is needed.

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 no parameters, and schema coverage is 100% trivially. Per rubric, with 0 parameters, the baseline is 4. The description does not need to add parameter info.

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: 'Grab recently played MIDI into a new clip (Live's Capture MIDI).' It uses a specific verb ('grab') and resource ('recently played MIDI', 'new clip'), effectively distinguishing it from siblings like create_midi_track or capture_and_insert_scene.

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 prerequisite ('Requires that MIDI was recently played into an armed/monitored track') but does not explicitly guide when to use this tool versus alternatives or when not to use it. Context is clear but lacks exclusions.

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

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

Annotations declare destructiveHint=true and idempotentHint=true; description adds that it removes all automation points (not a time range), manual parameter state remains, and undo can recover accidental clears. This context goes beyond 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?

Three sentences, front-loaded with the core action, followed by prerequisite, behavior, and recovery. Every sentence is necessary and informative, with 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 4 required parameters, output schema exists, and destructive behavior, the description covers all essential aspects: what it does, prerequisite, behavioral details, and recovery path. Completely adequate for safe and correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by instructing use of get_device_parameters to resolve the 'parameter' argument, which is not obvious from the schema alone.

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 verbs ('Delete...entire automation envelope') and resource ('one device parameter...from a clip'), clearly distinguishing it from siblings like write_automation and undo. It also mentions the prerequisite tool get_device_parameters, reinforcing its focused purpose.

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

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

Provides explicit prerequisite ('Resolve the device and parameter with get_device_parameters first') and contrasts with alternatives (write_automation for replacing envelope, undo for recovery). Does not explicitly state when not to use, but the context and exclusions are 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?

Annotations indicate destructiveHint=true. The description reinforces this by mentioning 'discard material' and 'copy notes', which imply modification. It adds useful behavioral context like transposition behavior and pitch=-1 meaning all pitches.

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, using a single sentence with a list of operations. It front-loads the core purpose ('Structural clip edits') and efficiently packs details about each operation. Minor improvement could be breaking into clearer bullet points.

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 8 parameters (3 required) and presence of an output schema, the description covers the main operations and relevant parameters. It is sufficiently complete for an experienced user, though some edge-case behaviors (e.g., error handling) are not 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?

Schema description coverage is 0%, but the description explains the key 'op' parameter with examples and clarifies pitch=-1. It also provides context for region_start, region_length, destination_time within duplicate_region. Other common parameters (track_index, clip_index) are not described but are typically well-understood.

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 performs 'Structural clip edits' and lists three specific operations (duplicate_loop, crop, duplicate_region) with brief explanations. It distinguishes itself from sibling tools like edit_notes or delete_clip by focusing on structural manipulations.

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 what each operation does and when to use them (e.g., 'extend 2 bars to 4 before adding variation' for duplicate_loop). However, it does not explicitly state when not to use this tool or mention alternatives like edit_notes for note-level changes.

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 annotation shows destructiveHint=false, and the description confirms non-destructive behavior by stating 'resume playback.' It also adds specific detail about the playhead position, going beyond the annotation to explain the exact behavior.

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

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

The description is a single, efficient sentence with a parenthetical clarification, front-loading the core purpose. Every word 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 has no parameters and an output schema exists, the description completely explains its action (resume playback) and distinguishes it from a sibling. No further context is needed.

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 zero parameters, the schema coverage is 100%, so the baseline is 4. The description does not need to add parameter information, and the tool's behavior is fully conveyed.

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 'Resume playback from the current position' and distinguishes from the sibling tool 'start_playback' which 'restarts from the playhead's last start point instead.' It uses a specific verb and resource, 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 explicitly contrasts with 'start_playback' to guide when to use this tool (resume vs. restart). It provides clear context but does not elaborate on other situations where it might be inappropriate.

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

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

The description adds behavioral context beyond annotations: it mentions the version dependency, the requirement for an empty clip slot, and the need for an audio track. Annotations only provide destructiveHint=false; the description clarifies the mutation's nature and prerequisites. No contradiction with annotations.

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

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

The description is concise and well-structured: starts with the core action, then version requirement, then parameter list. Every sentence adds value without redundancy. 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 three required parameters, the presence of an output schema, and the single annotation, the description covers all necessary preconditions and parameter semantics. It leaves no obvious gaps for an agent to misuse 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?

With 0% schema description coverage, the description fully explains all three parameters: track_index, clip_index, path. It adds contextual details (absolute path, audio file examples, preconditions) that the schema alone lacks, providing complete semantic 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 clearly states the tool's action: creating an audio clip in an audio track's clip slot by importing a file. It distinguishes itself from siblings like 'create_clip' (which likely creates MIDI clips) and 'set_clip_audio' by specifying the import mechanism and track type. The version requirement adds specificity.

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 preconditions (target track must be audio, slot must be empty, requires Live 12.0.5+) but does not explicitly contrast with sibling tools or state when to use this tool over alternatives. 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?

Annotations indicate non-destructive and non-idempotent; description explains shifting behavior for indices and empty track creation. However, it does not cover corner cases like out-of-bounds indices, but this is minor given schema 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?

Two compact sentences: first states purpose, second explains param behavior and alternatives. 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?

For a simple one-parameter tool with an output schema and clear annotations, the description covers purpose, usage, and behavior sufficiently. No missing elements.

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 a good schema description, and the description adds value by explaining the shifting behavior of indices beyond what the schema provides.

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

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

The description clearly states the action ('Insert an empty audio track at a chosen position') and resource, and explicitly distinguishes from siblings by suggesting alternatives (create_midi_track for instruments/MIDI, create_return_track for send bus).

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 explicit when-to-use (audio track insertion) and when-not-to (use alternatives for MIDI or return tracks), along with parameter behavior for index values.

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 failure conditions and length units beyond annotations (destructiveHint: false). Discloses that clip creation fails if slot occupied or track is audio, adding context. No contradiction with annotations.

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

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

Three sentences: purpose, preconditions/length explanation, and typical usage chain. All sentences are essential, no waste, front-loaded with key 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 purpose, key parameters, failure modes, and usage flow. Output schema exists so return value explanation is unnecessary. Could mention defaults for empty clip (e.g., no notes), but generally complete for this 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 0% coverage, but description explains length parameter in beats (4.0 = one 4/4 bar). It indirectly clarifies clip_index and track_index by referencing 'Session slot' and failure when slot has a clip. Adds significant value for a low-coverage 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?

Description clearly states 'Create an empty MIDI clip in a Session slot', using a specific verb and resource. It distinguishes from sibling tools like create_audio_clip and add_notes_to_clip by specifying MIDI and slot context.

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

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

Explicitly states failure conditions (slot occupied, audio track) and suggests alternatives (pick another clip_index or delete_clip). Provides a typical usage chain: create_clip -> add_notes_to_clip -> fire_clip/duplicate_to_arrangement, guiding when to use this tool.

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

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

The description discloses a side effect (moves playhead to time) and explains the internal reason, adding behavioral context beyond the destructiveHint: false annotation.

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 front-loaded purpose and a separate paragraph for side effects and alternatives, no unnecessary verbiage.

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

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

Given the tool's simplicity, the description covers the main behavior, side effect, and usage context, and output schema exists to handle return values.

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?

While schema coverage is 100%, the description adds important context about the time parameter's side effect and the rename behavior for name, improving understanding beyond the schema alone.

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 creates or renames an Arrangement locator at a specific beat position, distinguishing it from sibling tools like set_arrangement_time and get_locators.

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 explicitly tells the agent when to use alternatives: 'Use set_arrangement_time when only the playhead should move, and get_locators to inspect existing markers.'

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

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

Annotations provide destructiveHint: false, but the description adds no behavioral detail beyond that. It does not mention side effects, default track settings, or error conditions.

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?

Extremely concise: one sentence for purpose and one line for parameter. No extraneous information, front-loaded with the action.

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 one optional parameter and an output schema, the description covers key aspects. Missing details like default track state are minor given the output schema.

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

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

The single parameter 'index' is well explained, with the special value -1 meaning end of list. Given 0% schema description coverage, this adds necessary 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?

Description clearly states the tool creates a new MIDI track in the Ableton session, distinguishing it from siblings like create_audio_track or create_return_track.

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

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

No guidance on when to use this tool versus alternatives such as create_audio_track or create_scene. The description lacks when-not-to-use 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?

Annotations provide destructiveHint=false, and the description adds context by explaining what a return track is (a send bus). It does not contradict annotations. However, no further behavioral details (e.g., permissions, side effects) are given, which is acceptable given the tool's simplicity.

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 13-word sentence with parenthetical clarification. It contains no filler or redundancy. Every word earns its place.

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

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

For a tool with no parameters and an output schema (assumed but not shown), the description is largely complete. It could mention if the tool returns the created track, but the current text is sufficient for basic understanding.

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 no parameters (schema coverage 100%), so the description correctly omits parameter details. With zero parameters, a baseline of 4 is appropriate; the description adds no param info but doesn't need to.

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

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

The description clearly states the verb "Create" and resource "return track", with an explanatory parenthetical defining a return track as a send bus for reverb/delay. This distinguishes it from siblings like create_audio_track or create_midi_track.

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 via the parenthetical explanation (shared reverb/delay), but it lacks explicit when-to-use or when-not-to-use guidance relative to the many sibling tools. Usage is implied but not formally stated.

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

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

The annotation indicates non-destructive behavior. The description adds that index -1 appends at the end, but does not disclose other behavioral traits such as whether an empty scene is created or what happens with invalid indices. It adds some value beyond annotations 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 a single, front-loaded sentence that conveys the essential purpose and key parameter behavior. 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?

Given the tool's simplicity (one optional parameter, output schema exists), the description is largely complete. It does not explain side effects or prerequisites, but the non-destructive annotation and output schema mitigate the need.

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 explains that the index parameter with -1 appends at the end. This adds meaningful context that the schema alone does not provide, effectively compensating for the lack of parameter 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 creates a new scene (row of clip slots). The verb 'create' and resource 'scene' are specific and distinguish it from sibling tools like delete_scene, duplicate_scene, or fire_scene.

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 like capture_and_insert_scene. The description does not mention prerequisites or when not to use it, leaving the agent without decision support.

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

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

Annotations already indicate non-destructive behavior (destructiveHint: false). The description adds the return value detail but does not disclose other behavioral traits like whether it creates a new lane or modifies existing lanes. It adds marginal value beyond 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 extremely concise with two sentences, front-loading the action and purpose. 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 low complexity (one integer parameter, output schema for return count), the description is mostly complete. It states the purpose and return value. A mention of what track_index refers to would improve it.

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

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

The description does not mention the single parameter track_index, leaving its meaning entirely to the schema (which has 0% coverage). Since schema coverage is low, the description should compensate but fails to do so.

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 ('Add a take lane'), the resource (take lane to a track), and the return value ('Returns the new take-lane count'). It distinguishes from sibling creation tools by specifying the unique context of comping takes.

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 comping multiple recorded takes but does not explicitly state when to use this tool over alternatives or provide exclusion criteria. No alternatives 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?

Beyond the destructiveHint annotation, the description discloses the behavioral trait of index shifting, which is important for correct multi-delete operations. This adds value beyond 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?

Two focused sentences with a clear instruction and a critical warning. No extraneous words, and the important note is highlighted in caps.

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

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

Given the simple operation and presence of an output schema, the description covers the essential behavior and the main caveat. It could mention prerequisites like 'arrangement view must be active', but that is likely implicit.

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 only hints that arrangement_clip_index is a position from get_arrangement_clips, but provides no details about track_index or parameter constraints. With 0% schema coverage, this is insufficient for an agent to reliably determine parameter values.

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

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

The description clearly states the verb 'delete' and the resource 'a clip from the Arrangement timeline', with the specific method 'by its position in get_arrangement_clips' list'. This distinguishes it from sibling tools like delete_clip or delete_track.

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 includes a NOTE that explains how indices shift after each delete and advises to re-read get_arrangement_clips between deletes. This provides crucial usage guidance, though it does not explicitly list when not to use or alternatives.

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

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

Annotations only indicate destructiveHint=true. The description adds crucial behavioral traits: it deletes content, leaves slot empty, does not shift indices, and fails on empty slots. It also suggests using undo for reversal, implying irreversibility.

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 efficiently convey purpose, behavior, and usage alternatives. No wasted words, and key information is front-loaded in the first sentence.

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 complexity (2 params, output schema exists), the description covers the action's effect, failure condition, and alternatives. It is complete enough for an agent to correctly 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?

Schema coverage is 100% with descriptions for both parameters. The description does not add parameter-specific details beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states 'Delete the existing Session-view clip in a slot, including its content,' which specifies the action (delete) and the resource (Session-view clip). It also distinguishes from siblings like stop_clip and undo.

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 explicit guidance on when to use alternatives: 'Use stop_clip if the intent is only to stop playback; use undo immediately if the deletion was accidental.' It also notes that it fails for an empty slot, implying when not to use.

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

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

Annotations already mark destructiveHint=true, but the description adds value by explicitly stating that indices shift and advising to re-read the chain afterward, which is crucial behavioral context beyond the annotation.

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-loaded with the core action and immediately providing the critical side effect. Every sentence adds necessary information with no waste.

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 (2 simple parameters, output schema exists, annotations present), the description covers the operation and its important consequence. Missing maybe a mention of the output type, but overall 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. It clarifies that device_index is 0-based, adding meaning to that parameter, but track_index remains unexplained. Partial compensation.

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 deletes a device from a track's chain by position (0-based), which is a specific verb and resource. It distinguishes from siblings like delete_track or delete_clip by specifying 'device' and 'chain'.

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

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

No explicit when-to-use or alternatives provided. The description implies usage for removing devices but doesn't contrast with other delete tools such as delete_track or delete_clip, leaving the agent without guidance.

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

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

Annotations already mark the tool as destructive (destructiveHint=true). The description adds behavioral context: later returns shift down after deletion, which is beyond what annotations provide. No contradiction.

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

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

A single sentence that is front-loaded with the verb and resource. No unnecessary words; every part of the 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?

Given the tool's simplicity (one parameter, destructive action, output schema exists), the description provides sufficient context for an agent to use it correctly. It covers the action, indexing, and side effect.

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 must compensate. The description adds meaning: '0 = Return A' and the shifting behavior, which is not in the schema (only type integer). This helps the agent understand the parameter's semantics.

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

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

The description clearly states the action ('Delete a return track by index') and specifies the resource ('return track') with concrete detail ('0 = Return A'). It distinguishes from siblings like 'delete_track' by specifying the target type and index-based deletion.

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 use the tool: when a specific return track needs to be deleted by index. It does not explicitly mention when not to use it or alternatives, but the sibling 'delete_track' implies the distinction. The context is clear enough for an agent.

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

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

Annotations already mark destructiveHint: true, but the description adds valuable behavioral context: 'Later scene indices shift down by one.' This goes beyond the annotation without contradicting it.

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

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

The description is extremely concise with two sentences, no filler, and front-loaded key information. 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?

Given the tool's simplicity and the presence of annotations and output schema, the description is mostly complete. However, it could mention what happens on invalid indices or the return value for 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 for the parameter scene_index is 0%, and the description does not explain its meaning, range, or required format. The agent must infer from the name alone, which is insufficient.

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

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

The description clearly states the verb 'Delete' and the resource 'scene (row)', and distinguishes from sibling tools like create_scene or duplicate_scene by specifying the action and consequence.

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 implicitly indicates usage to delete a scene but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention prerequisites or alternatives among siblings like delete_track.

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?

Annotation provides destructiveHint=true. Description adds crucial behavioral note about indices shifting down, which is beyond the annotation.

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, no wasted words, front-loaded with purpose. Highly 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?

Adequately covers core behavior for simple deletion with index shift. Output schema exists but description misses permanence or failure conditions.

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

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

Schema description coverage is 0%. Description only indirectly implies track_index meaning via the index shift note. Does not clarify indexing convention or bounds.

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 'Delete a track' clearly, specifying verb and resource. Distinguished from sibling deletion tools by focusing on tracks.

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 vs alternatives (e.g., delete_clip, delete_scene), but name and context imply track-specific deletion.

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. Description adds behavioral context by describing the tool as a map and mentioning orientation, consistent with read-only nature. Does not disclose additional side effects, but annotations cover the safety profile adequately.

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-load the purpose, then add supplementary information about toolsets and alternatives. Every sentence adds value; no redundancy or wasted phrases.

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 zero parameters and presence of output schema, description adequately covers what the tool returns (tool groups, conventions) and how to use it for orientation. It is complete for its intended role as a high-level overview 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?

No parameters in input schema (0 params), so description has no obligation to add param info. Baseline 4 is appropriate. The description does not mention parameters, but none exist to clarify.

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

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

Description clearly states the tool provides a high-level map of server tool groups and conventions, aiding orientation before first call. It distinguishes itself from siblings by explicitly naming alternative tools for specific use cases: get_session_snapshot for live state, analyze_mix for mix problems.

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

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

Explicitly advises using this tool for initial orientation before first call. It provides clear when-not-to-use guidance by directing to get_session_snapshot for current live state and analyze_mix for mix problems, with no ambiguity.

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

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

Annotations declare readOnlyHint=true, and the description adds that it returns guidance (no side effects). It also notes case-insensitivity of device_name. No 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?

Two front-loaded sentences plus parenthetical examples. No wasted words; all information serves a clear 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?

With one parameter, output schema exists, and annotations present, the description fully covers purpose, parameter details, and sibling context. 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?

Schema has no description for device_name (0% coverage). The description compensates by listing example values and stating case-insensitivity, adding essential 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 clearly states it returns 'curated guidance' for an Ableton device, specifying what the guidance includes (parameters, units, values, mixing tips). It also lists example device names, distinguishing it from sibling tools like get_device_parameters.

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

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

Explicitly says to pair with get_device_parameters for live indices and ranges, providing a clear alternative. Context implies when to use: when needing curated insights rather than raw parameter data.

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?

Aligns with annotations (readOnlyHint: true) by stating 'Reads only'. Adds detailed behavioral context: algorithm (Krumhansl-Kessler), return values (best-fit key, confidence range -1..1, margin, runner-up), and weight parameter effect. No contradictions.

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

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

Three sentences, front-loaded with the primary action, no redundant text. Efficiently conveys purpose, behavior, and parameter guidance.

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 adequately covers return values. However, it omits edge cases (e.g., empty clips) and does not explicitly require the clip to be MIDI. Still, it is mostly complete for a straightforward read-only 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 0%, but the description explains the weight parameter's possible values ('duration', 'velocity', 'product', 'count') and its role in pitch-class histogram weighting. For clip_index and track_index, context from the tool name and description implies their meaning as clip identifiers. Adds significant value 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 clearly states the verb 'detect', the resource 'key/scale of one Session MIDI clip', and the algorithm (Krumhansl-Kessler). It distinguishes from sibling tools like 'als_detect_key' and 'detect_session_key' by specifying it operates on a single clip in Session view using track and clip indices.

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 states 'Reads only; changes nothing,' clarifying appropriate use cases. While it doesn't list alternative tools, the context of session clip focus vs. sibling tools like 'detect_track_key' provides implicit guidance. Some explicit when-not-to-use would improve it.

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 'Reads only,' matching the readOnlyHint annotation. It adds context about pooling notes from all MIDI tracks' Session clips and the algorithm used (Krumhansl-Kessler), which goes beyond the annotation.

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 plus a parameter note, all front-loaded with the core purpose. Every sentence adds value with no redundancy or unnecessary details.

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

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

Given the tool's purpose (key detection), the description covers the algorithm, scope, parameter options, and read-only nature. With an output schema present, return values need not be detailed. The description is complete for an AI agent to understand 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 description fully explains the single parameter 'weight,' listing its possible values ('duration', 'velocity', 'product', 'count') and their meaning (histogram weighting). Since the schema provides no enum or description, this adds critical semantic clarity.

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 detects the overall key/scale of the whole set by pooling notes from all MIDI tracks' Session clips using the Krumhansl-Kessler algorithm. This distinguishes it from sibling tools like detect_clip_key and detect_track_key which focus on individual clips or tracks.

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 tool is for detecting the harmonic center of the entire arrangement, implying it should be used when an overall key is needed rather than per-track or per-clip. However, it does not explicitly name alternatives or state when not to use it.

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?

Discloses read-only behavior with 'Reads only; changes nothing,' which reinforces the readOnlyHint annotation. Also mentions the algorithm (Krumhansl-Kessler) and the effect of the weight parameter. No contradictions.

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

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

Four well-structured sentences. First sentence states purpose and method, second provides use case, third explains parameter, fourth states safety. No superfluous words, front-loaded efficiently.

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 (2 parameters, output schema present), the description covers all necessary aspects: purpose, usage, parameter meaning, and behavioral safety. 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?

Schema coverage is 0% (no descriptions in schema), but the description explains the 'weight' parameter with valid options ('duration', 'velocity', 'product', 'count'). The 'track_index' parameter is not described, but it is self-evident from context.

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 the action ('Detect the key/scale'), the resource ('whole track'), and the method ('pooling the notes of every Session clip it holds'). Distinguishes from sibling tools like 'detect_clip_key' and 'detect_session_key' by specifying 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?

Provides explicit use case: 'Useful when a part is spread across several clips.' This implies when to use this tool over single-clip alternatives, though it does not explicitly name the alternatives or state when not to use.

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?

Description explicitly mentions overwriting, consistent with destructiveHint annotation. Adds copy vs move distinction, but lacks details like automation behavior or session-only 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 concise sentences: first states action and side effect, second adds value proposition. 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?

Covers main purpose and side effect, but could clarify scope (session only, same set) and limitations. Output schema exists, so return values are handled.

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% coverage, and description does not explain parameters individually. However, parameter names (src_track, dst_scene) are self-explanatory, mitigating the gap.

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

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

Description clearly states the action (copy a clip), target (any other track/scene slot), and side effect (overwrites destination). Distinguishes from siblings like duplicate_scene or delete_clip.

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?

Implied usage as 'cross-track way to build variations' provides context, but no explicit when-not-to-use or alternatives among many 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?

The description discloses side effects: 'creates new content and increases the scene count; later scene indices shift to make room.' Annotations show destructiveHint: false, which is consistent. No contradictions.

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 only two sentences, front-loaded with the main purpose, and every sentence adds value. No 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?

With one parameter, full schema coverage, and an output schema present, the description covers the tool's purpose, side effects, and alternatives thoroughly. It is complete for an AI agent to understand when and how to use it.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no additional meaning beyond the schema's description of scene_index; it only explains the tool's overall behavior, not the parameter itself.

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 'Insert a copy of one Session scene, including every clip in its row.' It uses a specific verb (insert copy) and identifies the resource (scene). It also distinguishes from sibling tools by mentioning duplicate_track and duplicate_clip_to.

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 tells when to use alternatives: 'Use duplicate_track for a whole track or duplicate_clip_to for one clip.' It also suggests a use case: 'Use the new scene as an editable section variation.'

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 'OVERWRITES whatever already occupies the destination range... like recording over tape - this is also the supported way to REPLACE a section,' adding significant behavioral context beyond the destructiveHint annotation. It also mentions the underlying API and Live version compatibility.

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

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

The description is well-structured with a clear first sentence, behavioral notes, workflow, and parameter list. Every sentence adds value, and the length is appropriate for the tool's complexity.

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 need not explain return values. It covers purpose, behavior, parameters, and typical usage, making it complete for an AI agent to correctly 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?

Despite the input schema having no descriptions (0% coverage), the description explains each parameter: track_index (track owning clip), clip_index (clip slot in Session), destination_time (beat position in arrangement). This fully compensates for the schema gap.

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 'Copy a Session-view clip into the Arrangement timeline,' specifying the exact action (copy/duplicate) and resource (Session clip to Arrangement). It distinguishes from siblings like 'duplicate_clip_to' and 'delete_arrangement_clip' by focusing on the specific Session-to-Arrangement 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 provides a typical workflow (create clip, duplicate_to_arrangement, switch_to_arrangement_view) and explains that it overwrites content, implying use for placement/replacement. It does not explicitly state when not to use it, but the context is clear given the workflow and sibling operations.

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

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

Beyond annotations (destructiveHint=false), the description reveals creation of new content, increase in track count, and index shifting, giving the agent full understanding of 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?

Three sentences efficiently convey core action, side effect, and alternatives. No fluff, front-loaded with the most important information.

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

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

Given the tool's simplicity (one parameter, simple action) and the presence of an output schema, the description covers purpose, side effects, and alternatives comprehensively.

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

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

Schema coverage is 100%, and the description does not add extra semantics to the single parameter (track_index) beyond what the schema already provides. 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 action ('Insert a copy of one regular track, including its devices and clips') and distinguishes from sibling tools by mentioning 'Use duplicate_scene for a Session row or duplicate_clip_to for one clip.'

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

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

Explicitly provides when to use alternatives (duplicate_scene, duplicate_clip_to) and suggests post-duplication actions ('Rename or edit the copy to create a variation').

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 annotation destructiveHint=false indicates the tool is not destructive, and the description aligns by stating 'edit subset' without implying data loss. The description adds value beyond annotations by detailing the matching rule for removal (pitch+start) and that it does not rewrite all notes.

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 consists of two sentences, front-loading the purpose and then detailing parameter structures. Every sentence contributes essential information without redundancy or excess 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 complexity of editing notes with add/remove and the existence of an output schema, the description covers the core functionality well. It lacks explicit explanation for the required indices, but these are intuitive given the context.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the structure for 'add' and 'remove' parameters with specific fields (pitch, start_time, etc.) and the matching rule. However, it does not explain the 'clip_index' and 'track_index' parameters, which are required and could benefit from clarification.

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 edits a subset of notes in a MIDI clip without rewriting all, specifying the add (pitch, start_time, duration, velocity, mute) and remove (pitch, start_time) structures. This distinguishes it from siblings like add_notes_to_clip (which only adds) and delete_clip (which deletes entire clips).

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 usage by explaining the tool edits a subset of notes without rewriting all, and specifies the matching rule for removal. However, it does not explicitly state when to use this tool versus alternatives like add_notes_to_clip, nor does it mention exclusions.

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

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

Annotations idempotentHint=false and destructiveHint=false are not contradicted. The description adds important behavioral context: launching takes Session control, replaces other clips, and may retrigger an already-playing clip.

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, then details and alternatives. 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 is simple, has output schema, and the description covers preconditions, behavior, and alternatives, making it complete for its 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% with descriptions for both parameters. The description does not add extra parameter meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description starts with 'Launch one existing Session-view clip using Live's launch quantization,' clearly stating the verb and resource. It distinguishes from siblings by mentioning fire_scene and continue_playing.

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 states when to use fire_clip ('The slot must contain a clip'), describes its behavior, and provides alternatives: 'Use fire_scene to launch a whole row, or continue_playing for transport only.'

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

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

Annotations are minimal (idempotentHint false, destructiveHint false). The description adds behavioral context: it fires row clips together, can replace/stop clips based on slot launch behavior. This goes beyond annotations, though it could also mention what happens if no clips are in the scene.

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 plus a third for alternatives. No redundant information, front-loaded with the main action. 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?

With one parameter, clear annotations, and an output schema, the description is complete. It explains the launch behavior, replacement/stop effect, and offers alternatives. 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?

Schema description coverage is 100% (the only parameter 'scene_index' is described as 'Zero-based Session-view scene (row) index.'). The tool description does not add new meaning to the parameter; it only reinforces the context. 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 action ('Launch a Session-view scene') and the resource ('scene'), and distinguishes itself from sibling tools 'fire_clip' (single track) and 'start_playback' (Arrangement transport). Verb+resource is specific and 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?

Explicit guidance: use for Session launching, not for single-track or Arrangement transport. Mentions launch quantization and slot behavior, giving clear context on when and how to use.

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 destructive behavior (replacing notes), aligning with the destructiveHint annotation. It also details the algorithm and parameter effects, though some behavioral traits like output summary content are omitted.

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 warning. It is moderately concise, though the algorithmic explanation 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 7 parameters, 0% schema coverage, and an output schema, the description covers the main algorithm and parameter usage. It lacks details on the return value and assumes MIDI clips, but is generally 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?

With 0% schema coverage, the description compensates by explaining key parameters (pitches, note_length, steps, source_clip_index) and their roles. However, track_index, clip_index, and velocity are not elaborated.

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 writes a 'Philip-Glass additive process' into a Session clip, explicitly mentioning it replaces existing notes. This distinguishes it from sibling generative tools like generate_melody or generate_bassline.

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 the tool works with parameters but does not explicitly indicate when to use it versus other generative tools. No when-not or alternative recommendations are provided.

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

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

The description discloses that the tool replaces existing notes, and explains style behaviors (roots, root_fifth, walking, eighth_pump) and octave ranges. Annotations already provide destructiveHint=true, so description adds meaningful behavioral context beyond 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 concise and front-loaded: it states the action and side effect first, then details parameters. 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?

The description covers the main behaviors but omits details on 'beats_per_chord' and does not describe the output format (though output schema exists). The tool has 7 parameters with 0% schema coverage, so more context would be beneficial.

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 adds value by explaining the 'progression' parameter (referencing generate_chord_progression syntax), style options, and octave. However, it does not explain 'velocity', 'clip_index', 'track_index', or 'beats_per_chord', leaving gaps.

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: 'Write a bassline following a chord progression.' It explicitly mentions that it replaces existing notes, distinguishing it from other note-generation tools. Among siblings, it is distinct from generate_chord_progression and generate_drum_pattern.

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 generating basslines but provides no explicit guidance on when to use this tool versus alternatives. It does not include when-not-to-use scenarios or comparisons with 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?

The description adds significant context beyond the destructiveHint annotation, detailing exact destructive behavior: 'creates a clip when the slot is empty; otherwise resizes its loop and replaces every existing note'. This fully discloses the tool's impact.

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 defining purpose and a well-structured second paragraph covering behavior, prerequisites, format, and alternatives. No superfluous content.

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

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

Given the presence of an output schema (making return value documentation unnecessary), the description covers all essential aspects: purpose, destructive behavior, prerequisites, input format, and alternatives. It's fully 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?

With 100% schema coverage, the description still adds value by explaining chord symbol format and listing supported qualities, which is domain-specific guidance not present in the schema. This goes beyond the baseline of 3.

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

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

The description clearly states the verb 'Generate voiced chords and write them into one Session-view MIDI clip', specifying the resource and action. It distinguishes from siblings like add_notes_to_clip and edit_notes by giving explicit alternatives.

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 states when to use the tool (generating chord progressions) and when not to, referencing specific alternatives ('Use add_notes_to_clip for exact notes or edit_notes to preserve existing ones'). It also notes a prerequisite: 'The track must accept MIDI'.

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 annotation destructiveHint=true is already present, and the description explicitly states 'REPLACES the clip's notes if the clip exists,' confirming the destructive behavior. It also details the standard drum map and the effects of swing and humanize, adding transparency beyond 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 short and front-loaded with the main purpose. It uses line breaks to separate key info: purpose, replacement note, parameter details, drum map reference. Every sentence adds value, 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?

Given the tool has 7 parameters and an output schema (not shown but present), the description covers core behavior, destructiveness, style, swing, humanize, and drum map. However, it does not explicitly state whether the clip must already exist or if the tool creates it, and track_index/clip_index are not explained. These are minor 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 0%, so the description must compensate. It explains style (list), swing (meaning), humanize (meaning), and references the drum map. However, it does not explain bars, seed, track_index, or clip_index. While some parameters are common, the description adds moderate value but leaves gaps.

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 writes a genre drum pattern into a Session clip on a Drum Rack track. It specifies the resource (Drum Rack track, Session clip), verb (write/generate), and lists genre styles. It distinguishes from siblings like generate_bassline or generate_chord_progression by focusing on drums and mentioning replacements.

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 style options and explains swing and humanize parameters, implying usage for drum pattern generation. It mentions the standard drum map, giving context for note numbers. However, it does not explicitly state when to use this tool versus alternatives like add_notes_to_clip or write_drum_grid, but the specificity provides clear guidance.

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

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

The description explicitly states REPLACES existing notes (destructive), explains the Euclidean distribution, rotation, humanization, and instrument mapping. This adds significant context beyond the destructiveHint annotation.

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 two sentences front-loading the main action. However, the second sentence is a run-on list of parameter explanations, slightly lacking structure.

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 complexity (10 params, no schema descriptions) and the presence of an output schema and annotations, the description provides enough context for most users. Missing seed and velocity details slightly reduce 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?

The description explains most parameters (steps, pulses, rotate, bars, humanize, instrument) but misses seed and velocity. Since schema coverage is 0%, the description should cover all parameters; missing two is a notable gap.

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 writes a Euclidean (Bjorklund) rhythm into a Session clip, specifying the algorithm and how parameters affect the pattern. It distinguishes itself from siblings like generate_drum_pattern by the Euclidean algorithm focus.

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 Euclidean rhythms but does not explicitly guide when to use this tool versus alternatives like generate_drum_pattern or write_drum_grid. No when-not-to-use or alternative names are provided.

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