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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds the constraint that it operates on a single bounced render and clarifies the read-only nature in prose ('Read-only'), which reinforces rather than merely repeats the annotation. The behavioral burden is largely on annotations here, and the description adds value by scoping input to a rendered WAV rather than arbitrary audio.

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

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

Three short sentences, front-loaded with the core purpose and metrics, followed by a usage directive. Zero filler or wasted words. The sibling differentiation is compactly embedded in the same lines.

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

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

For a single-input read-only analysis tool, the description is complete: it lists what metrics are returned, scopes input to a single render, and names the folder-level alternative. An output schema exists, so return-value details are covered structurally. The only minor gap is not describing the shape of the spectral band energy output, but the output schema presumably covers that. Given low complexity and full annotation coverage, this approaches 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 description coverage is 100% — the single 'path' parameter is already well documented as a rendered WAV file with path resolution. The description reinforces that it should be a 'bounced render' (adding slight semantic nuance beyond the schema's 'rendered WAV file'), but beyond that it adds minimal parameter-level detail. Baseline 3 is appropriate given full schema coverage.

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

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

The description states a specific verb+resource ('Analyze a rendered WAV file into mix metrics') and enumerates the metrics produced (loudness LUFS/LRA, RMS, peak, spectral band energy, stereo width). Clearly distinguishes from the sibling analyze_render_dir, which is a folder-level version. This is exemplary purpose clarity.

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 'Use on a single bounced render' and explicitly names the alternative: 'For a whole folder of renders, use analyze_render_dir instead.' This is exactly the when/when-not/alternatives guidance the rubric rewards.

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 provide readOnlyHint=true and idempotentHint=true, which covers the safety profile. The description reinforces this with an explicit 'Read-only diagnostic' statement and adds what the tool produces (conflict pairs with suggestions). It adds value beyond annotations by describing the nature of the analysis and its output.

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

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

Two short paragraphs, both front-loaded with the core purpose first, then the actionable output, then the usage context. Zero waste—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 an output schema present, good annotations (readOnly, idempotent), and 100% parameter schema coverage, the description is complete for what's needed. It covers purpose, output nature, and when to run it. No significant gaps for a diagnostic tool.

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

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

Schema description coverage is 100%, so both parameters (pattern, render_dir) are already well-documented in the schema with defaults and clear descriptions. The description adds no additional parameter-specific semantics beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Analyze...reported which pairs are fighting for the same frequency band') with clear resource scope (rendered tracks). It gives examples of what it detects (bass vs sub, snare vs bass) and the output type (actionable suggestions). It clearly distinguishes from siblings like auto_mix by being diagnostic.

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 says 'Run before auto_mix to plan EQ/ducking decisions', naming a sibling tool as the alternative/next step. It provides when-to-use context (before mixing decisions) but doesn't explicitly state when NOT to use it beyond implying it's a diagnostic that precedes auto_mix.

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 idempotentHint=true, so the safety profile is clear. The description adds context that this is a read-only batch analysis and names the prerequisite relationship (before auto_mix/preview_mix), which goes beyond the annotations. It's a batch operation over a directory which is a meaningful behavioral disclosure.

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

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

Compact and well-organized: first sentence states purpose, second clarifies the batch nature and relationship to analyze_audio, third gives explicit workflow timing. Zero wasted words, information is front-loaded.

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

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

Despite being a simple one-parameter tool, the description is complete: purpose, data input expectations, relationship to alternatives, and workflow placement are all covered. An output schema exists, so return-value explanation isn't required. Nothing significant is missing for effective use.

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

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

Schema description coverage is 100% and there's only one parameter. The description reinforces the directory/parameter by restating the 'one WAV per track' constraint and the default renders/ directory, but doesn't add substantial new semantics beyond what the schema already documents. Baseline 3 is appropriate with full coverage.

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

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

Description clearly states verb+resource+scope: 'Analyze every WAV in a directory of rendered tracks'. It explains the context (bounced Ableton tracks, one WAV per track) and explicitly differentiates from siblings as the 'batch variant of analyze_audio', distinguishing its 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 timing guidance: 'Run this before auto_mix or preview_mix so the renders are measured against the style profile.' It names sibling tools (analyze_audio, auto_mix, preview_mix) and positions this tool's role in the workflow, effectively distinguishing when to use the batch variant vs the single-file variant.

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 discloses the mutating behavior of dry_run=False ('APPLY the volume/pan corrections to the Live set (mutating!)'), complements the destructiveHint=true annotation. It also discloses external dependencies (Ableton Live, AbletonOSC) and the offline capability of dry runs. It could add details on whether the operation is reversible or what happens to the Live set state, but the description plus annotations give a solid picture.

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

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

The description is well-structured with a concise one-line purpose, an Args section, a Returns line, and a clear usage directive. Every sentence earns its place. Slightly verbose with the line breaks and formatting, but information-dense and front-loaded with the purpose statement. Not quite maximal efficiency but close.

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

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

With an output schema present and 100% parameter coverage, the description needs less. It covers the core safety protocol (dry_run first), external dependencies, and output shape. For a mutating tool with destructiveHint=true, the key gap would be whether corrections are reversible or how the user validates results post-application, but given the strong annotations, schema, and output schema, it's reasonably complete.

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

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

Schema coverage is 100%, so the bar is set at baseline 3. The description adds value by explaining the render_dir semantics ('one WAV per track, bounced from Ableton'), clarifying pattern as the file-matching glob, and grounding dry_run as a safety toggle returning recommendations vs applying changes. It reinforces but also enriches schema descriptions, particularly for render_dir and dry_run.

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 'Auto-mix rendered tracks toward a musical style' with a specific verb+resource. It lists the action (auto-mix), the inputs (rendered WAV tracks), and the output (per-track corrections and master notes). It distinguishes itself from siblings like analyze_render_dir (which analyzes) and preview_mix (which previews) by being the action tool that applies corrections.

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 directs usage: 'Call with dry_run=True first to review the recommendations; only use dry_run=False to apply them to the Live set.' It also states prerequisites (Ableton Live + AbletonOSC for dry_run=False) and that the dry run works offline. This provides clear when-to-use and when-not-to-use guidance, plus the two-step safety protocol.

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 idempotentHint=true, covering the safety profile. The description adds that it returns 'basic project info,' which is some behavioral context. It doesn't specify what happens on connection failure (error vs. degraded status), but with a read-only idempotent check tool, the annotation coverage is adequate and the description adds modest value.

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, complete sentence that conveys the tool's purpose with zero wasted words. Front-loaded with the primary action (check connection) and secondary detail (return project info). Appropriate for a zero-parameter diagnostic tool.

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

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

For a zero-parameter, read-only, idempotent status tool with an output schema, the description is largely complete. It covers purpose and return content. It could arguably mention failure behavior (what happens if Ableton isn't connected), but given the tool's simplicity, annotations, and output schema, this is a minor gap.

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

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

This tool has 0 parameters, so there's nothing for the description to explain beyond confirming it's a no-argument request. The description's mention of returning project info clarifies the output behavior. With no parameters, the description doesn't need to add parameter semantics, and it appropriately stays silent.

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 what it does: checks the connection to Ableton Live and returns basic project info. The verb 'check' with specific resource 'Ableton Live' is clear. However, it doesn't explicitly distinguish from siblings like analyze_audio or preview_mix, though given the tool name and single-purpose nature (status check), differentiation is reasonably implied.

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 it's a pre-flight/diagnostic tool for verifying Ableton connectivity, but doesn't explicitly state when to use it (e.g., before other Ableton-dependent operations) or when not to use it. Given sibling tools like analyze_audio and auto_mix likely depend on Ableton, some usage context would help but it's not critically misleading.

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 idempotentHint=true, so the safety profile is covered. The description adds the 'Read-only' confirmation (redundant with annotations) and clarifies the list->fetch sequencing dependency, but doesn't elaborate on the output structure beyond the general content types, which is partially covered by the output schema. It adds modest 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?

Three sentences, all earning their place: the first defines what is returned, the second declares read-only safety, the third provides the critical usage sequence. Zero filler or redundant verbiage. Well-front-loaded with the purpose before the context.

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 single simple parameter, full schema coverage, an output schema, and read-only annotations, the description is nearly complete. It could arguably note what happens when an invalid/unknown style name is passed, but for a straightforward profile-fetch tool with such clean annotations, this is essentially fully specified. The only minor gap is error-handling behavior for unknown names.

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 input schema already explains that the style parameter is a name like 'techno' or 'breaks' and points to list_styles. The description reiterates this dependency but adds minimal new meaning beyond what the schema provides. Baseline 3 is appropriate given full schema coverage.

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

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

Clearly states the verb ('Get'), resource ('full profile for a style'), and scope ('spectral curve, track balance, compression and FX recommendations'). Effectively distinguishes from siblings like list_styles (which lists names) and analyze_audio (which analyzes audio rather than fetching a named style profile).

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

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

Explicitly instructs the agent to call list_styles first to see available names, then pass one to this tool. This provides a clear when-to-use and sequencing directive. The implicit contrast with list_styles (which merely lists) clarifies when this tool is the right choice — when a detailed profile is needed.

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 idempotentHint=true, so the read-only behavioral trait is covered structurally. The description reinforces this with 'Read-only.' and adds the discovery workflow context. With strong annotations, the description adds value by framing the tool's role as an entry point rather than repeating safety traits.

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

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

Three short sentences, zero waste. Front-loaded with the core purpose, then the behavioral note, then the usage directive. Every sentence earns its place.

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

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

For a zero-parameter discovery tool with both readOnlyHint and idempotentHint annotations plus an output schema, the description fully covers what's needed: what it returns (styles with targets), how it fits the workflow (call first, feed results elsewhere), and its safety profile (read-only). Nothing essential is missing.

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

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

The tool has zero parameters and schema coverage is 100% trivially (empty properties object). No parameter documentation is needed since there are none. The description correctly focuses on the output relationship (style names feeding into other tools) and what 'targets' are included in results, which provides the value the schema can't.

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?

Clear purpose: 'List all available mixing styles with their targets.' Specific verb (list) + resource (mixing styles) + scope (all, with targets). Distinguishes from siblings since get_style retrieves a single style while this lists all, and suggest_style recommends one. Slight deduction because it doesn't explicitly contrast with suggest_style's purpose, but the verb+resource+scope is strong.

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?

Excellent guidance: 'Call this first to discover style names; pass one to get_style, auto_mix or preview_mix.' This explicitly says when to use it (first, for discovery) and tells the agent which sibling tools consume its output. This is a model of usage direction.

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

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

Annotations provide readOnlyHint=false (mutation), idempotentHint=true, destructiveHint=false. The description adds meaningful context: it writes a NEW file (output_path description explicitly says 'source renders are never modified'), and confirms it operates fully offline. However, the description doesn't dwell on behavioral details that annotations already cover, and the added content (WAV creation, normalization behavior) is genuinely useful beyond the schema.

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

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

The description is front-loaded with a clear action sentence followed by parameter explanations in a structured list format. It's moderately long but every sentence earns its place - context for max_duration and sidechain_db adds real value. Slight redundancy with schema parameter descriptions, but the overall structure is well-organized.

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 7-parameter tool with 100% schema coverage and an output schema present, the description is comprehensive. It covers the workflow context (preview before applying in Live), offline capability, normalization behavior, and the key nuance around mismatched render lengths. The contrast with auto_mix rounds out the tool's place in the broader workflow.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters. The description adds some value by explaining the max_duration and sidechain_db semantics in context (loops vs full arrangement mismatch), but most parameter meanings are already clear from the schema field descriptions. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states that the tool applies style corrections to rendered WAVs and bounces a stereo preview mix, specific verb+resource (Apply+Bounce) with clear scope ('volumes + pans applied to audio, summed, normalized'). It distinguishes itself from siblings by explicitly contrasting with auto_mix with dry_run=True for recommendations.

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 explicit when-to-use guidance: 'Use this to listen to the mix before applying anything in Live; for recommendations only, use auto_mix with dry_run=True.' It also names the alternative, making it clear this is for listening/previewing rather than recommendations, and explicitly notes it works fully offline as long as render WAVs exist.

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 idempotentHint=true and destructiveHint=false, and readOnlyHint=false. The description complements these by explicitly stating 'Read-only for your audio files; it may write a preview WAV when output_path is omitted,' which clarifies the actual write behavior and resource effects beyond what annotations convey. It doesn't detail authorization needs or rate limits, but the read-only caveat plus idempotency is solid disclosure.

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

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

Three tight paragraphs, zero filler. Each paragraph earns its place: first explains the core operation and metrics, second clarifies the read/write behavior, third gives sequencing guidance. Front-loaded with the core purpose 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?

For a complex tool with 4 parameters, conditional behaviors (output_path vs. style), and a quality-gate semantic, the description covers the key decision points: metric targets measured, read/write footprint, when to run, and parameter interactions. The output schema exists to convey return structure, and sibling differentiation is handled. No significant gaps remain.

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

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

Schema description coverage is 100%, so all four parameters are documented in the schema. The description adds behavioral context about how style and output_path interact (style optional when output_path points at existing WAV), which supplements the schema meaningfully. However, there's no information about acceptable glob formats for pattern or how render_dir interacts—beyond what the schema's own descriptions already state.

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 runs a quality gate measuring the mix against top-label targets (LUFS, LRA, true peak, RMS, spectral tilt) and returns a ready/needs_work verdict. This distinguishes it from siblings like analyze_audio (generic analysis) and preview_mix (rendering) by framing it as a label-standard qualification gate.

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 says 'Run this last, after preview_mix, to decide whether the mix is release-ready,' providing clear sequencing guidance relative to siblings. It also explains the output_path conditional behavior—when to provide an existing file vs. when preview rendering occurs—giving concrete decision criteria.

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

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

The description states 'Read-only,' which aligns with and reinforces the readOnlyHint annotation. Rather than contradicting, it adds value by confirming the non-destructive nature and framing the output as a suggested profile name to be consumed by sibling tools. With both readOnlyHint and idempotentHint annotations present, the description's disclosure is adequate—it adds the context of what the output is used for.

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 tight and effective. The first line states the primary function, and the second paragraph gives targeted usage guidance and output flow. Every sentence earns its place—no filler, no repetition of schema details, appropriately 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 has an output schema (which the description needn't explain), a read-only safety profile covered by annotations, and full parameter documentation in the schema. The description covers the essential behavioral context—what it does, when to use it, and how the result flows into auto_mix/preview_mix. This is complete for a tool of this complexity.

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

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

Schema description coverage is 100%, so both parameters (pattern and render_dir) are already documented with their own descriptions including defaults. The description adds no additional parameter semantics beyond what the schema provides. Per the baseline rule for high schema coverage, a 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 what the tool does: analyze rendered tracks and suggest a fitting style profile. 'Suggest which style profile fits best' is a specific verb+resource combination. It's reasonably distinguishable from siblings like list_styles (which lists available profiles) and get_style (which retrieves a specific one), though it doesn't explicitly name those 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 instructs when to use it: 'Use this before auto_mix when you are unsure which style to pick.' It also explains the downstream flow—the returned profile name can be passed to auto_mix or preview_mix. This provides clear context on when to invoke it, though it doesn't explicitly mention when NOT to use it beyond the 'unsure' framing.

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