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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering safety. The description adds 'complete' state, clarifying the scope of the response. While it doesn't mention error behavior or edge cases, the annotations handle the primary behavioral expectations, and the description adds useful context beyond them.

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

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

A single, front-loaded sentence that states the action and scope immediately. There is zero waste—every word contributes to understanding the tool's purpose. It is concise and efficiently structured.

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

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

Given the tool is a simple read operation with an output schema present, the description covers the essential purpose. It does not clarify that neither parameter is required (which is unusual), but the schema covers parameter details. For a read-only tool with annotations and output schema, this is adequately complete, though it could mention that at least one identifier is typically 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?

Schema description coverage is 100%, so both parameters (inputId and inputName) are fully documented in the schema. The description does not add any additional parameter-specific meaning, such as which identifier is preferred or whether both can be used. It remains at the baseline of 3 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 uses a specific verb ('Get') and resource ('complete OBS mixer state'), scoped to 'one audio-capable input'. This clearly differentiates it from siblings like audio_mixer_list (which returns all mixers) and audio_mixer_set (which modifies), leaving no ambiguity about its function.

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 states the tool is for a single input, providing clear context for when to use it (when you need mixer state for one specific input). However, it does not explicitly exclude alternatives or mention when not to use it, such as pointing to audio_mixer_list for all inputs. The context is clear but lacks explicit routing to sibling tools.

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

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

Annotations already declare readOnlyHint, idempotent, and non-destructive, so the safety profile is covered. The description adds useful behavioral detail about the specific audio properties included, which enriches what annotations communicate. It does not contradict any 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 a single well-structured sentence with no filler or redundancy. The action and resource scope are front-loaded, and the field list adds needed detail without bloat.

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 parameterless list tool with a read-only annotation profile and an output schema available, the description provides everything an agent needs to select and invoke it correctly. It is complete and appropriately scoped.

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, so there is nothing for the description to elaborate beyond the schema. This is the baseline-4 case: parameter semantics are fully satisfied by the schema.

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

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

The description uses a specific verb ('List') and resource ('OBS inputs that support audio), naming the included fields (volume, mute, balance, sync offset, monitoring mode, track routing). This clearly distinguishes it from siblings like input_list and audio_mixer_get: it lists audio-supporting inputs with their audio properties, rather than listing all inputs or fetching one mixer.

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 context is clear: use this when you need an overview of all audio-capable inputs and their audio settings. It does not explicitly name alternatives like input_list or audio_mixer_get, nor does it state when not to use it, so the 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 already indicate readOnlyHint=false and destructiveHint=false, so the description doesn't need to restate that. It does add that the tool returns the complete mixer state, which is useful context. However, it doesn't disclose any side effects beyond toggling mute or any limitations.

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 front-loads the primary action ('Toggle mute') and includes the return behavior. 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 an output schema, and the description covers the core action and return. However, it omits clarification on parameter usage (both optional, possibly one suffices), which could confuse an agent. This is a minor gap given the tool's simplicity.

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

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

Schema coverage is 100% with each parameter having a clear description ('OBS input UUID' and 'OBS input name'). The description adds no extra meaning about parameter usage, such as whether one is preferred over the other or if both are needed. It remains at baseline for well-documented schema.

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

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

The description states a specific action (toggle mute) on a specific resource (OBS audio input) and clearly mentions the return of the complete mixer state. It distinguishes from siblings like audio_mixer_get/set by specifying 'toggle' as a unique 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?

No guidance is given on when to use this tool versus audio_mixer_set or audio_mixer_get. The description does not mention any selection criteria, prerequisites, or alternatives, leaving the agent to infer usage.

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 is consistent with the annotations: it states a mutating behavior, matching readOnlyHint=false, and does not contradict destructiveHint=false. It adds a useful list of the mutable properties, but it does not disclose important behavioral details such as whether an input identifier is required or whether omitted properties are left unchanged.

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 with no filler. Every clause contributes either the action, the target resource, or the scope of properties, making it economically structured for an agent to parse.

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 9-parameter mutation tool with zero required parameters, the description is incomplete. It does not mention that an input must be identified via inputId or inputName, nor that at least one property should be supplied, and it leaves the volumeDb/volumeMul distinction unexplained. The output schema partially offsets return-value explanation, but the invocation guidance is still insufficient.

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 only 44%, so the description carries significant parameter-semantics burden. It names property categories like 'volume' and 'mute', but it fails to clarify ambiguous mappings such as volumeDb vs volumeMul, and it does not explain units or the relationship between the two volume parameters.

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 names a specific verb ('Change'), a specific resource ('OBS mixer properties'), and enumerates the exact properties affected: volume, mute, stereo balance, sync offset, monitoring mode, and output track routing. This clearly distinguishes the tool from read-only siblings like audio_mixer_get and audio_mixer_list.

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 no guidance about when to use this tool instead of related tools such as input_audio_set or audio_mixer_mute_toggle. There are no explicit conditions, exclusions, or alternative routes, so the agent must infer usage from the tool name and sibling list.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds minimal behavioral context beyond confirming it returns mute/volume state. It does not contradict annotations and provides slight clarification, but does not discuss edge cases like missing parameters or return 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?

A single, front-loaded sentence with no filler. The key action and target are immediately clear, making it efficient for an agent to parse.

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 getter with output schema and annotations covering safety, the description is mostly complete. It lacks explicit routing to siblings, but that is covered in usage guidelines. The core functionality and target are clear enough for 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% with both parameters described (inputId and inputName). The description adds no additional meaning about parameter usage, such as how to choose between them or whether both are needed. It meets the baseline for high coverage but does not exceed it.

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

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

The description states a clear verb ('Get') and resource ('mute and volume state for an OBS input'). It is specific about what is retrieved, and the 'OBS input' wording distinguishes it from mixer-level tools like audio_mixer_get, though it does not name alternatives explicitly.

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

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

The description implies usage for retrieving per-input mute/volume, but provides no explicit when-to-use vs alternatives like input_audio_set or audio_mixer_get. No exclusions or conditions are given, leaving the agent to infer context.

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

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

The description states the effect (changing mute/volume), consistent with annotations indicating a write operation (readOnlyHint=false). It does not add context about partial update behavior (whether unspecified parameters are left unchanged), the distinction between volumeDb and volumeMul, or any side effects. Annotations cover basic safety, so the description's contribution is limited but not contradictory.

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, direct sentence that immediately conveys the core functionality. It is front-loaded with the action and resource, with zero unnecessary words or repetition. This is exemplary conciseness.

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

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

For a tool with 5 optional parameters and no required fields, the description is too minimal. It does not mention that either inputId or inputName must be provided to identify the target, nor does it clarify how mute and volume interact when both are set. The output schema exists but does not replace critical usage context like partial updates. This leaves significant gaps for an agent.

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

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

Schema description coverage is only 40% (inputId and inputName have descriptions; muted, volumeDb, volumeMul do not). The description does not compensate by explaining these parameters—it mentions 'mute' and 'volume' generically without mapping them to specific schema fields or clarifying units. Agents receive insufficient guidance on parameter selection.

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 (set) and the resource (mute and/or volume for an OBS input), making the purpose evident. It distinguishes itself from generic input_settings_set and mixer-level audio_mixer_set by focusing specifically on input audio properties, though it doesn't name these siblings explicitly.

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 usage is implied: use this tool when you need to adjust mute or volume on an input. However, it offers no explicit when-to-use vs. when-not-to-use guidance, nor does it mention alternatives like input_audio_get for reading or audio_mixer_set for mixer channels. This leaves the routing decision to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the optional filtering behavior but does not disclose details like whether the result is a flat list, whether inputKind values are case-sensitive, or what happens when no inputs exist.

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?

One sentence, front-loaded with the action and resource, and the optional restriction is stated efficiently. 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 read-only list tool with an output schema and strong annotations, the description is nearly complete. The only notable gap is the lack of guidance on valid inputKind values, but the optional parameter and output schema reduce the need for more detail.

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 for the undocumented inputKind parameter. It does add that inputKind restricts the list to one input kind, but it does not specify valid values or format. With only one optional parameter, this is adequate but not rich.

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 ('List') and resource ('OBS inputs'), and notes an optional restriction by input kind. It is clear enough to distinguish from scene_list and media_list, though it does not explicitly name a sibling alternative.

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: listing inputs, optionally filtered by kind. It does not explain when to prefer this over input_settings_get or other input-related tools, nor does it mention any exclusions 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 already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description's role is limited. It adds that the tool returns the input kind and current settings, which is useful, but it does not address potential edge cases like when both params are provided, whether one is sufficient, or error handling. With annotations covering the safety profile, a 3 is appropriate.

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 with no filler. It directly states what the tool does and front-loads the action and resource.

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 (not shown) and simple read-only behavior, so return values are presumably documented there. However, the description leaves ambiguity about parameter usage: with zero required parameters, it is unclear whether at least one must be supplied. This gap could lead an agent to call the tool without an identifier, resulting in an error. For a simple getter, more clarity on the required input would improve completeness.

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

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

Schema description coverage is 100% – both inputId and inputName have clear descriptions in the schema, so the description does not need to repeat them. However, it does not clarify the relationship between the two parameters (e.g., whether either is required, precedence if both are given). The baseline of 3 is justified since the schema carries the parameter information but the description adds no extra semantic guidance.

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

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

The description states a specific action ('Get') and resource ('OBS input kind and its current settings'), making the tool's purpose clear. It does not explicitly differentiate from siblings like input_list or input_settings_set, but the name and description make it evident that this targets a single input's settings, not listing or modifying them.

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

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

Usage context is implied by the description – you use this when you need the current settings of a specific OBS input. However, it does not explicitly state when to prefer this over input_list or input_settings_set, nor does it mention that at least one of inputId or inputName should be 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?

Annotations already convey that this is a write operation that is not idempotent and not destructive. The description adds the valuable behavioral detail that overlay=true preserves unspecified settings, implying that overlay=false may not preserve them. This goes beyond the annotations, though the consequences of overlay=false are not fully spelled out.

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 short sentences with the core action front-loaded. Every phrase contributes either to purpose or to key behavior, with no filler or redundant restatement of the title.

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 four parameters and an existing output schema, the description is minimally sufficient but leaves a noticeable gap: it does not say how to identify the target input when inputId and inputName are both individually optional. The overlay behavior is useful, and annotations cover safety semantics, but an agent still needs to infer target-selection rules.

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 adds meaning for the overlay parameter with 'overlay=true preserves unspecified settings', which the schema does not explain. However, it does not clarify the settings object structure or explain the apparent need to provide either inputId or inputName even though only settings is required. Schema descriptions cover inputId and inputName, leaving the description as a partial but not complete supplement.

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 and resource: 'Apply settings to an OBS input.' This clearly identifies it as a setter and distinguishes it from the sibling input_settings_get. The overlay clarification does not obscure the core 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?

No guidance is given on when to use this tool versus alternatives such as input_audio_set or input_settings_get. The only usage hint is the overlay parameter behavior, which is more about how to invoke than when to choose 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?

Annotations already indicate readOnlyHint=false (mutation) and destructiveHint=false (not destructive), so the safety profile is covered. The description adds that it supports local files and network inputs, and can position/size the new scene item immediately. This is useful but does not reveal side effects like whether existing sources are replaced or whether the source is immediately active. Given annotations cover the mutation nature, this is a reasonable middle score.

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

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

The description is two sentences with no fluff. The primary action is front-loaded in the first sentence, and the second sentence adds key capabilities. Every word earns its place, making it concise and well-structured.

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

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

Despite having an output schema, the tool has 18 parameters and low schema description coverage. The description is too brief to adequately cover the full set of parameters and their interactions. It does not explain behaviors like loop, autoplay, network seekability, or restart on activation. For a tool this complex, the description is incomplete.

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

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

Schema description coverage is only 17% (only source, sceneId, sceneName have descriptions). The description only hints at parameters like position/size (x, y, width, height, fit) and source mode (local/network), but does not explain the many other parameters such as loop, autoplay, speedPercent, clearOnMediaEnd, etc. With low schema coverage, the description should compensate, but it does not provide sufficient parameter-level guidance.

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: 'Create an OBS Media Source in a scene.' It specifies the resource (OBS Media Source) and the context (scene), and it differentiates from sibling tools like media_list and media_remove by using the verb 'Create.' It also adds specific capabilities (local/network inputs, immediate positioning/sizing) that further define its scope.

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

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

The description implies usage—when you need to add media to a scene—but does not explicitly state when to use it versus alternatives like media_play or media_control. There are no exclusions or comparisons to sibling tools, so the agent must infer context from the verb 'Create.' This is adequate 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 indicate a mutating operation (readOnlyHint false). The description lists actions but does not disclose side effects such as whether 'stop' resets playback position or whether 'restart' is equivalent to stop+play. Without explicit behavior notes, the agent must infer from action names.

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

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

A single, front-loaded sentence listing all four actions. No fluff, maximum efficiency.

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?

Adequate for a simple tool, but it omits the requirement that either mediaId or mediaName must be provided (the schema only marks action as required). This is a functional gap; an agent might attempt to call the tool with only an action, which would fail. Output schema exists, so return values are not needed in the description.

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

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

Schema descriptions cover mediaId and mediaName, and the action parameter's enum defines possible values. The tool description adds no extra parameter information, merely restating the actions. With 67% coverage and a self-explanatory enum, the description adds minimal value but is not deficient.

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: playing, pausing, stopping, or restarting a Media Source. It uses specific action verbs and identifies the resource. While it doesn't explicitly differentiate from the sibling media_play, the broader scope is self-evident.

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 media_play. It doesn't mention conditions or exclusions, leaving an agent uncertain whether media_control is preferred for a simple play operation.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds the consolidated nature and lists fields, which is helpful, but does not disclose any limitations like pagination or potential latency. 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?

Single sentence, front-loads the main purpose, and efficiently enumerates the included data categories without redundancy. No filler 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 output schema exists (though not shown), the description need not explain return values. It clearly states what information is available. The presence of an alias (mediaName) is in the schema correspondences. The description is complete for a read-only info 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 are documented in the schema. The description does not add additional meaning beyond what the schema already provides. Baseline 3 applies.

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

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

The description clearly states a specific verb ('Get') and resource ('Media Source information') and enumerates the categories of information included. It does not explicitly differentiate from siblings like media_status, but the consolidation of all source info makes it distinct enough.

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

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

It implies usage as a comprehensive info-gathering tool but does not explicitly state when to prefer it over alternatives or when not to use it. It doesn't name alternatives, but the broad scope suggests it for full details.

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, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds the fact that mediaId is persistent, which is useful for later references but does not describe any other behavior like pagination or filtering. 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?

Two concise sentences with no waste. The purpose is front-loaded, and the mediaId note adds relevant context without fluff. Every sentence earns its place.

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

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

The tool is simple with one optional parameter and has an output schema, so the return format is covered. However, the includeSettings parameter is completely unexplained, which is a notable gap for an agent to know how to use the tool correctly. Adequate but not fully complete.

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

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

Schema description coverage is 0%, and the description does not mention the includeSettings parameter at all. The parameter's meaning is left entirely to inference from its name. With zero coverage and no compensatory explanation, the description adds no value for parameter understanding.

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 'List Media Source (ffmpeg_source) inputs' with a specific verb and resource, distinguishing it from scene_list and input_list. It also notes the persistent mediaId, which differentiates the output semantics from other media tools.

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

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

Usage is implied by the purpose: to list media sources. However, it does not explicitly state when to prefer this over alternatives like input_list or media_info, nor any exclusions. The context of siblings suggests it, but no explicit guidance is given.

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

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

Annotations are all false, offering little behavioral signal. The description discloses the primary action (start playback) and optional adjustments, but omits details like what happens if media is already playing, whether it restarts, or any side effects. It does not contradict annotations, but adds limited context beyond the basic operation.

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

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

A single 14-word sentence that is front-loaded with the primary action ('Start normal playback') and then lists optional modifiers. No filler or repetition; each 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?

The tool has 4 optional parameters but the description does not clarify whether mediaId and mediaName are mutually exclusive alternatives or both needed, nor what happens if neither is provided. It also doesn't mention the output schema, but that exists separately. These gaps make it less complete than ideal for an agent to call 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 covers 50% of parameters (mediaId and mediaName have descriptions). The description compensates by explaining startMs ('seek to startMs before playing') and speedPercent ('change playback speed'), which are otherwise undocumented. This adds meaningful context for the ambiguous parameters, though units for speedPercent are not explicitly stated.

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

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

The description states a specific action ('Start normal playback') with clear optional modifiers (speed and seek). It distinguishes from siblings like media_seek and media_speed_set by combining them, and from media_play_range by implying full playback. The verb and resource are explicit.

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

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

The description implies when to use the tool (starting playback with optional speed/seek) but does not explicitly mention alternatives or exclusions. It doesn't say 'use media_seek for seeking only' or 'use media_play_range for a range'. Guidance is implicit, 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?

The description discloses key behavioral traits: it returns immediately while the server watches the OBS cursor, and at the end it pauses on the exact frame by default or stops. This goes beyond the annotations, which are all false and thus provide no behavioral hints. However, it doesn't mention how speedPercent or pollIntervalMs affect execution, nor does it clarify what happens if both mediaId and mediaName are omitted. Still, the core behavior is well explained.

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 long, front-loads the primary purpose, and includes essential behavioral details without fluff. Every word earns its place, and the structure is efficient.

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

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

Given the complexity (7 parameters, low schema coverage, output schema exists), the description is incomplete. It does not explain how to identify the media (mediaId vs mediaName, or that one is needed), nor does it clarify the role of speedPercent or pollIntervalMs. It also doesn't mention what the return value indicates, though the output schema covers that. For a tool with this many parameters, more context is needed to call it correctly.

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

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

Schema description coverage is low (29%), so the description must compensate. It adds meaning to startMs/endMs (defines them as the range), endAction (pause/stop), and implicitly the default behavior. It does not explain speedPercent or pollIntervalMs, but those are somewhat self-explanatory and have constraints in the schema. Given the coverage gap, the description provides meaningful semantics for the most critical parameters.

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 plays a specified time range ([startMs,endMs]) on a media source, using the verb 'play' with a specific resource. It also distinguishes this from general media_play (which plays the whole media) and media_seek (which jumps to a position) by focusing on range playback. The sibling tool names reinforce this differentiation.

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

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

The description implies usage for playing a segment, but it does not explicitly state when to use this over alternatives like media_play or media_seek. It also doesn't mention prerequisites (e.g., requiring a mediaId or mediaName to identify the source) or scenarios where this tool is inappropriate. The 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 already indicate mutating, non-idempotent, and non-destructive behavior. The description adds the optional pause side effect, but it does not disclose what happens when pause is false (e.g., whether playback continues) or what occurs if no active range is present. It adds some context beyond annotations but lacks depth.

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 front-loads the core purpose and includes the optional pause behavior. Every word earns its place; there is no wasted text or redundancy.

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

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

The tool has 3 parameters with none required, yet the description does not clarify that at least one of mediaId or mediaName must be provided to identify the media source. It also does not specify behavior when no active range exists. Although an output schema exists (not shown), the ambiguity around parameter usage is a significant gap for a mutating 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 descriptions cover mediaId and mediaName (67% coverage), which is high enough to warrant a baseline of 3. The description itself adds no parameter information, and pause lacks any schema description. Since the description does not clarify parameter relationships (e.g., that at least one identifier is needed), it does not elevate the score.

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

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

The description clearly states the action (cancel) and the target (active range enforcement for a Media Source), distinguishing it from siblings like media_play_range (which starts a range) and media_control (general control). The verb is specific and the resource is well-defined.

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

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

The description implies usage when an active range exists, but it does not explicitly mention when not to use it or compare against alternatives like media_play_range or media_control. There are no stated exclusions or conditions, so an agent must infer the appropriate context.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description doesn't need to repeat basic mutability. It adds value beyond annotations by disclosing the cascade effect on scene items and by limiting the target to Media Source inputs, which are not inferable from the structured data.

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

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

A single sentence with no filler, front-loaded with the action verb. Both phrases, 'Media Source input' and 'all of its scene items,' carry necessary information, so 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?

Output schema and annotations cover return values and destructive side effects, but a practical gap remains: the schema lists both parameters as optional while the description does not clarify that at least one of mediaId or mediaName is needed. An agent could reasonably attempt a call with no arguments. This is a notable missing piece for a destructive 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%: mediaId and mediaName are already documented as the OBS input UUID and media input name. The description adds no guidance on selecting between the two parameters or on the fact that both are listed as optional in the schema, so it provides no semantic value beyond what the schema already gives.

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 precise verb ('Delete') and resource ('a Media Source input'), and expands the scope with 'all of its scene items,' which clearly differentiates it from sibling tools like scene_item_remove. This makes the tool's function 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 cascade wording ('and all of its scene items') gives an agent clear context for choosing this tool over scene_item_remove, which removes only a single scene item. It does not explicitly state when not to use the tool, but the scope is clear enough for correct selection.

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

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

Annotations provide only false hints, so the description carries the behavioral disclosure burden. It does not mention side effects on playback, whether the media input must exist or be playing, clamping behavior, or whether repeated seeks accumulate. It only restates the core seek operation without adding deeper 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 a single sentence with no wasted words. It front-loads the core action and immediately communicates the key mode distinction, making it easy to parse and act on.

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 mediaId/mediaName already documented, the description is adequate for basic invocation. Yet it lacks sibling differentiators, usage context, and behavioral side effects, which are important given the large set of closely related media tools. It is minimally viable but not fully complete.

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

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

Schema description coverage is 50%, and the description adds useful meaning for `milliseconds` (millisecond cursor) and `mode` (absolute vs relative). However, it does not clarify whether mediaId and mediaName are alternatives, which takes precedence, or how they relate to the required `milliseconds`, so it only partially compensates for the schema's 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 a specific action ('Seek a Media Source') and precisely defines the two behaviors: seeking to an absolute millisecond cursor or applying a relative offset. It is unambiguous about the resource being seeked, but it does not explicitly differentiate this from closely related siblings like media_play_range or media_control.

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

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

There is no guidance on when to use media_seek versus alternative sibling tools such as media_play, media_play_range, or media_control. The description explains what the tool does, including the absolute/relative modes, but does not state prerequisites, exclusions, or alternative selection 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?

Annotations indicate a mutation tool (readOnlyHint=false) but are sparse. The description adds critical behavioral context: 'OBS restarts/reinitializes the media when this setting changes,' which is not disclosed by annotations. This warns the agent of a disruptive side effect. 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?

Two sentences: the first states purpose and range, the second discloses the side effect. Both are front-loaded and essential, with zero redundancy. The description is efficiently structured for quick agent parsing.

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

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

The description covers the core action and its notable side effect. However, it omits guidance on choosing between mediaId and mediaName, which is not clear from the schema either. Since an output schema exists (not shown), return values are not a concern. The missing parameter-selection context makes it incomplete for an agent to confidently call 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 covers mediaId and mediaName with descriptions, but speedPercent lacks a description in the schema. The description clarifies speedPercent as a percent with range 1-200, adding some value. However, it does not explain the relationship or selection between mediaId and mediaName, leaving ambiguity for a key parameter choice. With 67% coverage, this is adequate but not thorough.

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 ('Set') and resource ('Media Source playback speed') with an explicit range (1-200). It clearly distinguishes from siblings like media_play or media_control by focusing on speed adjustment. The side-effect note further clarifies its unique role.

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 use for changing playback speed but does not explicitly differentiate from alternatives such as media_control or media_play. There is no mention of when to use this tool versus others, nor any exclusions or prerequisites beyond the implicit need for an existing media source. The side-effect warning is useful but not a usage guideline.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the specific data points returned (state, duration, cursor, range-playback metadata), which is useful context beyond the annotations. It does not disclose any additional behavioral traits (e.g., behavior when both parameters are omitted), but given the read-only nature, this is acceptable.

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 front-loads the core purpose and enumerates the specific outputs. There is zero waste; 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?

The tool has only two optional parameters and an output schema exists, so return values do not need to be described. The description covers the essential function and the annotations cover safety. It does not clarify how to choose between mediaId and mediaName or what happens if neither is provided, but these are minor gaps for a simple read-only getter.

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

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

Schema description coverage is 100%, with both parameters (mediaId and mediaName) clearly documented in the schema, including that mediaId is an OBS input UUID. The description adds no additional parameter meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states a specific verb ('Get') and resource ('media playback state') and enumerates the exact data returned (state, duration, cursor, active range-playback metadata). This clearly distinguishes it from sibling tools like media_info (which likely covers general media metadata) and media_play/media_seek (which modify state).

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 that this tool is for retrieving playback state, implying its use when that information is needed. It does not explicitly name alternatives or exclusions, but the purpose is unambiguous and no competing sibling is obviously intended for the same task. The lack of explicit 'when not to use' is a minor gap.

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, idempotentHint, and destructiveHint=false, so the safety profile is well-covered. The description adds the specific return payload (versions and range playbacks), which goes beyond annotations. It does not mention connection management or error cases, but for a read-only status fetch this is adequate.

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, well-structured sentence that front-loads the action (Connect to OBS) and then states the output precisely. There is no redundant information, and 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?

For a zero-parameter tool with an output schema already provided, the description covers all necessary knowledge: what it does, what it returns, and implicitly its read-only nature. Nothing is missing to decide whether to invoke it. It is fully self-contained.

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 zero parameters and 100% schema description coverage, meaning there is nothing for the description to add. With no parameters, the baseline is 4, and the description correctly remains silent, avoiding unnecessary filler.

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 a concrete action (connect to OBS) and the exact resource, then enumerates the output (OBS/obs-websocket versions plus active range playbacks). It clearly separates this status tool from siblings like scene_list or media_play, making its 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 implies usage when connection status, versions, or range playback state are needed, but it does not explicitly state when to use it versus alternatives or provide exclusions. With multiple sibling tools, this ambiguity could be improved, though this is the only status-centric 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false. The description adds no behavioral context beyond 'create' – it doesn't mention whether creating a scene with an existing name fails or overwrites, whether it affects the current scene, or any side effects. With annotations covering the safety profile, a 3 is appropriate – the description adds minimal behavioral context but doesn't 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?

One sentence, zero waste, front-loaded with the verb and resource. The description is appropriately sized for a simple create operation.

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 create tool with one parameter and an output schema, the description is mostly complete. However, it doesn't address edge cases like duplicate scene names or whether the new scene becomes active. The output schema exists, so return values are covered. The missing behavioral context (duplicate handling) is a minor gap for a create operation.

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

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

Schema description coverage is 0%, so the description must compensate. The description mentions 'scene' but doesn't explain the sceneName parameter beyond what the schema provides (type string, minLength 1). The parameter name is self-explanatory, but the description adds no additional meaning about naming conventions, uniqueness, or format. Baseline 3 is appropriate given the single self-explanatory parameter.

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

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

The description states a clear verb and resource: 'Create a new OBS scene.' It is unambiguous and distinguishes itself from sibling tools like scene_delete and scene_set_current. However, it doesn't explicitly differentiate from scene_list or other scene-related tools, though the verb 'create' makes the purpose obvious.

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: use this tool when you need to create a new OBS scene. It doesn't explicitly state when not to use it or mention alternatives, but the context of sibling tools (scene_delete, scene_set_current) makes the usage context reasonably clear. No explicit exclusions or alternative routing.

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 destructiveHint=true, so the agent knows this is destructive. The description adds no further behavioral context such as irreversibility, cascading effects on scene items, or confirmation steps. It restates the basic action but provides no extra insight 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 a single sentence that front-loads the action ('Delete') and resource, followed by the selection method. There is no unnecessary wording, making it concise and easy to parse.

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 deletion tool with two optional parameters and an existing output schema, the description is largely sufficient. It could mention that at least one identifier is needed, but the schema implies that, and the destructive nature is covered by annotations. Overall, it meets the needs for 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 description coverage is 100%, with both sceneId and sceneName documented in the input schema. The description adds no additional meaning about parameter usage, such as whether one is required or what happens if both are provided. Since the schema already covers parameter semantics, the description provides minimal added value.

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

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

The description uses the specific verb 'delete' with the resource 'OBS scene' and the method 'by UUID or name', which clearly distinguishes it from sibling tools like scene_create (create) and scene_list (list). An agent can immediately identify the action and target.

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 is provided about when to use this tool versus alternatives, nor any exclusions or prerequisites. While the name and description make the purpose obvious, there is no mention of conditions like needing at least one of sceneId or sceneName, or when to prefer a different 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?

Annotations already declare readOnlyHint=false and destructiveHint=false, indicating a mutating but non-destructive operation. The description adds only that it enables or disables, which is consistent with the annotations. It does not disclose additional behavioral details such as reversibility or side effects, but for such a simple toggle this is acceptable. 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 a single concise sentence with no unnecessary words. It is appropriately front-loaded, stating the action immediately. However, brevity comes at the cost of completeness, which is penalized elsewhere.

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

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

For a tool with 4 parameters and 50% schema coverage, the description is insufficient. It does not explain how to obtain sceneItemId, the meaning of enabled, or any expected output. While an output schema exists, the description should still provide enough context for an agent to call the tool correctly without prior knowledge.

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 only 50% (sceneId and sceneName have descriptions, but sceneItemId and enabled do not). The description provides no additional meaning for any parameter. It does not explain that sceneItemId identifies the specific item (likely from scene_item_list) or that enabled sets visibility. Given the low coverage, the description fails to compensate.

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 (enable/disable) and the resource (scene item). It is distinguishable from siblings like scene_item_remove or scene_item_transform_set, though it does not explicitly name alternatives. The title 'Show/hide scene item' reinforces the intent, but the description alone is sufficient to convey the core 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?

There is no guidance on when to use this tool versus alternatives. It does not state prerequisites (e.g., obtaining a sceneItemId via scene_item_list) nor any exclusions. An agent must infer usage from the name and context. This is a significant gap for a tool in a large sibling set.

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 signal a non-read-only, non-idempotent mutation, and the description adds useful coordinate semantics: index 0 is bottom. It does not disclose side effects on other items' z-order or behavior when the index is out of range. No contradiction with annotations exists.

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 one efficient sentence plus a clarifying coordinate note. It is front-loaded with the operation and contains no filler or redundant restatement of the title.

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 reorder mutation with an output schema and annotations, the description covers the core semantics. The main remaining gap is optional sceneId/sceneName disambiguation and index bounds, but these are not severe enough to make the tool unusable.

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 only 50%, and the required parameters sceneItemId and index lack schema descriptions. The description adds meaning to index by tying it to z-order and bottom position, but it does not clarify how sceneItemId is obtained or whether it is scoped to a scene.

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 and resource: 'Set scene item z-order.' This clearly identifies the operation and distinguishes it from sibling tools like scene_item_transform_set or scene_item_enabled_set, which affect other scene-item properties.

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 clarifies how to interpret the index value ('OBS index 0 is the bottom'), which is useful usage context. However, it does not explicitly say when to use this tool, when not to, or that scene_item_list should be used to obtain sceneItemId values. There are no direct sibling alternatives for z-order, so the gap is mild.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no further behavioral detail (e.g., error handling, ordering, or scope limits). Given the strong annotation coverage, the bar is lower, and the description meets it without adding significant value beyond purpose restatement.

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 with no filler. It states the core function efficiently. It could potentially be expanded with a brief note on parameters, but for a simple list operation, this length is appropriate.

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 that likely describes the return format, so the description need not explain return values. However, it lacks guidance on the optional parameters (e.g., providing both vs. one, error behavior when neither is given) and doesn't mention the distinction between sceneId and sceneName. These gaps are notable for an agent deciding how to invoke the tool correctly.

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

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

Schema description coverage is 100% – both sceneId and sceneName have descriptions in the schema. The tool description adds no additional meaning or usage notes about these parameters (e.g., which to use, mutual exclusivity, or default behavior). This is the baseline 3 since the schema already documents them.

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 a specific verb ('List') and resource ('source/item in a scene'), which distinguishes it from sibling tools like scene_list (lists scenes) and input_list (lists inputs). However, it doesn't explicitly contrast with those siblings or clarify that 'source/item' refers to scene items that reference sources, leaving slight ambiguity for agents unfamiliar with OBS terminology.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., scene_list, input_list). The optional nature of both parameters (sceneId and sceneName) is not explained – the description doesn't say what happens if both are omitted or which one takes precedence. An agent receives no direction on parameter selection or exclusion criteria.

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

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

Annotations already declare destructiveHint: true, so the destructive nature is known. The description adds a specific behavioral detail—that the underlying input is not deleted—which is valuable and not captured by annotations. This goes beyond the baseline without contradicting 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 a single sentence that is front-loaded with the core action and the crucial nuance about not deleting the input. There is no wasted wording, and it efficiently communicates the essential information.

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

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

The tool is simple (one required parameter) and has an output schema (indicated). The description covers the primary action and the key nuance. The optional sceneId/sceneName usage is clear from the schema, and the output schema covers return values. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 67%, with sceneId and sceneName having descriptions, but sceneItemId (the required parameter) lacks a description. The tool description does not explain any parameters or clarify how sceneItemId should be obtained. Since coverage is above 50%, a baseline of 3 is appropriate, but the description adds no additional parameter 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 states a specific action (remove), a resource (scene item), and a key distinguishing nuance (without deleting the underlying input). This clearly differentiates it from scene_delete and other scene-item operations, making the tool's purpose immediately 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 implies usage for removing a scene item while preserving the input, but it does not explicitly name alternatives or conditions for when to use this tool over siblings like scene_item_enabled_set or scene_delete. The nuance about not deleting the input gives context, but no explicit exclusion or alternative is provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to repeat safety. It does add the specific data points returned, which is useful. However, it does not mention behavior on invalid IDs, conflict resolution between sceneId and sceneName, or any side effects. Given annotations cover the safety profile, this adds moderate value but not deep behavioral insight.

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 leads with the verb and resource, then lists the exact attributes retrieved. There is no filler or redundant wording, making it efficient and immediately scannable.

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?

This is a simple getter with an output schema that likely documents the return structure. Annotations cover the safety profile. The description clearly states what data is returned, which is sufficient for an agent to invoke it correctly. The only minor gap is the lack of error-handling or prerequisite context, but given the tool's simplicity and the presence of an output schema, this is not a significant omission.

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 67%: sceneId and sceneName have descriptions, while sceneItemId does not. The description does not add any parameter-level explanation, such as clarifying that sceneItemId is required or that sceneId and sceneName are alternatives. Since coverage is moderate and not low, the baseline of 3 applies; the description does not compensate for the missing sceneItemId description but also does not need to heavily compensate.

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 'Get' and the resource 'scene item placement', and enumerates the specific properties retrieved (position, size, scale, crop, rotation, bounds). This distinguishes it from the sibling setter 'scene_item_transform_set' and the list tool 'scene_item_list', making its 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 implies this is a read-only getter for transform data, but it does not explicitly state when to use it versus alternatives, nor does it mention that it complements the setter. There is no guidance on choosing between sceneId and sceneName, but that is parameter-level. The usage context is clear from the name and description, but explicit exclusion of alternatives is missing.

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

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

All annotations are false, so the description carries full burden. It states it 'sets' properties, implying mutation, but does not disclose whether it is a partial update (only provided params changed) or a full reset of unspecified properties. It also doesn't mention potential side effects or error conditions. This is a significant gap for a mutating tool.

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

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

Two sentences, front-loaded with the purpose and then a key clarification about width/height and fit modes. No redundant information, every word earns its place. Very efficient.

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

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

With 15 parameters and 13% schema coverage, the description is far from complete. It does not mention that sceneItemId is required, does not explain units or defaults for most parameters, and does not clarify whether the operation is incremental or overwriting. The description is insufficient for a complex tool like this.

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 only 13%, so the description must compensate. It adds meaning for 'width+height use OBS bounds' and explains the 'fit' enum values (contain, cover, stretch). However, it does not clarify semantics for scale, rotation, crop, or how to specify the scene (sceneId/sceneName). It provides partial added value but leaves many parameters unexplained.

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 'Set' and the resource 'scene item', listing the specific transform properties (position, size, scale, rotation, crop). This distinguishes it from sibling tools like scene_item_transform_get (get) and scene_item_remove (remove). No ambiguity about what it does.

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

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

The description implies this tool is for modifying transform properties, and the sibling list shows scene_item_transform_get for reading. However, it does not explicitly state when to use this over alternatives, nor does it mention prerequisites or exclusions. The usage context is implied but not explicitly 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds behavioral detail beyond annotations by stating that the current program/preview scenes are identified as part of the result. No contradiction exists.

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 with no filler. Every phrase adds value, covering both the list action and the additional current-state identification.

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 tool with an output schema present, the description is fully adequate. It states what the tool returns and what additional information it provides, and the annotations cover safety and side-effect expectations.

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, so the schema is trivially complete and the description does not need to explain inputs. The baseline of 4 applies because there are no parameters to describe and no parameter documentation burden.

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 ('List') and resource ('OBS scenes'), and further specifies that it identifies the current program/preview scenes. This clearly distinguishes it from siblings like scene_create, scene_delete, and scene_item_list, which operate on different resources or actions.

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

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

The description provides clear context: it is the tool to call when an agent needs the scene list and the current program/preview selection. It does not explicitly name alternatives or exclusion conditions, but the context is unambiguous enough for a zero-parameter read 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 annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the agent knows this is a non-read, non-destructive, non-idempotent operation. The description adds no extra behavioral context, such as whether the switch takes effect immediately or whether the scene must exist. Given the annotations carry the safety profile, a score of 3 is appropriate—the description does not contradict annotations, but it also does not enrich them.

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 leads with the action and resource, and immediately mentions both parameter modes. There is no fluff or redundant phrasing—every word earns its place. It is efficiently front-loaded for quick agent parsing.

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 (though not shown here) and fully documented parameters, but the description omits important usage nuances. It does not clarify what happens if both sceneId and sceneName are provided (e.g., precedence), whether the scene must already exist, or whether any parameter is required (schema shows both optional). For a mutation tool that changes the live program state, an agent would benefit from at least a note that the scene should be valid. The description is minimal and leaves these details ambiguous.

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%—both sceneId and sceneName have descriptive text in the schema ('OBS scene UUID' and 'OBS scene name'). The description only reiterates that the target can be specified by UUID or name, adding no new meaning about parameter priority, mutual exclusivity, or whether at least one is required. Since the schema already documents the parameters, the baseline of 3 is correct; the description offers marginal extra value.

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

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

The description states a specific verb ('Switch') and a clear resource ('current program scene'), and it explicitly mentions the two ways to specify the target ('by UUID or name'). This clearly distinguishes it from sibling tools like scene_list (which lists scenes) or scene_create (which creates scenes), so an agent can tell what it does without inspecting the schema.

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

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

The description implies when to use the tool—when you need to change the active scene—but it does not explicitly mention alternatives or exclusions. It does not say, for example, 'Use scene_list first to find available scenes' or 'Do not use this to create or delete scenes.' The usage context is inferable from the tool name and sibling list, but there is no explicit 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 readOnly, idempotent, and non-destructive. The description adds that it returns MCP image content directly, and that omitting a source captures the current program scene. These details go beyond annotations and inform the agent about output format and default behavior, which is valuable. No contradictions 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 two sentences, front-loaded with the core action and return type, followed by a useful default behavior. No unnecessary words; every part adds value.

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

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

The tool has six parameters, none required, and low schema coverage. The description does not explain width, height, format, or quality, nor does it mention potential error conditions. However, the output schema likely describes the image return, and the tool is relatively simple. Still, with low schema coverage, the description should have provided more parameter guidance to be fully complete.

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

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

Schema description coverage is only 33% (only sourceName and sourceId have descriptions). The description does not compensate for the undocumented width, height, format, and quality parameters. It only clarifies that source can be a scene or input, which is already partially in the schema descriptions. With low schema coverage, the description should have explained the meaning and defaults of the other parameters, but it does not.

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 captures a scene or input via OBS GetSourceScreenshot and returns it as MCP image content for AI vision. It specifies the resource (scene/input) and the action (capture), and notes the default behavior when no source is given, which distinguishes it from all sibling tools that manage scenes/inputs but do not capture screenshots.

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 the fallback behavior when no source is specified, which is a usage guideline. It does not explicitly list alternatives, but since this is the only screenshot tool among siblings, that omission is acceptable. It could have stated 'use when you need a visual snapshot' but the mention of 'for AI vision' implies the use case.

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