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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions 'Optionally pass settings' but does not explain the confirm parameter, potential side effects, prerequisites (e.g., source must exist), or whether adding a filter is reversible. This is a thin disclosure for a mutation 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?

The description is a single front-loaded sentence with no filler. It is concise and to the point, but it sacrifices critical parameter and behavioral details. It earns its place but could be slightly expanded without losing 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?

Given the 5-parameter schema with no inline descriptions, the description is incomplete. It does not explain required parameters or the confirm field, nor does it mention any prerequisites or error scenarios. The presence of an output schema is not enough to compensate for these missing operational details.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It covers source_name implicitly ('to a source') and filter_settings ('optionally pass settings'), but it does not explain the difference between filter_name and filter_kind, the meaning of confirm, or what the filter_settings object should contain. Significant gaps remain.

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

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

The description clearly states the action: 'Add a filter to a source' and provides concrete examples like chroma_key_v3 and noise_suppress_v2. It is specific and distinguishes from sibling tools such as remove_filter, toggle_filter, and set_filter_settings.

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—whenever you need to add a filter to a source—but it provides no explicit alternatives or exclusions. It doesn't mention when to prefer this tool over other filter-related operations, so usage guidance is only implied.

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

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

With no annotations provided, the description must disclose behavior. It only says 'Add', which implies mutation but does not describe side effects, whether the source must already exist, if duplicate additions are allowed, what happens on failure, or how the 'confirm' and 'enabled' parameters affect execution. This is a significant transparency 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?

The description is a single concise sentence, front-loaded with the action and resource. It contains no fluff, but it is perhaps too terse given the missing parameter and behavioral details. It earns its place but does not use the available space to improve clarity.

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

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

Given the tool has 4 parameters, no annotations, and an output schema that is not described, the description is incomplete. It does not explain the optional parameters (confirm, enabled), the prerequisites (source must exist), or the outcome of adding a source. Although an output schema exists, it doesn't make up for the lack of behavioral and parameter context.

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

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

Schema description coverage is 0%, so the description must compensate with parameter explanations. It does not. The schema lists four parameters (source_name, scene_name, confirm, enabled) with no descriptions, and the tool description adds nothing about their meaning or constraints. Even the basic mapping of 'source' and 'scene' to parameter names is trivial and does not clarify behavior.

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

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

The description clearly states the action ('Add'), the resource ('source'), and the target ('scene'), with the clarifying phrase 'existing source' and 'as a new scene item'. This distinguishes it from sibling tools like create_source or remove_source_from_scene.

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

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

Usage is implied by the phrase 'existing source' — it should be used when the source already exists and you want to place it in a scene. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention prerequisites or exclusions. Guidance is limited to what is inferred from the wording.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'Medium risk,' which hints at potential side effects but does not explain what they are—e.g., whether creating a profile with an existing name overwrites it, whether the confirm parameter is required for that, or what happens if the operation fails. This is insufficient for safe usage.

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

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

The description is extremely short—two sentences with no filler. It efficiently conveys the core purpose and a risk level. Every word contributes, and it is front-loaded with the action.

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

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

Despite having an output schema, the tool has no annotations and no parameter descriptions. The description does not cover the confirm parameter's role, overwrite behavior, or any prerequisites. The 'Medium risk' note is a start, but for a mutation tool with a required confirm-flag pattern likely present, it lacks necessary context.

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

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

With 0% schema description coverage, the description must explain the parameters. It does not mention profile_name or confirm at all. While 'profile_name' is self-explanatory, 'confirm' is unclear without explanation—does it confirm overwriting? The 'Medium risk' hint indirectly relates but does not define parameter behavior.

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 ('Create') and resource ('a new OBS profile'), which distinguishes it from sibling tools like list_profiles and set_current_profile. The phrase 'OBS profile' is explicit and unambiguous.

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

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

The usage context is implied: this tool is for creating a new profile, not for listing or switching profiles. However, there is no explicit mention of when to use it versus alternatives, such as checking if a profile already exists or using set_current_profile. The 'Medium risk' tag gives a small hint but no clear when-to-use guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates an 'empty' scene, which is a mild behavioral trait, but it does not mention what happens if the scene name already exists, whether the new scene becomes the current scene, or any other side effects. This is a significant gap for a mutation 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?

The description is a single, front-loaded sentence with zero waste. It immediately states the purpose without any filler, making it an appropriately sized definition for a tool of this simplicity.

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?

While the tool is simple and an output schema exists, the description leaves out important contextual details such as error behavior (duplicate names), side effects (whether the scene is auto-activated), and the typical workflow of creating a scene before populating it with sources. Given the availability of sibling tools like duplicate_scene, more guidance would be expected.

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

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

The schema has one required parameter, scene_name, and the schema description coverage is 0%. The description adds no meaning beyond the parameter's title, which is already present in the schema. For such a simple parameter, the lack of explanation may be acceptable, but the description does not compensate for the low schema coverage as required.

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

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

The description clearly states the action ('Create') and the resource ('a new empty scene'), which distinguishes it from sibling tools like delete_scene, rename_scene, and duplicate_scene. The word 'empty' adds a useful qualifier that implies a scene with no sources.

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 about when to use this tool versus alternatives like duplicate_scene or switch_scene. The description does not mention prerequisites, such as whether creating a scene is required before adding sources, nor does it explain exclusions (e.g., when a scene name already exists).

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

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

With no annotations provided, the description must disclose behavioral details. It only adds 'Medium risk', which is vague and does not explain what the risk entails, whether the new collection becomes active, or if it requires OBS to be running. The behavior after creation is undisclosed, such as potential switching or overwriting.

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

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

The description is very concise with two short statements. It front-loads the purpose and does not waste words, though 'Medium risk' is somewhat vague but still brief.

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 a mutation (create) with no annotations and a minimal description. It lacks context about the effect on the current OBS session, whether the new collection is auto-selected, or how it relates to list_scene_collections. The output schema exists but the description does not indicate what to expect on success or error.

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

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

Schema description coverage is 0%, so the description must compensate. It does not mention the parameters 'collection_name' or 'confirm' at all. While the schema titles give hints, 'confirm' with default false is ambiguous, and the description adds no clarification.

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

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

The description clearly states the action: 'Create a new OBS scene collection.' It uses the specific verb 'Create' and the resource 'OBS scene collection', which distinguishes it from sibling tools like create_scene or list_scene_collections.

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

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

The description provides no usage guidance. It does not state when to use this tool versus alternatives like set_current_scene_collection or create_scene, nor mention prerequisites or exclusions. The only clue is the verb 'create', which implies the intended use but without explicit 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states the basic creation action and omits important details such as whether confirmation is needed, what happens on duplicates, or any other side effects of this mutation 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?

The description is concise and to the point, but it is under-specified for a tool with this many parameters and no other documentation. It is efficient but incomplete.

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

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

Given the tool's complexity (6 parameters, no schema descriptions, no annotations), the description is far too minimal. It fails to explain parameter usage or behavioral nuances, making it insufficient 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 0%, and the description explains none of the six parameters. Terms like 'kind' and 'source_settings' are not clarified, so the description adds no semantic value beyond the bare schema.

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

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

The description clearly states the tool creates a new source (input) and adds it to a scene, using a specific verb and resource. It distinguishes from siblings by emphasizing 'new' source, though it doesn't explicitly name alternatives like add_source_to_scene.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states what it does without any context, exclusions, or alternative references.

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

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

With no annotations provided, the description carries the full burden. It discloses that the action is permanent ('Permanently remove') and high-impact requiring confirmation. This is useful behavioral context, though it doesn't specify how confirmation is conveyed (e.g., the confirm parameter) or potential side effects like removal of associated sources.

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

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

The description is extremely concise, consisting of two short sentences that immediately convey the core action and caution. No filler or redundant information; every word contributes value.

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

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

Given that an output schema exists, the description doesn't need to detail return values. It covers the essential aspects: permanent deletion and the need for confirmation. However, it could be more complete by explicitly stating that the confirm parameter must be set to true, and by noting any prerequisites or side effects. Overall, it is adequate for a simple 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?

The schema has 0% description coverage, so the description must compensate. It adds meaning to the confirm parameter through 'requires confirmation,' implying that confirmation must be explicitly given. The scene_name parameter is self-explanatory from its name and the description's reference to 'a scene,' but the description doesn't elaborate further on parameter formatting or requirements beyond that.

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 with a specific verb and resource: 'Permanently remove a scene.' This distinguishes it from sibling tools like create_scene, rename_scene, or duplicate_scene, and even from delete_source by specifying 'scene'.

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

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

The description provides clear usage context by labeling the operation as 'High-impact: requires confirmation,' which signals that the agent should obtain user consent before invocation. It does not explicitly name when not to use or mention alternatives, but for a straightforward destructive operation, this guidance is sufficient.

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

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

With no annotations, the description carries the full burden. It discloses the permanent, destructive nature ('Permanently remove'), the risk ('High-impact'), and the confirmation requirement. This goes beyond the schema by adding crucial safety context, though it doesn't mention side effects like removal from all scenes.

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

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

Two short sentences deliver all essential information in a front-loaded manner. Every word earns its place: 'Permanently remove a source. High-impact: requires confirmation.'

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 is sufficient for a simple delete tool, but it lacks explicit differentiation from remove_source_from_scene and does not clarify how confirmation is provided (e.g., setting confirm=true). The output schema covers return values, but the description could be more complete about the tool's scope and execution requirements.

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 explain either parameter. It only hints at confirmation without naming the 'confirm' parameter or its required value (true) to execute. The 'source_name' parameter is obvious, but the description adds minimal semantic value over the schema.

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

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

The description clearly states the tool's function: 'Permanently remove a source.' The verb 'remove' combined with 'permanently' distinguishes it from sibling tools like hide_source or remove_source_from_scene, making the purpose unambiguous.

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

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

The phrase 'High-impact: requires confirmation' provides clear context that this is a destructive action needing user confirmation. It does not explicitly name alternatives or exclusion criteria, which prevents a 5, but the cautionary context is helpful.

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

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

With no annotations, the description carries the transparency burden. It reveals the tool checks for muted sources and missing devices, strongly implying a read-only diagnostic nature. Yet it doesn't explicitly state that no state is modified, nor does it describe any prerequisites or return behavior beyond the output schema.

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

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

The description is a single, efficient sentence that starts with the verb 'diagnose' and includes two specific examples of what it addresses. Every word contributes, with no redundancy or filler.

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

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

For a zero-parameter diagnostic tool with an output schema present, the description adequately scopes the tool's purpose. It could be more explicit about the tool being read-only and how the results are presented, but such details are partially covered by the output schema and sibling context, making it sufficient.

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

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

The tool has zero parameters, so schema coverage is complete at 100%. The description doesn't need to explain parameter meanings; the baseline of 4 applies because there is nothing to clarify.

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

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

The description clearly states the tool diagnoses audio problems, specifically citing muted sources and missing devices. This distinguishes it from broader diagnostics like diagnose_obs and from audio control tools like mute_source or set_volume, making its purpose unmistakable.

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 audio issues are suspected, and the cited examples give concrete triggers. However, it doesn't explicitly compare with sibling tools like list_audio_sources or get_audio_status, so an agent might need to infer when to prefer this diagnostic over direct audio queries.

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

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

No annotations are provided, so the description carries the full burden. It discloses what the tool checks and that it returns a structured report, which is useful. However, it does not explicitly state that it is read-only, mention prerequisites like OBS running, or describe any potential side effects, leaving some behavioral aspects undisclosed.

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 concise sentences, front-loaded with the key purpose ('Full OBS health check') followed by a scannable list of checked items. Every word adds value, with no redundancy or filler.

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

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

For a zero-parameter tool with an output schema, the description covers the scope well by listing the health check areas and mentioning the structured report. It could be more complete by noting prerequisites (e.g., OBS must be running) or stating that it is a read-only diagnostic, but these are minor gaps 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?

The tool has zero parameters, so the baseline score is 4. The description does not need to explain parameter semantics since there are none, and the schema already confirms an empty parameter set.

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 this is a 'Full OBS health check' and enumerates specific areas it covers (connection, scene, recording, streaming, FPS, CPU, memory, dropped frames, audio). This distinguishes it from sibling tools like diagnose_stream or diagnose_recording, which focus on narrower aspects.

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

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

The description provides clear context for use as an overall health check, and the word 'Full' implies it is the comprehensive option. However, it does not explicitly mention alternative tools for specific issues, so it falls short of fully explicit guidance with exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full burden. It lists diagnostic areas but fails to disclose whether the operation is read-only, what side effects may occur, or what the return structure looks like beyond the schema. Minimal behavioral context beyond the name.

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

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

The description is a single, front-loaded sentence that states the purpose and scope without unnecessary words. Every element earns its place.

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

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

With zero parameters and an existing output schema, the description is largely sufficient for selection. The ambiguity of 'state' and lack of elaboration on what the diagnosis covers are minor gaps, but the schema can fill return details.

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

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

The input schema has zero parameters, so the baseline is 4. No parameter documentation is needed, and the description does not introduce any conflicting or missing parameter expectations.

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 'diagnose' with the resource 'recording' and enumerates focus areas (output state, disk, FPS), clearly distinguishing it from sibling tools like diagnose_stream and diagnose_audio.

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 intended use case (recording problems) is implied, but no explicit alternatives or exclusions are provided. It does not contrast against diagnose_obs or get_recording_status, leaving the agent to infer when this tool is preferred.

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

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

With no annotations, the description must disclose behavioral traits. It only mentions 'Diagnose' but does not explain whether the tool is read-only, requires specific permissions, or produces a summary report. The output schema exists but the description still lacks transparency about side effects or operational impact.

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

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

The description is a single, concise sentence that is front-loaded with the key action and target. It contains no redundant words and effectively communicates the tool's purpose.

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

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

Despite having an output schema and no parameters, the description is insufficient to distinguish this tool from closely related siblings like get_stream_health, which also relates to streaming status. It lacks guidance on expected output format or how to interpret results, making it contextually 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?

The tool has zero parameters, so the description does not need to add parameter meaning. Per the baseline for no parameters, a score of 4 is appropriate since the schema coverage is trivially 100% and there is nothing to clarify.

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

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

The description clearly states the action ('Diagnose') and the resource ('streaming problems'), with specific focus areas (drops, congestion, encoder). It distinguishes itself from sibling tools like diagnose_obs, diagnose_recording, and diagnose_audio, which target different aspects of the OBS ecosystem.

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 a clear use case: diagnosing streaming issues such as drops, congestion, or encoder problems. It does not explicitly state exclusions or alternatives, but the focus is sufficiently clear from the description alone.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals that sources are also duplicated and that a custom name is optional, adding value over the schema. However, it omits the 'confirm' parameter's purpose and any side effects, leaving gaps in transparency.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently states the core functionality and a key option, earning a top score for 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?

The description covers the primary function and an optional behavior, but given there are 3 parameters and no annotations, it is incomplete. It misses the confirmation parameter and usage context. The output schema exists, so return values are not needed here, but the description still leaves significant gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly covers 'scene_name' (the scene to duplicate) and 'new_name' (custom name), but 'confirm' is completely unexplained. The description does not fully document all three 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's action: duplicating a scene and all its sources into a new scene. It distinguishes from sibling 'duplicate_source' by explicitly mentioning scene-level duplication with source copying, and the optional custom name is noted.

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

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

The description implies when to use this tool (to duplicate a scene with its sources) but provides no explicit guidance on when not to use it or alternatives like 'create_scene' or 'duplicate_source'. Usage context is inferred rather than 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?

With no annotations provided, the description must disclose behavioral traits, but it only mentions that settings are preserved and that scene/new name are optional. It does not explain what happens on name conflicts, whether the original is affected, or what the confirm flag does. These are significant gaps for a duplication 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?

The description is a single sentence that front-loads the verb 'Duplicate' and includes all essential optionality in a compact, well-structured form. Every word contributes value, and there is no redundant information.

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

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

Even though there is an output schema, the description fails to address critical runtime behaviors such as the role of confirm, behavior when scene_name refers to a nonexistent scene, and potential name conflicts. Given the four parameters and absence of annotations, this is insufficient for reliable tool 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?

The schema has 0% description coverage, so the description must compensate. It clarifies that new_name and scene_name are optional via 'optionally under a new name' and 'optionally into a scene', but it does not explain the confirm parameter or the meaning of source_name beyond the tool name. This leaves half the parameters semantically 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 'Duplicate' and the object 'a source with its settings', and explicitly mentions optional scene and new name, which distinguishes it from sibling tools like duplicate_scene and create_source. It is specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of when the confirm parameter is needed. It simply states the action without conditional advice, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It mentions confirmation before stopping and the return of a summary, which is helpful. However, it does not explain what happens if confirmation is not provided, whether the session can be resumed, or any side effects (e.g., unsaved data). This is adequate but not rich.

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 primary action. Every part is necessary: the action, the confirmation gate, and the output summary. No redundancy or filler.

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

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

Given the tool's moderate complexity, the output schema exists (so return values need not be described), and the description covers the core behavior and parameter roles. It falls slightly short of fully complete because it does not explicitly address alternatives or the implications of the confirmation default, but overall it is sufficient for an agent to understand and invoke the tool.

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

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

Schema description coverage is 0%, so the description must add meaning to the parameters. It does so by linking 'recording and/or streaming' to the stop_recording and stop_streaming flags, and 'after confirmation' to the confirm parameter. This provides context beyond the bare parameter names, though it does not explain defaults or the exact consequences of each combination.

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

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

The description clearly states the tool's purpose: to stop recording and/or streaming after confirmation and return a session summary. This distinguishes it from sibling tools like 'stop_recording' and 'stop_stream' by emphasizing the session-level scope and the final summary.

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 (ending a recording/streaming session with confirmation and a summary) but does not explicitly compare against alternatives like 'stop_recording' or 'stop_stream'. It lacks clear when-to-use vs. when-not-to-use guidance, especially since siblings exist for individual stop actions.

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

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

With no annotations, the description must disclose behavioral traits. It does state the scope and content of the response, but it does not explicitly confirm that the tool is read-only, describe return format, or mention potential side effects. Some transparency is provided, but not fully.

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 directly conveys the core purpose. No filler or redundant information. It is appropriately sized for a parameterless status tool.

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

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

For a simple status retrieval with no parameters and an output schema available, the description is adequate. It covers the scope and content, but lacks explicit contextual guidance on when to use it. Given its low complexity, the description is reasonably complete.

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

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

The tool takes zero parameters, yielding a baseline of 4. There are no parameter semantics to clarify, so the maximum baseline is appropriate.

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

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

The description clearly states the resource ('audio status') and scope ('all audio-capable sources'), and enumerates specific fields (mute/volume). Although it omits an explicit verb, the tool name 'get' supplies the action. It differentiates from siblings like get_volume, which targets a specific source.

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 on when to use this tool versus alternatives. It does not mention exclusions or suggest alternatives like list_audio_sources or get_volume. Usage is only implied by the name and description.

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

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

No annotations exist, so the description carries the burden. It clearly indicates a read-only operation via 'Return', but it does not disclose edge cases (e.g., behavior when no scene is active) or explicitly state non-mutating behavior. This is acceptable for a simple getter.

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: 'Return the currently active program scene.' It is appropriately sized, front-loaded, and contains no filler.

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

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

For a zero-parameter, read-only tool with an output schema, the description fully captures the tool's purpose. There are no parameters to explain, and return values are covered by the output schema. The description is complete for its simplicity.

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

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

The tool has zero parameters, and the empty input schema fully documents this. Per the baseline for zero-parameter tools, no additional parameter details are needed. The description adds no parameter-specific value, but none is required.

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

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

The description uses the verb 'Return' with the specific resource 'currently active program scene', clearly distinguishing it from sibling tools like list_scenes or switch_scene. It is concise and unambiguous.

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

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

No explicit guidance is provided about when to use this tool versus alternatives like list_scenes, but the phrase 'currently active program scene' implies it should be used for querying the active scene. Usage is inferred rather than clearly 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?

With no annotations provided, the description carries the full burden. 'Get' implies a read-only operation, and 'settings and state' hints at the return content, but the description does not explicitly state that it has no side effects, does not require special permissions, or describe error behavior if the filter/source doesn't exist. It is minimally 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 clear sentence that front-loads the action and resource, with no wasted words 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?

For a simple get operation with an output schema present (so return values need not be detailed), the description adequately covers the essential context. It lacks comparison to sibling tools but is otherwise complete for 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 description coverage is 0% and the description compensates only slightly by indicating that the tool operates on 'one filter on a source,' mapping loosely to the filter_name and source_name parameters. The parameter names themselves are self-explanatory, but no additional meaning, constraints, or examples are provided.

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 'Get' and identifies the resource as 'the settings and state of one filter on a source.' This clearly distinguishes it from sibling tools like list_filters (which lists filters), set_filter_settings (which modifies), and toggle_filter (which toggles state). It is both specific and differentiated.

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 its usage by naming the object, but it does not explicitly state when to use this tool versus alternatives such as list_filters for enumerating filters or set_filter_settings for modifying them. No exclusions or prerequisites are mentioned, so guidance is only implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation with no side effects, which is helpful, but it does not disclose additional behavioral traits such as response format (though an output schema exists) or potential operational requirements like needing OBS to be running. This is adequate but minimal.

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 directly states the tool's purpose. No unnecessary words or filler, making it easy to parse and understand.

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 list tool with no parameters and an output schema available, the description is fully complete. It specifies the scope ('all hotkeys') and the domain ('OBS'), leaving no ambiguity about the tool's function.

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 baseline is 4. The description correctly adds no parameter information since none exist, and the input schema is already empty. No gap in 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 'List all hotkeys defined in OBS' uses a specific verb ('List') and resource ('hotkeys defined in OBS'), clearly distinguishing it from sibling tools like trigger_hotkey which triggers rather than lists.

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 context is implied: use this to retrieve the list of hotkeys. However, there is no explicit guidance on when to use versus alternatives, nor any mention of prerequisites or exclusions. The description simply states what it does without providing contextual decision-making information.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It accurately describes the read-only nature of the operation, but does not provide details such as time units (seconds/milliseconds), behavior when the source is missing, or whether any state is affected. This is a simple getter, so minimal disclosure is acceptable, but more context would improve transparency.

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

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

The description is a single, direct sentence that front-loads the action and outcome. There is no wasted text or redundancy, making it highly 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?

The tool is simple with one parameter and an output schema, so the description need not explain return values. However, given the lack of annotations and low schema coverage, the description should provide more context about time units or edge cases to be fully complete. It is adequate but leaves clear gaps.

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

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

The schema has no descriptions (0% coverage), so the description must compensate. It mentions 'media source,' which hints that source_name identifies the media source, but it does not explicitly map the parameter or add format details. The schema's title 'Source Name' already provides some meaning, and the description adds only marginal context.

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

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

The description clearly states the tool retrieves the current playback position and duration of a media source. It uses a specific verb ('get') and resource, and distinguishes itself from siblings like set_media_time by focusing on reading rather than modifying.

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 reading playback state, and the presence of set_media_time as a sibling clarifies when not to use this tool. However, it does not explicitly name alternatives or state exclusions, so it misses full marks.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It lists the stats returned, which adds value, but does not explicitly state that this is a read-only snapshot operation or whether it affects OBS. The name 'get' strongly implies read-only, but the description could be more explicit.

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 filler. It front-loads the tool's purpose and lists the key metrics efficiently. 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?

The tool is simple with no parameters and an output schema, so the description does not need to explain return values. It clearly lists the included metrics, making it sufficiently complete for a stats retrieval tool. Minor gap: no mention of the snapshot nature or units, but these are likely in the output schema.

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

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

The tool has zero parameters, so parameter semantics are trivially covered. The description adds no parameter information, but none is needed. Baseline 4 is appropriate for zero-parameter tools.

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 retrieves 'Raw OBS statistics' and lists specific metrics (CPU, memory, FPS, render/output drops). This is a specific verb+resource combination that distinguishes it from sibling tools like get_obs_status or get_stream_status.

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 raw performance metrics by naming the specific statistics, but it does not explicitly state when to use this tool versus alternatives like get_obs_status. Sibling differentiation is minimal.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It lists what information is returned (connection, version, scene, etc.), but it does not mention potential failure modes (e.g., when OBS is not running), nor explicitly confirm this is a read-only operation. This leaves some gaps for an agent deciding to invoke it.

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

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

The description is a single, front-loaded sentence that immediately states the tool's purpose, followed by a helpful example. Every word contributes, and there is no redundancy or filler.

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

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

Given the tool's simplicity (0 parameters) and the existence of an output schema, the description is adequately complete for a status-check tool. It states the core content and provides a usage example. It could be enriched by noting that it serves as a health check before other OBS commands, but this is not essential.

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 the description correctly reflects that. With no parameters to explain, the baseline score is 4. The description adds no parameter-related information, but none is needed.

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

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

The description clearly states the tool returns overall OBS status including connection, version, current scene, and recording/streaming state. It uses a specific verb ('status') and resource ('OBS'), and the example clarifies the intent. However, it doesn't explicitly distinguish from the sibling tool 'get_obs_stats', relying on 'Overall' to imply a broader overview.

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 example 'Is OBS connected?' gives a clear use case, implying this tool is for quick connection/status checks. However, it does not explicitly state when to use this tool over alternatives like get_obs_stats, nor does it provide 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?

No annotations are provided, and the description simply restates the function without disclosing behavioral traits such as side effects, error behavior, or requirements. While a getter is likely side-effect free, this is not explicitly confirmed.

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

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

The description is a single concise sentence that front-loads the action and resource, and immediately provides useful examples without any fluff.

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

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

For a simple getter with one parameter and an existing output schema, this description is adequate. It lacks explicit usage guidance, but the examples and output schema cover the key information needed 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?

The schema provides no description for output_name (0% coverage), but the description compensates with concrete examples (adv_stream, adv_file_output), clarifying the expected values. Though not exhaustive, the examples add meaningful guidance beyond the schema.

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

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

The description clearly states the tool retrieves settings for a specific OBS output, with concrete examples of valid outputs (adv_stream, adv_file_output). The verb 'Get' and resource 'settings' distinguish it from sibling tools like set_output_settings.

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 reading output settings but does not explicitly state when to use this tool versus alternatives. No mention of set_output_settings or other getters, but the examples provide context for which outputs to target.

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

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

With no annotations, the description carries the full burden. It clearly indicates a read-only operation via the verb 'get' and specifies the resource being retrieved. It does not describe edge cases or return format, but the output schema covers return values, and the behavior is straightforward.

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 directly states the tool's purpose with no unnecessary information or filler.

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

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

For a zero-parameter getter tool with an output schema provided, the description is sufficiently complete. It fully explains what the tool does, and the output schema handles return value details.

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

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

The tool has no parameters, so the baseline is 4. The description does not need to add parameter semantics, and the input schema is complete with 100% coverage.

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

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

The description uses a specific verb ('Get') and resource ('the folder where recordings are saved'), making the tool's purpose unambiguous. It clearly distinguishes itself from the sibling tool 'set_record_directory' by focusing on retrieval rather than modification.

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

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

The context is clear for a simple getter tool, but it does not explicitly state when to use this over alternatives or mention the counterpart 'set_record_directory' to change the directory. No exclusions are given, but the usage is inherent in the tool's purpose.

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

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

With no annotations, the description carries the transparency burden. It plainly indicates a read-only operation via 'Get' and discloses the exact data points returned (recording state, paused state, duration). It doesn't discuss explicit side effects, but for a getter, this is sufficient 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, concise sentence that front-loads the verb and provides all necessary information without redundancy. Every word contributes value.

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

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

Given there are no parameters and an output schema exists (as indicated by context signals), the description adequately covers the tool's functionality. It fully explains what the tool does without needing to elaborate on return values or edge cases.

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

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

The tool has zero parameters, and the schema is empty, so the baseline of 4 applies. The description adds no parameter details because none are needed.

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

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

The description clearly identifies the resource (OBS recording) and the specific information being retrieved (whether recording, paused, and duration). It uses an explicit verb ('Get') and distinguishes from sibling status tools like get_stream_status and get_replay_buffer_status.

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 recording status is needed but provides no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives, though the clarity of the purpose makes the intended use straightforward.

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

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

No annotations are provided, so the description carries the full burden. The verb 'Get' implies a read-only operation, but the description does not explicitly state that it has no side effects or mention any return format. However, the description does clarify the specific states checked ('active or saving'), adding some behavioral context beyond a generic status query.

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

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

The description is a single, concise sentence that front-loads the action ('Get') and clearly states the query subject. Every word earns its place with no redundancy or vague filler.

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

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

Given the tool's simplicity (zero parameters, no nested objects) and the existence of an output schema, the description is sufficiently complete. It names the resource and the specific status values checked, which is enough for an agent to select and invoke the tool correctly. Slightly more context about the replay buffer lifecycle could elevate it, but it is not necessary.

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

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

The tool has zero parameters and the input schema is empty, so there is nothing for the description to add. With 0 parameters, the baseline is 4, and the description appropriately focuses on the return value rather than 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's purpose with a specific verb ('Get') and resource ('replay buffer status'), and even specifies the exact information returned ('whether the replay buffer is active or saving'). This distinguishes it from sibling action tools like start_replay_buffer, stop_replay_buffer, and save_replay_buffer.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_recording_status or get_stream_status. The name and title imply it is for checking replay buffer status, but there is no explicit context or exclusion of other status tools.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'List' implies a read-only operation, and 'with visibility' indicates the output includes visibility status. However, it doesn't state whether hidden sources are included, error behavior if scene_name doesn't exist, or that the tool doesn't modify state. The description adds one useful detail (visibility) but lacks depth for a read 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?

The description is a single sentence of 12 words, front-loads the action ('List sources'), and contains no filler. Every word earns its place, making it highly 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?

For a simple list tool with one parameter and an output schema, the description covers the core purpose and a key output detail (visibility). It doesn't explain error handling or edge cases, but the output schema likely covers return structure. The description is mostly complete given the tool's low complexity, though it could mention what happens if the scene doesn't exist.

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

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

Schema description coverage is 0%, so the description must compensate. The only parameter, scene_name, is named clearly and the description links it to the concept of 'inside a scene,' but it doesn't add details like whether the name must be exact or case-sensitive. The parameter name is self-explanatory, so the description's contribution is marginal but not fully compensating for zero schema coverage.

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

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

The description clearly states the verb (List), the resource (sources/scene items inside a scene), and an additional detail (with visibility). It distinguishes from siblings like list_sources (global list) and get_source (single source) by specifying the scope as a specific scene.

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

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

The description implies when to use this tool: when you need to know the source composition of a particular scene and their visibility. It doesn't explicitly name alternatives or exclusions, but the 'inside a scene' scope provides clear context that differentiates it from global source listing. No explicit when-not-to-use guidance, but the purpose is clear enough.

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

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

With no annotations provided, the description carries full behavioral burden, but it only states 'Get the settings and visibility state of one source.' It does not disclose any side effects, error behavior, permission requirements, or whether the source must exist. This is a significant transparency gap for a tool with no annotation support.

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, earning a high conciseness score. However, it is slightly under-sized given the need to explain parameters, so it does not reach 5.

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

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

Although an output schema exists, the description does not fully cover the input context: scene_name is unexplained, and there is no annotation support. The tool is simple but with 2 parameters and no schema descriptions, the description is incomplete for reliable 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 0%, so the description must compensate. It confirms source_name is the identifier but does not explain the role of scene_name, which is optional. The description adds minimal value beyond the schema, leaving parameter meaning ambiguous.

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 'Get the settings and visibility state of one source' clearly states the verb (Get), resource (settings and visibility state), and scope (one source). This distinguishes it from sibling tools like list_sources (multiple) and get_source_transform (specific to transform).

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 such as get_source_transform or show_source. There is no mention of alternatives, exclusions, or prerequisites, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only operation but does not mention side effects, whether it requires an active OBS connection, or any other behavioral characteristics. The output schema covers return format, but the description adds no extra transparency.

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

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

The description is a single, concise sentence that is front-loaded with the key information. There is no wasted text or redundant phrasing.

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 this is a simple zero-parameter tool with an output schema, the description is largely complete for selection and invocation. However, a small addition about typical use (e.g., before creating a source) would improve completeness, but this is a minor gap.

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

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

The input schema is empty with zero parameters, and the baseline for 0 params is 4. The description does not need to add parameter details, as there are none to describe.

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 ('all source types (input kinds) that OBS supports'), making its purpose unambiguous. It also naturally distinguishes itself from sibling tools like list_sources, which enumerate actual sources rather than kinds/types.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no context for how it fits into a workflow (e.g., during source creation). It is a bare statement of functionality without usage direction.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clearly states this is a 'get' operation (read-only), and enumerates the transform properties returned. However, it does not disclose potential errors (e.g., nonexistent source/scene) or any units/format details.

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

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

The description is a single concise sentence, front-loaded with the verb and object. Every word adds value, with no redundancy or unnecessary detail.

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 tool with two self-explanatory parameters and an output schema, the description is adequate but not complete. It lacks usage guidance and behavioral nuances, but the tool's simplicity somewhat compensates.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'source' and 'scene' but does not explain the parameters beyond their names, which are already visible in the schema. No additional meaning or constraints are added.

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 verb 'Get' and clearly specifies the resource: 'position, scale, rotation and crop of a source in a scene.' This is specific and distinguishes it from sibling tools like set_source_transform or get_source by naming the exact transform 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 provides no guidance on when to use this tool versus alternatives such as get_source or list_sources. There is no mention of use cases, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. It lists the health indicators examined, which gives some transparency, but it does not explicitly state that the operation is read-only, has no side effects, or whether any permissions are required. The term 'Check' implies non-mutation, but this is not made explicit.

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

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

The description is a single, concise sentence that front-loads the action and resource while adding specific, relevant details. Every word earns its place, with no fluff 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 (no parameters) and has an output schema, so the description need not explain return values. However, given the large set of sibling tools, a brief note on how this differs from get_stream_status or diagnose_stream would improve completeness. As is, it is adequate for a 0-param health-check tool.

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

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

The tool has zero parameters, so the baseline is 4. There is nothing to add beyond the empty schema, and the description correctly focuses on behavior rather than 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 uses a specific verb ('Check') with a clear resource ('stream health') and immediately lists concrete metrics (dropped frames, congestion, reconnects). This distinguishes it from sibling tools like get_stream_status (which reports status) and diagnose_stream (which is a broader diagnostic), making the tool's purpose unmistakable.

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 monitoring stream health but does not explicitly state when to use this tool over alternatives like get_stream_status or diagnose_stream. No exclusions or alternative references are provided, leaving the agent to infer the appropriate context from the wording alone.

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

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

No annotations are provided, so the description carries the burden. The verb 'Inspect' indicates a read-only operation, and the description clarifies that it returns both the stream service type and configured settings. However, it does not mention any error conditions, side effects, or prerequisites beyond what the tool name implies.

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 of eight words, front-loaded with the key action. No filler or redundant content.

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

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

Given the tool's simplicity (no parameters, output schema provided), the description covers the core purpose. However, it lacks explicit usage context or exclusion of competing tools, which would make it more complete.

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

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

The tool has zero parameters, so the schema fully covers the input. The description correctly avoids inventing 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 uses a specific verb 'Inspect' and identifies the resource as 'the stream service type and configured settings'. It clearly distinguishes from sibling tools like get_stream_status (status) and set_stream_settings (settings mutation).

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_output_settings or get_stream_status. No exclusions or conditions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It clearly indicates a read-only getter operation and specifies the three status fields returned. It does not mention error conditions or prerequisites, but for a simple status query this is largely sufficient.

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 filler. It front-loads the verb 'Get' and immediately lists the specific data points, making it highly 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?

An output schema is present, so return values are documented elsewhere. The tool is simple with no parameters, and the description sufficiently explains the core purpose, though it could benefit from a brief note on how it differs from get_stream_health.

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 fully covers input needs. The baseline of 4 applies because there is nothing to explain beyond what is already structured.

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 retrieves OBS stream status including 'live', 'reconnecting', and 'duration'—a specific verb and resource. It distinguishes itself from siblings like get_recording_status and get_stream_health by focusing on the stream's live state and duration.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as get_obs_status or get_stream_health. The context implies usage when stream-specific status is needed, but no alternatives or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Return' clearly signals a read-only operation with no side effects, which is the key behavioral trait for this getter. However, it does not address edge cases like behavior when studio mode is disabled, though an output schema may cover that.

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 fronts the main action (return status) and lists the specific outputs. No wasted words or redundancy with 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?

Given the tool's simplicity (zero parameters) and the presence of an output schema that likely documents return fields, the description is complete. It states exactly what the tool returns and does not omit any necessary context for an agent to use it correctly.

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

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

The tool has zero parameters, so the baseline score is 4. There are no parameter semantics to explain, and the description appropriately focuses on describing the return content rather than 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 uses the specific verb 'Return' and clearly identifies the resource (studio mode status) plus the additional return values (preview and program scenes). This distinguishes it from mutation tools like set_studio_mode and from get_current_scene, making its purpose unmistakable.

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

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

The description provides no guidance on when to use this tool versus alternatives such as set_studio_mode or get_current_scene. It simply states what it does without any exclusions, prerequisites, or recommendations, leaving the agent to infer usage 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?

With no annotations provided, the description carries the full burden. The verb 'List' clearly indicates a read-only operation with no side effects, which is transparent enough for a getter. The existing output schema covers return details, so no additional behavioral disclosure is necessary.

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 concise, front-loaded sentence that states the action and scope directly. Every word contributes to meaning, with no redundant or extraneous content.

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

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

Given the tool's simplicity (zero parameters, output schema present), the description is fully complete. It clearly states what the tool does, and the output schema handles return value details, so there are no gaps.

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

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

The tool has zero parameters and an empty input schema, so the baseline is 4. The description adds no parameter-specific information, but none is needed since no parameters exist.

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 clearly identifies the resource as 'scene transitions' with an additional detail 'and the active one'. This distinguishes it from related sibling tools like set_scene_transition and trigger_transition, which perform different 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 implies usage when you need to see available transitions or the current active one, but it does not explicitly state when to use this tool versus alternatives. No exclusions or alternatives are mentioned, making guidance minimal but not misleading.

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

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

No annotations are present, and the description discloses no behavioral traits whatsoever. It does not state that this is a read-only getter, describe the return format, or mention any permissions or side effects. The description fails to carry the burden of behavioral transparency.

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

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

The description is extremely concise and information-dense, but it is a sentence fragment rather than a complete sentence. It effectively captures the key fields in few words, but the lack of grammatical structure makes it less clear than it could be.

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 an output schema, the description lists the expected fields, which is minimally adequate. However, it does not explicitly state the action ('gets') or provide any usage context, making it somewhat incomplete for a tool with no annotations.

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 empty and there is nothing to explain. The description adds no parameter information, but the baseline of 4 is appropriate for a zero-parameter tool where parameters are not relevant.

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 lists the fields ('Canvas resolution, output resolution and FPS') but lacks a verb or explicit statement of action, relying on the tool name for meaning. It provides specific detail about what settings are included, but does not clearly distinguish from siblings like set_video_settings beyond the name.

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 about when to use this tool versus alternatives such as set_video_settings or get_obs_stats. The description offers no context, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations, the description carries the full burden. It states 'current volume' and specifies the return format (multiplier and dB), implying a read-only operation with no side effects. However, it does not disclose potential error conditions (e.g., invalid source name) or further behavioral details.

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

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

The description is a single, front-loaded sentence that efficiently conveys the tool's purpose and output format. Every word is necessary, with no redundancy or filler.

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

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

For a simple getter tool with an output schema present, the description adequately covers the core behavior. It does not need to explain return values in detail since the output schema exists. However, it lacks any mention of error handling or edge cases, which is a minor gap for a tool with no annotations.

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

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

Schema coverage is 0% and the description does not explicitly describe the source_name parameter. It only mentions 'audio source' in the context, which provides some implicit meaning, but given the low coverage, the description should have compensated with more explicit parameter 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 'Get the current volume of an audio source (multiplier and dB)' clearly states a specific action (get) and resource (volume of an audio source). It also distinguishes itself from sibling tools like set_volume or mute_source by focusing on the read-only retrieval of current volume.

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 the current volume of an audio source. However, it does not explicitly state when to use it over alternatives (e.g., get_audio_status) or exclude scenarios. The context is clear but not elaborated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the literal action without revealing side effects, such as whether the hide is per-scene, persists, or can be reversed by show_source.

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 plus an example, which is maximally concise and front-loaded. Every word contributes to conveying the core purpose.

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

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

For a simple tool, the description is minimally viable but leaves out important contextual relationships with sibling tools (e.g., show_source) and does not compensate for the absence of parameter documentation. The existence of an output schema reduces the need to describe return values, so this is a marginal pass.

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

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

The input schema has 0% description coverage, and the description does not explain the two parameters beyond what their names already imply. The phrase 'in a scene' adds no meaning to scene_name, and source_name is left entirely undeveloped.

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 ('Hide') and the resource ('a source in a scene'), which unambiguously distinguishes it from siblings like show_source or mute_source. The example 'Turn off my webcam' reinforces the intended behavior.

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 example provides a concrete use case, implying when to use this tool, but the description does not explicitly contrast it with alternatives such as show_source or set_source_visibility_in_all_scenes. There is no mention of when not to use it.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly states the tool lists all audio sources and their mute/volume state, which implies a read-only operation. However, it does not explicitly state that it has no side effects, nor does it mention any edge cases (e.g., behavior when no sources exist or OBS is disconnected). For a simple list operation, the risk is low, but the description could be more explicit about its read-only nature.

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

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

The description is a single concise sentence that front-loads the verb and resource and immediately states the output scope. It contains no filler words or redundant information, making it highly efficient 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?

Given the tool's simplicity (no parameters, output schema exists), the description is adequate for an agent to understand what it does. It clearly defines the resource ('all audio sources') and the output content ('mute and volume state'). However, it lacks any contextual guidance on when to choose this over related tools like get_audio_status, so it is 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?

The tool has zero parameters, so the description cannot add meaning beyond the empty schema. The baseline for 0 parameters is 4, and the description correctly avoids mentioning any parameters. No further semantic clarification is needed.

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

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

The description uses a specific verb ('List') and resource ('audio sources') and clearly states the scope ('all') and the included information (mute and volume state). This distinguishes it from sibling tools like list_sources or get_audio_status, 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention that it's best for getting an overview of all audio sources, nor does it suggest using get_volume or get_audio_status for individual source details. No exclusions or alternative tools are named.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. The word 'list' clearly indicates a read-only operation, and adding 'with their state' tells the user what information will be returned. It does not describe error cases, but for a simple listing tool 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 sentence with no unnecessary words. It front-loads the verb and resource, and the additional 'with their state' is concise and informative.

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

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

Given the tool has only one parameter, an output schema is available, and the operation is a read-only list, the description is sufficient for a user to understand what the tool does and what input it expects. No significant context is missing.

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

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

The schema has 0% description coverage, but the tool description explicitly mentions 'a source', making it clear that the required parameter source_name identifies the source whose filters are listed. This adds meaning beyond the raw schema title and type, compensating for the lack of a parameter description.

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 (list), the resource (all filters attached to a source), and includes the additional detail 'with their state'. This distinguishes it from sibling tools like get_filter_settings, which retrieves settings for a specific filter, and toggle_filter, which changes 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 implies the tool is used when you need to see all filters on a source, but it does not explicitly mention alternatives or when not to use it. There is no comparison to other filter-related tools in the description.

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

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

With no annotations, the description carries the full burden. It explicitly mentions that it returns all profiles and the active one, which is a useful behavioral detail. However, it does not explicitly state read-only behavior, though 'list' strongly implies it.

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

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

A single, front-loaded sentence that precisely describes the tool's function with no unnecessary words. Every part of the description 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 no parameters and an output schema likely covering return values. The description fully explains the purpose for a zero-argument listing tool, and sibling context does not require elaboration.

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 baseline is 4. The description adds no parameter-level details, but none are needed. The input schema is empty and thus fully covered.

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 ('List all OBS profiles') and adds the specific detail of identifying the active profile, distinguishing it from profile-management tools like set_current_profile.

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

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

There is no guidance on when to use this tool versus alternatives such as set_current_profile or create_profile. The description only states what it does, not the context or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It clarifies the active collection is included, which is useful, but does not disclose side effects or return format details. Listing is inherently read-only, but no explicit safety statement is made.

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 wasted words. It immediately states 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 no parameters and an output schema is present, so the description only needs to convey the core purpose. It does so clearly and completely for a tool of this simplicity.

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

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

The tool accepts zero parameters, so the baseline is 4. The description correctly doesn't reference any parameters, as none exist.

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 verb 'List' with a specific resource 'all OBS scene collections' and adds 'and the active one,' making it distinct from sibling tools like list_scenes or list_profiles.

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 what the tool does but provides no explicit guidance on when to use it over alternatives. Usage is implied for viewing scene collections, but no exclusions or alternatives are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It clearly indicates a read-only operation ('List') and specifies the scope ('every scene') and output characteristic ('with its index'). While it does not mention error conditions or prerequisites, these are not critical for this simple list 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?

The description is a single sentence, front-loaded with the verb, and contains only necessary information. Every word contributes to understanding the tool's purpose and behavior, with no wasted or redundant content.

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

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

Given the tool's simplicity (no parameters, no nested objects) and the presence of an output schema, the description is complete enough. It communicates the essential behavior—listing every scene with its index—and does not need to describe return values since the output schema covers them.

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

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

The tool has zero parameters and schema description coverage is 100%, so there is no parameter documentation needed. The description adds no parameter details because none exist; this matches the baseline for 0-parameter tools.

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 'List' and identifies the resource 'every scene in OBS' with an additional detail 'with its index', making the action and scope unambiguous. It clearly distinguishes from sibling tools that mutate or retrieve individual scenes (e.g., switch_scene, get_scene_sources).

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

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

The description implies usage by stating it lists all scenes, but it does not explicitly discuss when to use this tool over alternatives or any exclusions. The context signals show a simple read operation with no parameters, making usage fairly obvious, yet no explicit guidance is provided.

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

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

No annotations are provided, so the description must bear the burden of transparency. The description states that it lists all sources with their kind, which implies a read-only query, but it does not explicitly confirm non-destructiveness or describe any side effects. It adds minimal behavioral context beyond the tool's basic function.

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

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

The description is a single, concise sentence that front-loads the action and scope. Every word is relevant, with no filler or repetition.

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

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

Given the tool's simplicity (zero parameters, clear output), the description provides sufficient context. The output schema presumably details the returned structure, so the description doesn't need to explain return values in depth. It fully explains the tool's purpose and scope, but could be slightly more explicit about the returned data if 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?

The tool has no parameters, and the schema shows an empty object, giving 100% coverage. The description reinforces that the tool lists 'all' sources, indicating there is no filtering parameter, which aligns with the schema. With no parameters, the baseline of 4 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 the tool's function: listing all sources (inputs) in OBS and including their kind. This distinguishes it from sibling tools like list_audio_sources (which specifically lists audio sources) and get_source (which retrieves a single source).

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 the general-purpose listing tool for all OBS sources, but it does not explicitly mention when to use it over alternatives like list_audio_sources or get_source. No exclusions or alternative references are provided, so the usage guidance is only implicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It lists the actions but does not specify effects beyond their names, nor does it mention error conditions, side effects, or whether source existence is required. The description is too sparse for a control 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?

The description is highly concise, consisting of two short sentences. It front-loads the main purpose and then lists actions, with no redundant or filler content.

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

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

For a simple two-parameter tool, the description is minimal but somewhat sufficient. Yet it omits any usage context, error behavior, or distinction from sibling tools, which is especially relevant given the large number of related controls. The presence of an output schema reduces the need to describe return values, but overall the description feels 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?

The input schema has no descriptions (0% coverage), but the description compensates by enumerating the valid action values (PLAY, PAUSE, STOP, RESTART, NEXT, PREVIOUS). However, 'source_name' is only vaguely described as a media/VLC source, lacking format or validation details.

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 indicates the tool's function with specific verbs (play, pause, stop, restart, skip) and identifies the resource (media/VLC source). It lists all supported actions, making the purpose unambiguous and distinct from sibling tools like set_media_time which focus on seeking.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or how it relates to sibling media controls. The agent is left to infer usage from the action list alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action without elaborating on side effects, whether the change is persistent, or the role of the 'confirm' parameter. This is a significant transparency gap for a mutation 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?

The description is a single, fluff-free sentence, which is structurally concise. However, it is under-specified for the tool's complexity (including a 'confirm' parameter), so it sacrifices completeness for brevity. A few more words would significantly improve it without losing 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?

Given there is an output schema and 2 parameters, one of which is a boolean requiring clarification, the description is incomplete. It does not address the behavior of 'confirm', potential side effects, or the relationship to sibling audio tools. The tool is simple, but the description leaves too much unspecified for fuller completeness.

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

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

The input schema has 0% description coverage, and the description does not explain either parameter. 'source_name' is inferable from the tool's purpose, but 'confirm' is completely unexplained—its effect, whether it gates the action, or what the default false means. The description adds no value beyond the schema's field names.

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

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

The description 'Mute an audio source' clearly states the action (mute) and the target (audio source), which distinguishes it from the sibling 'unmute_source'. However, it doesn't explicitly mention any scope or context that would further differentiate from other audio tools like 'set_volume', so it's clear but not maximally distinct.

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 about when to use this tool versus alternatives (e.g., 'unmute_source', 'set_volume', or 'hide_source'). The intended use is implied by the name, but there is no explicit context or mention of prerequisites, which leaves the agent without clear decision support.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It accurately states the action but does not explicitly mention that the operation is read-only or that it returns a catalog of tools. Given the simple nature, there is no misleading information, but additional context would improve transparency.

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

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

The description is a single concise sentence that is front-loaded and information-dense. Every word adds value, and there is no wasted text.

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

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

This is a simple, parameterless tool with an output schema present. The description fully covers what the tool does, and the output schema handles return-value details. There are no missing behavioral or usage aspects that need further explanation.

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 baseline is 4. The description does not need to explain parameters but could hint at the output structure. The mention of 'with a short description' adds some context about what the returned list will contain.

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 ('every available OBS MCP tool') and adds detail about the output ('with a short description'). It clearly distinguishes the tool from the many specific sibling tools that operate on individual OBS features.

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 tool discovery without explicitly stating when to use it over alternatives. Since it lists all tools with descriptions, the intended use case is clear, but there is no direct statement like 'use when you need an overview of available tools'.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It does not state what happens if there is no active recording, whether the pause is reversible, or any side effects. The only behavioral hint is 'active', implying a recording must already be in progress.

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 phrase of five words: 'Pause the active recording.' It wastes no words and directly states the action, achieving perfect conciseness for a simple control 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?

The tool is simple with no parameters and has an output schema, so return values need not be explained. However, the description omits context about prerequisites or consequences, such as requiring an active recording or how to resume. Given the low complexity, it is minimally adequate but lacks helpful context, warranting a medium score.

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

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

The tool accepts zero parameters, so the schema is already fully self-explanatory. The baseline for 0 parameters is 4, and the description appropriately adds no parameter-related details, as there are none to describe.

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 'pause' with the resource 'active recording', clearly distinguishing it from siblings like start_recording, stop_recording, and resume_recording. It goes beyond a tautology by specifying the target as the active recording, making the action 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?

No guidance is given about when to use this tool versus alternatives such as stop_recording or resume_recording. It does not mention that pause is for temporary suspension or that resume_recording is the complementary action, so the agent must infer usage context from tool names alone.

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

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

With no annotations, the description carries the full burden and does well by disclosing that it switches scenes, verifies sources, checks audio/readiness, and reports a summary. It also clearly states it does not start recording. Missing details about side effects like permanently changing the current scene or prerequisites, but core behavior is transparent.

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

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

The description is concise, consisting of two meaningful sentences. The first sentence lists the exact actions in a compact list, and the second adds a crucial disclaimer. No filler or redundant information.

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

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

The description outlines the steps, the final report, and the exclusion of starting recording. It is reasonably complete for a no-parameter tool, though it could mention prerequisites (e.g., OBS running) or potential failure conditions, but these are not critical given the scope.

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

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

The tool has zero parameters, and the schema confirms this with no properties. Per the baseline for 0 params, a score of 4 is appropriate; the description does not need to explain parameter semantics.

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

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

The description uses a specific verb 'Prepare' with a clear resource 'OBS for recording' and details the concrete steps: switch to recording scene, verify sources, check audio and readiness, and report a summary. It explicitly states 'Does NOT start recording,' which clearly distinguishes it from the sibling tool start_recording.

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 makes it clear this is for preparing OBS before recording and explicitly warns it does not start recording, which is a key exclusion. However, it does not explicitly name alternatives like prepare_stream for streaming or state when not to use it beyond the recording context.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key mutation (switch scene) and explicitly excludes going live, which is helpful. But it does not state whether verification steps modify anything, whether OBS must be running, or whether this is idempotent. It also doesn't describe side effects on existing source states.

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-loaded with the purpose, and includes a clear negative scope. Every phrase earns its place.

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

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

Given that an output schema exists and there are no parameters, the description sufficiently conveys the tool's scope and steps. It could mention prerequisites like OBS running, but overall it is complete for an agent to decide when to invoke.

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?

Tool has 0 parameters, so the description adds context about the workflow rather than parameter syntax. Given the empty schema, the description adequately fills the gap by explaining what the tool does.

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

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

States a specific action: 'Prepare OBS for streaming' and enumerates the steps: switch to stream scene, verify sources/audio, check output config, report readiness. Explicitly distinguishes from start_stream by noting 'Does NOT go live.'

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

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

The phrase 'prepare OBS for streaming' and the explicit 'Does NOT go live' imply this is a pre-flight check before going live. However, it does not name alternative tools like start_stream or get_stream_health, so the guidance is clear but not exhaustive.

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

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

The description discloses that the operation is high-impact and requires confirmation, which is useful. However, it does not explain what high-impact means concretely (e.g., permanent deletion) or how confirmation works (e.g., the confirm parameter must be true). With no annotations provided, the description carries the full burden and falls short.

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

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

Two short sentences with no filler. The most important information is front-loaded.

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

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

Given that there is an output schema, return values needn't be explained. Yet for a high-impact mutation, the description lacks details about the confirmation flow, error cases (e.g., filter not found), and the irreversible nature. The description is minimal but not fully adequate.

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

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

The input schema has 0% description coverage, so the description must compensate. The text implies the need for source_name and filter_name ('from a source') and the confirmation requirement touches on the confirm parameter. However, it does not explain the boolean semantics (e.g., that confirm must be explicitly set to true) or any constraints on names.

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

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

The description clearly states the action (remove) and the resource (a filter from a source), using a specific verb. It is distinct from sibling tools like add_filter or toggle_filter.

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

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

The description provides no guidance on when to use this tool versus alternatives like toggle_filter to disable a filter. The 'High-impact' warning is a caution, not a usage guideline. There is also no mention of prerequisites, such as the filter existing.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the operation is high-impact and requires confirmation, and clarifies that the source is not destroyed. It also hints at the confirm parameter's role. However, it doesn't detail the consequence of confirm=false, reversibility, or prerequisites like scene/source existence, leaving some gaps.

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 primary action, and no fluff. Each sentence provides meaningful information: the operation's scope and the high-impact/confirmation requirement. This is 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?

The tool is relatively simple, but the description lacks crucial details for an agent to invoke it safely: what happens if confirm is not true, whether the operation is reversible, and what output to expect (though output schema exists). It also doesn't mention preconditions like the source existing in the scene. The description is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate for parameter explanation. It only addresses confirm indirectly with 'requires confirmation', but does not explain scene_name or source_name beyond their names, nor specify that confirm must be set to true. The description adds minimal 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 the action ('Remove a source from a scene') and immediately clarifies the key distinction from sibling tools: it does not delete the source itself, unlike delete_source or show/hide source. This is a specific verb+resource combination with a clear boundary.

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

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

The description implies the intended use case (removing a source while preserving it), which contrasts with deletion. However, it does not explicitly name alternatives or explain when not to use it, such as versus hide_source or set_source_visibility_in_all_scenes. The guidance is indirect 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only restates the action without revealing any side effects, error conditions, or requirements (e.g., whether the scene must exist, what happens if the new name is already taken).

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 wasted words. However, it is so minimal that it borders on tautological, adding little value beyond 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?

Given the absence of annotations, 0% schema coverage, and no behavioral context, the description is grossly inadequate for a tool that modifies state. The presence of an output schema doesn't compensate for missing usage context, side effects, or parameter semantics.

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 adds no meaning beyond the schema. The parameter names (scene_name, new_name) are self-explanatory, but the description does not clarify constraints, formats, or relationships between the 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 'Rename an existing scene' clearly states a specific action (rename) on a specific resource (scene). It distinguishes from sibling tools like create_scene, delete_scene, and duplicate_scene by the verb 'rename' and the qualifier 'existing'.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or suggested use cases, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Set') but does not mention whether the index is zero-based, what happens if the index is out of bounds, whether the operation is reversible, or any permission requirements. For a mutation tool, this is a significant gap in transparency.

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

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

The description is a single, concise sentence of 12 words. It is front-loaded with the verb and key concept, contains no filler, and every word contributes to the meaning. This is an excellent example of efficient, focused tool documentation.

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

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

Given the tool's simplicity and the existence of an output schema (which would explain return values), the description is minimally adequate. It covers the essential purpose and parameters but omits contextual details like index semantics, error behavior, or prerequisite filter existence on the source. For a simple reorder operation, this is a clear but not exhaustive coverage.

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

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

The input schema has 0% description coverage, so the description must compensate by explaining parameter roles. The phrase 'processing order (index)' gives semantic meaning to the index parameter, and 'of a filter on a source' maps to filter_name and source_name. However, it does not clarify index base or valid ranges, which leaves partial ambiguity.

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

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

The description clearly states a specific action ('Set the processing order (index)') on a specific resource ('of a filter on a source'). This distinguishes it from sibling tools like set_source_index (which reorders sources) and set_filter_settings (which sets filter properties), making the tool's unique function clear.

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