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

No annotations provided, so description carries the full burden. Discloses the return format ({glass_break, fire_alarm}) and a key error case (hardware_unsupported for Gen1). Does not mention authentication, rate limits, or other potential errors, but is sufficiently transparent for a simple 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?

Three sentences, front-loaded with the main purpose, followed by compatibility and return format. No extraneous information.

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

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

Given the tool's simplicity (one parameter, simple return) and the existence of an output schema, the description covers purpose, constraints, error behavior, and return format comprehensively.

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

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

Schema coverage is 0% and the description adds minimal value beyond the parameter name. The 'camera' parameter is not described in terms of format or expected values (e.g., serial number vs device ID). With only one parameter, the description should provide more 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 verb 'get' and resource 'glass-break + smoke/fire-alarm sound detection config' for a Gen2 camera. It distinguishes from siblings like 'bosch_camera_audio_detection_set' and other audio tools by specifying the exact configuration returned.

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

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

Provides explicit compatibility conditions: only Gen2 Audio-Plus cameras with featureSupport.sound=true, and raises hardware_unsupported for Gen1. However, lacks explicit guidance on when to use this tool versus related siblings like bosch_camera_audio_get or privacy_sound_get.

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 provided, so description carries full burden. Discloses read-modify-write behavior, the fact that both fields are always sent on PUT (Bosch API resets omitted fields), and the return value. This is highly transparent 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?

Six sentences, each providing essential information. Front-loaded with main action. No wasted words. Important details are included without being verbose.

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 (3 parameters, read-modify-write, API quirk, Gen2 requirement), the description covers all necessary context. Output schema exists, but description still succinctly notes return value. No gaps.

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

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

Schema description coverage is 0%, so description must compensate. It explains that glass_break and fire_alarm are boolean, at least one required, and how they merge with current config. Does not explain camera parameter, but that is self-explanatory as device identifier.

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

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

Clearly states it updates glass-break and fire-alarm detection for Gen2 cameras. The verb 'update' and specific resource 'audio detection' are explicit. It distinguishes from siblings like bosch_camera_audio_detection_get (read) and bosch_camera_audio_set (general audio 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?

Explicitly states it is a Gen2 Audio-Plus-only feature and raises hardware_unsupported for Gen1. Specifies that at least one of glass_break or fire_alarm must be provided. However, it does not explicitly compare with sibling tools like bosch_camera_audio_detection_get, though the usage is clear from 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 of behavioral disclosure. It details the return structure ({microphone_level, speaker_level, intercom_enabled}) and explains the intercom_enabled field can be None. It also mentions the hardware_unsupported error condition. This is sufficient transparency 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 concise with only 4 sentences, each adding value. It is front-loaded with the core purpose and efficiently covers scope, error condition, and return details without unnecessary 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?

Given the presence of an output schema (implied by listing return fields), the description provides all necessary context: purpose, hardware requirements, error behavior, and return structure. It is fully adequate for a single-parameter read 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% (no parameter descriptions in schema). While the description does not explicitly describe the 'camera' parameter, it provides context about which cameras are valid (Gen2 with sound=true), implying the parameter is a camera identifier. However, it does not specify format or constraints on the parameter value, so it partially compensates.

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

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

The description clearly states the verb 'Get', the resource 'microphone and speaker level settings', and qualifies it as 'for one Gen2 camera', distinguishing it from sibling tools like bosch_camera_audio_set (set) and bosch_camera_audio_detection_get (get detection 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 explicitly limits usage to cameras with featureSupport.sound=true, specifically Gen2 Indoor II and Gen2 Outdoor II, and warns that it raises an error for Gen1 or unsupported Gen2 cameras. It does not explicitly name alternative tools for unsupported cases, but the guidance is clear and practical.

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 fully discloses: hardware unsupported error, range constraints, persistence of unspecified fields, and return value structure.

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

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

Concise but slightly dense; could be broken into bullet points, but all information is front-loaded and every sentence adds value.

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

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

Covers prerequisites, errors, constraints, behavior with unspecified fields, and return fields. Output schema exists, but description sufficiently describes return structure.

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

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

Schema has 0% description coverage, but the description explains parameter roles, optional nature, range (0-100), and at-least-one requirement, adding substantial meaning.

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

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

The description clearly states the tool sets microphone and/or speaker levels for Gen2 cameras with specific feature support, distinguishing it from siblings like bosch_camera_audio_get which retrieves levels.

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

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

Explicitly specifies conditions (featureSupport.sound=true), raises hardware_unsupported otherwise, and requires at least one of mic_level/speaker_level. Lacks explicit alternatives but provides clear 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?

Discloses return format ({enabled}), conditions for meaningful use, error case for unsupported cameras, and underlying API endpoint.

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

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

Three concise sentences, front-loaded with purpose, no unnecessary information.

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

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

Covers purpose, parameter, return format, conditions, and error case. Output schema exists, so return details are 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?

Only one parameter 'camera', which is intuitive from tool name. Description could clarify it's a camera ID but schema coverage is 0% and no additional semantics 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?

Clearly states it gets the auto-follow state for one camera. The description distinguishes it from 'set' sibling and specifies the camera type condition.

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?

Implies usage for reading state, but lacks explicit comparison to 'set' tool. Provides context on when it's meaningful (360° cameras with panLimit>0) and error handling.

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 main behavior (enable/disable), hardware dependency, and error condition. It does not detail side effects or response format, but for a toggle tool this is adequate. No contradiction with annotations as none exist.

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

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

The description is concise with three sentences, each adding value. The first sentence sets the purpose, the second adds a usage constraint, and the third provides the API endpoint and body format. 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?

Given the output schema exists (not shown but indicated), the description need not explain return values. It covers the hardware requirement, error handling, and API details. For a simple set operation, this is near-complete, though adding a note that it performs a write operation would enhance completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that 'enabled' is a boolean for turning auto-tracking on/off, but does not specify the format or expected values for the 'camera' parameter (likely an ID string). The API body example clarifies the structure, yet the camera parameter remains 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 clearly states the tool enables or disables 360° auto-tracking for one camera, using a specific verb and resource. It distinguishes from siblings, such as bosch_camera_autofollow_get which retrieves the state, by indicating this tool is for setting the autofollow state.

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

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

The description provides explicit context on when to use the tool: only for 360° indoor cameras with panLimit > 0. It also specifies the error raised for unsupported camera types. However, it does not explicitly state when not to use it, such as for non-360° cameras, beyond the error condition.

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 explaining behavior. It discloses the GET endpoint, the read-only nature through 'Get', the camera-generation limitation, and the interpretation of ranges (0% = always day, 100% = always night). This is useful contextual behavior beyond just restating the tool's name. It does not go into authentication or rate limits, but those are not present in any annotation and may not be expected for a simple GET.

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: three short lines cover the high-level operation, compatibility, value semantics, and the HTTP endpoint. Every sentence earns its place and there is no filler. It is appropriately front-loaded with the core action.

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

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

For a one-parameter read-only operation, the description covers the purpose, important range interpretation, and API endpoint. An output schema exists and can define the response format. But because annotations and schema param descriptions are absent, the description falls short of fully explaining the camera param, and it doesn't mention whether any special auth or camera state is needed. It is useful but not fully complete.

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

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

There is only one parameter, 'camera', and the schema gives no description for it. The description's API line, 'GET /v11/video_inputs/{id}/lighting', obliquely suggests that the camera parameter corresponds to an ID, but it never explicitly maps 'camera' to '{id}' or explains expected values or format. With 0% schema coverage, the description should compensate more decisively.

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

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

The description clearly states a specific verb ('Get') and a specific resource ('day/night lighting threshold and fading mode'), and it adds a compatibility restriction ('Gen2 cameras only'). It doesn't explicitly name sibling tools to differentiate itself, but the tool name and the read-oriented phrasing make its purpose unmistakable. A small deduction because it doesn't contrast itself with related tools like bosch_camera_darkness_threshold_set or bosch_camera_lighting_schedule_get.

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 a clear compatibility constraint: 'Gen2 cameras only.' This implies when not to use the tool, but it doesn't explicitly say 'use this when reading the threshold; use darkness_threshold_set when writing' or identify alternative siblings. The usage context is mostly inferable from the name and context signals, but it lacks direct when-to-use vs. alternative 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 behavioral disclosure burden. It states that the operation is a mutation, that unspecified fields are preserved, and that only Gen2 cameras are supported. It also gives the exact API endpoint and body fields, which helps the agent anticipate the underlying request.

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 efficiently structured: the main purpose leads, then the key constraint, then the API details. Each sentence serves a purpose and there is minimal 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 three-parameter setter with an output schema and no annotations, the description is largely complete. It captures the core operation, the parameter constraint, the partial-update semantics, and the low-level API mapping. It omits permission requirements, but that is a relatively minor gap for this 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 descriptions are missing entirely (0% coverage), so the description must compensate. It does: it gives the 0-100 range for threshold_percent, explains soft_light_fading as a fading mode, and clarifies the 'at least one required' constraint. The camera parameter is not described, but the API path implies it is the camera ID.

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

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

The description opens with a specific verb and resource: 'Set the day/night lighting threshold and/or fading mode.' It also scopes the tool to Gen2 cameras only, which clearly identifies its purpose and distinguishes it from the corresponding getter, bosch_camera_darkness_threshold_get, and from other lighting tools.

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

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

The description gives useful usage constraints: Gen2 cameras only, and at least one of threshold_percent or soft_light_fading must be provided. It clearly implies when to use this tool versus the matching getter, and explains the partial-update behavior.

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 provided, so description must convey behavior. It states it returns 'most recent' events, which is vague regarding time window. It does not explicitly confirm read-only status, but returns data. Lacks details on ordering, pagination, or authentication. Adequate but not thorough.

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

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

Description is very short: two sentences. Front-loaded with purpose, then lists output fields. No unnecessary words. Could add more detail without sacrificing conciseness, but current structure is efficient.

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

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

Given the tool has 2 params, no annotations, and an output schema, the description covers the basic purpose and output fields. However, it lacks usage context among 30+ siblings, parameter details, and behavioral specifics. Minimal but functional; leaves gaps for an AI agent to resolve.

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

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

Schema description coverage is 0%. Description does not explain the camera parameter (expected value) or the limit parameter (default, meaning). It only lists output fields. The schema provides types but adds no semantic context beyond the description's purpose. Agent needs more param info to use correctly.

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

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

Description clearly states it returns the most recent motion/person/audio events for a specific camera. The verb 'Return' and resource 'events' are specific. Among siblings like bosch_camera_motion_get and bosch_camera_audio_get, this tool aggregates event types, distinguishing it.

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

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

No explicit guidance on when to use this tool versus alternatives like bosch_camera_motion_get or bosch_camera_unread_get. Description does not mention when-not-to-use or provide context for selection among siblings.

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 bears full responsibility. It discloses the HTTP method (GET), the return type (raw dict of booleans), and that it's account-level. However, it lacks details on authentication, rate limits, or potential side effects, though for a read operation this 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 concise at four sentences, front-loads the action and endpoint, and includes a relevant example. Every sentence serves a purpose with no redundancy.

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

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

For a tool with no parameters and a simple return type, the description fully explains what it does, what it returns (with example), and the scope (account-level). It meets all needs for correct selection and invocation given the context.

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

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

The input schema is empty (0 parameters), and schema description coverage is 100%. The description adds value by explicitly stating there is no camera parameter and that flags are account-level, which clarifies the scope beyond the empty 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 it fetches account-level Bosch cloud feature flags, returns a raw dict of flag names to booleans, and provides an example. It distinguishes itself from sibling tools which are camera-specific by explicitly noting no camera parameter.

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

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

It says 'Useful for discovering which Bosch platform features are active for this account' and emphasizes 'No camera parameter — flags are account-level.' This implies when to use it, but does not explicitly mention when not to use it or name alternatives among siblings.

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 effectively discloses key behaviors: it raises invalid_argument for concurrent installs or when up-to-date, and explains that the camera reboots for 3-7 minutes while the call returns immediately. Missing details like authentication or return value, but sufficient for a straightforward action.

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

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

Three sentences, each providing essential information: the action, error guards, and post-install behavior. No redundant phrases; 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 description covers the core action and notable behaviors but omits parameter details and any mention of the output schema (despite its presence). Given the tool's simplicity, this is a noticeable gap, though the output schema likely documents return values separately.

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 explain the 'camera' parameter (e.g., what values it accepts). It only mentions 'one camera' vaguely. This gap forces the agent to infer the parameter's meaning from the schema alone, which is inadequate.

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 (Install) and resource (pending firmware update for one camera). It distinguishes the tool from its sibling 'bosch_camera_firmware_status', which checks for updates, making it clear that this tool performs the installation.

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 a pending update exists) and specifies error conditions (install in progress, no pending update). It could be more explicit about prerequisites (e.g., check status first) and alternatives, but context from siblings helps.

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 provided, so the description bears full responsibility. It only states the operation is a get (read), but does not disclose behavioral traits like permissions, rate limits, or behavior when camera is offline.

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 with no extra verbiage.

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

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

The tool has one parameter and an output schema. The description covers the core purpose, but lacks parameter details. However, for a simple info retrieval tool, it is mostly complete.

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

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

Schema description coverage is 0%, and the description does not clarify the 'camera' parameter format (e.g., ID, name, serial). It only says 'one camera', adding no meaning beyond the schema.

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

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

The description clearly states the action (Get), resource (firmware version and update-availability), and scope (one camera). It distinguishes from sibling tool 'bosch_camera_firmware_install' which installs firmware.

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

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

No explicit guidance on when to use or alternatives. Usage is implied as checking firmware status before an install, but no prerequisites 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 exist, so the description must cover behavioral aspects. It only states the action, omitting details like authorization requirements, whether the invite is sent immediately, idempotency, or error cases (e.g., duplicate email).

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

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

The description is extremely concise with two short phrases. It is front-loaded, but the brevity sacrifices necessary details for an agent to use the tool effectively.

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 one parameter and an output schema, the description should clarify the result (e.g., success message, pending invite). It lacks prerequisites and side effects, making it incomplete for reliable agent decision-making.

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 minimal value beyond the parameter name 'email' by noting '(by email)'. It does not explain format, validation, or implications.

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 'Invite' and the resource 'a new friend (by email)' to share cameras, and specifies it is account-level. It distinguishes from sibling tools like friends_list, friends_remove, friends_share, and friends_unshare.

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: to invite someone via email. It mentions 'Account-level' which clarifies scope. However, it does not provide when-not-to-use or explicitly mention alternatives among sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It explains the scope and that it lists both friends and invitations, but it does not disclose whether it returns pending or accepted ones, or require any authentication details. For a read-only list tool, the description 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 two concise sentences, front-loaded with the verb, and contains no redundant information. Every sentence adds value.

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

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

Given the existence of an output schema and the simplicity of the tool (no parameters), the description is sufficiently complete. It could optionally mention the format of the response, but overall it provides 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?

There are no parameters, so the schema coverage is effectively 100%. The description adds no parameter information, but none is needed. Baseline for 0 parameters is 4.

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' and the resource 'friends/invitations this account has shared cameras with'. It also clarifies the scope as account-level, distinguishing it from per-camera tools like bosch_camera_friends_share.

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

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

The description explicitly says 'No camera parameter — friends are account-level, not per-camera,' helping the agent understand when to use this tool. However, it lacks explicit comparisons to sibling tools like bosch_camera_friends_invite.

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 discloses destructive behavior (removes entirely) and return format, going beyond basic purpose. It does not cover authentication or reversibility, but it is transparent about side effects.

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

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

Two sentences front-loaded with key information and no unnecessary words. 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?

Covers purpose, side effects, and return format, but lacks parameter documentation and prerequisites (e.g., 'friend_id must exist'). Adequate for a simple tool but incomplete.

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

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

Schema description coverage is 0%, and the description does not explain the required 'friend_id' parameter (e.g., how to obtain it or its format). No added value beyond the schema structure.

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 'Remove a friend entirely' with specific side effects (revokes shares, deletes invitation/friendship), which distinguishes it from sibling tools like friends_invite, friends_share, etc.

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 for final removal but does not explicitly say when to use it vs alternatives like friends_unshare. No when-not or comparative 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?

Without annotations, the description carries full burden, disclosing that 'days' limits share duration and that omitting it gives unlimited sharing. It also mentions the return format. However, it omits error conditions or idempotency details, which are partially mitigated by the tool's simplicity.

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

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

The description is concise: two sentences clearly state purpose, parameter behavior, and return value. No redundant information, front-loaded with the core action.

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

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

For a simple tool with no annotations and an output schema only hinted at in the description, the description covers purpose, parameter semantics, and return format. However, it lacks error handling details, prerequisites (e.g., friend must exist), and whether sharing is additive or replaces existing shares.

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 compensates by explaining the 'days' parameter and its optionality, but provides no additional details for 'camera' or 'friend_id'. The other parameters are self-explanatory from context, but more explicit semantics would be beneficial given the low 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 'Share one camera with an existing friend,' specifying the verb, resource, and target audience. This effectively distinguishes it from sibling tools like bosch_camera_friends_invite (inviting new friends) and bosch_camera_friends_unshare (removing sharing).

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 using this tool for sharing with an existing friend, contrasting with invite for new friends, but does not explicitly state when to use it versus alternatives. No exclusions or when-not-to-use 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?

With no annotations, the description carries the burden. It discloses that the action revokes all shares, the friend entry persists (non-destructive to friend), and the return format. It lacks details on side effects or prerequisites but is adequate for a simple 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?

Two concise sentences: first states action and side effect, second describes return. No unnecessary words.

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

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

Given the simplicity (1 param, implied output schema), the description covers the essential behavior and return. It could mention that the friend must exist, but overall it is complete.

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

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

Schema coverage is 0%, and the description does not explain what 'friend_id' is or how to obtain it. The parameter name alone is insufficient.

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

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

The description clearly states the action ('Revoke ALL camera shares') and distinguishes from related siblings (e.g., bosch_camera_friends_remove removes the friend, bosch_camera_friends_share adds shares) by noting the friend entry remains.

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 of siblings (friends_share, friends_remove, etc.) implies when to use this tool (to revoke shares without removing the friend), but it does not explicitly state alternatives or when not to use.

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

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

There are no annotations, so the description carries full behavioral burden. It discloses destructive impact, account-unpairing, the need to re-commission the camera, confirmation requirement, the error behavior, and the API endpoint called.

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

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

The description is short, front-loaded with the critical DESTRUCTIVE label, and every sentence earns its place: what it does, why it is dangerous, what prerequisite must be set, and the exact API call.

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 tool's destructive nature, the description covers every essential bit an agent needs: purpose, side effects, required confirm flag, error when not set, and the underlying endpoint. Output schema exists, so return-value details are not required here.

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 explain the confirm parameter thoroughly—boolean required or invalid_argument is raised—and connects camera to the API path. It never explicitly defines what value `camera` should take, but the parameter name and endpoint context make this mostly inferable.

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

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

The description names an exact operation—factory-reset one camera via an explicit API endpoint—and clearly differentiates itself from the many camera siblings by calling the operation DESTRUCTIVE and noting it unpairs the camera from the Bosch account. This makes it unambiguous compared to soft_reset and other non-destructive tools.

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

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

It clearly conveys the consequence of use (unpairing and full re-commissioning), which tells an agent when this is appropriate. It does not name an explicit alternative like soft_reset, but the destructive-consequence context provides clear usage guidance without needing exclusions spell out.

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 full burden. It discloses key behavioral traits: errors per camera are captured in the 'error' field instead of raising exceptions, and the return fields are listed. This goes beyond minimal disclosure.

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

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

The description is three concise sentences, front-loaded with the core purpose. Every sentence adds value: purpose, return values, error handling. No unnecessary words.

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

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

Given the tool has no parameters and an output schema exists, the description sufficiently explains its behavior, return fields, and error handling. It covers what an agent needs to know for 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 tool has zero parameters and schema coverage is 100%. The description adds value by explaining that the check covers all cameras without needing parameters. Baseline for 0 params is 4, which 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 verb 'health check' and resource 'ALL configured cameras in one call'. It distinguishes from sibling tools that operate on individual cameras or settings by emphasizing bulk operation.

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

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

The description explicitly says it 'Replaces 4+ separate MCP calls for dashboard use', indicating when to use it for aggregated overview. However, it does not specify scenarios where this tool should not be used, but the context from sibling tools makes it clear that individual checks are 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?

With no annotations, the description fully covers behavioral aspects: listen-only limitation, optional speaker level setting, connection flow (REMOTE then LOCAL), and URL construction with enableaudio=1. It also notes the server does not play audio, providing complete 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 detailed and well-structured with paragraphs and a bullet list of arguments. It is longer than minimal but each sentence adds value. Minor redundancy could be trimmed, but overall effective.

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

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

Given the complexity and that output schema exists, the description appropriately explains the return value (RTSPS URL) and the complete workflow. No critical gaps remain for an agent to correctly invoke the tool.

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

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

Schema coverage is 0%, yet the description explains each parameter: camera (case-insensitive name), duration (default 60s, embedded as maxSessionDuration), and speaker_level (optional 0-100). It adds practical context beyond the schema, fully compensating for the lack of schema descriptions.

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

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

The description clearly identifies the tool as opening a listen-audio session tunnel and returning an RTSPS URL. It explicitly states 'listen-only' and distinguishes from other intercom functions. The verb+resource combination 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 advises that the tool is listen-only and that true two-way talk is not supported, referencing the Python CLI limitation. It details the intended usage flow but does not explicitly state when to avoid using this tool in favor of siblings, though the context makes it clear.

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

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

With no annotations, description carries full burden. Discloses return tuple structure, field meanings, valid ranges, and error condition for Gen1. Good behavioral coverage 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?

Concise with front-loaded purpose. Field details are structured in a code block, efficient but slightly lengthy. Could be trimmed if output schema covers returns.

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?

Completeness is high given output schema existence. Description adds value by explaining return fields, detection mode mapping, and the Gen2 identification method.

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

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

Schema coverage is 0%, so description should compensate. The only parameter 'camera' is self-explanatory, but no additional format or usage guidance is provided. Adequate for a simple string parameter.

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

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

Clearly states the verb 'Get' and resource 'intrusion detection configuration' for one Gen2 camera. Distinguishes from sibling bosch_camera_intrusion_set and specifies Gen2-only scope.

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

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

Explicitly states Gen2-only availability and raises hardware_unsupported for Gen1 cameras. Provides clear context for when to use, though no explicit alternative for Gen1 is suggested.

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 full burden. It discloses mutation behavior ('Update[s]', 'unspecified fields are preserved'), return format, and a historical bug. It does not explicitly state authorization needs, rate limits, or idempotency, but covers key behavioral aspects like error conditions for distance >8.

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 moderately long but efficiently structured: purpose first, then key constraint, followed by parameter details. Every sentence adds value, though some historical notes could be condensed. Still, it remains focused and 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?

Given 4 parameters (1 required) and no output schema provided (but noted as existing), the description covers the return format and key behavioral details. The hardware constraint, version bug, and parameter ranges provide a complete picture for an agent to invoke correctly. No gaps remain.

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

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

Schema coverage is 0%, so description fully compensates. Each parameter (mode, sensitivity, distance) is explained with accepted values, ranges, mapping to Bosch API fields, and version-specific behavior. This goes well beyond the bare schema, making parameter usage clear.

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

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

The description clearly states it 'Update[s] the intrusion detection configuration for one Gen2 camera.' It specifies the resource (intrusion detection config), action (update), and scope (one Gen2 camera), distinguishing it from siblings like bosch_camera_intrusion_get (retrieval). The Gen2-only constraint further clarifies its domain.

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

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

Explicitly notes Gen2-only requirement ('raises hardware_unsupported for Gen1 cameras') and 'At least one parameter must be provided.' It also provides version-specific advice (v1.6.0 vs v1.6.1). However, it does not compare with sibling set tools (e.g., motion_set) to guide when to use this over 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 bears full responsibility. It discloses the protocol (TCP port 443), timeout (1.5 s), and return values (reachable, ip, latency_ms). This is sufficient transparency for a simple network probe. A minor gap: it doesn't explain behavior on timeout or invalid IP, but the return schema indicates those cases would likely return reachable=false.

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

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

The description is concise: three sentences covering functionality, parameter usage, and return format. No redundant information. Front-loaded with the core probe action, then rationale, then output shape.

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

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

Given the tool's simplicity and the presence of an output schema (implied by context), the description fully covers the tool's purpose, parameters, and return value. Sibling tools are numerous but none overlap in functionality, so no further differentiation needed.

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

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

Schema coverage is 0%, so description must add meaning. It explains that 'camera' is resolved from bosch_config.json, while 'lan_ip' is a raw IP. It also implies mutual exclusivity by saying 'Pass either... or...'. This adds essential semantic value beyond the schema's basic type declarations.

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 probes camera LAN reachability on TCP port 443 with a 1.5s timeout. This is distinct from all sibling tools, which are about camera features like audio, motion, or streaming. The verb 'probe' and resource 'camera reachability' are specific.

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

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

The description explicitly advises when to use this tool: diagnosing cloud-down situations. It explains the consequence: if reachable, local writes (privacy/light) will work without waiting for Bosch infrastructure. This provides clear context and guidance, differentiating it from other 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?

No annotations are provided, so the description carries the full burden. 'Get' and 'API: GET /v11/...' make the read-only nature clear, and the 0-100% plus Gen2-only scope sets expectations. It does not discuss error behaviors, permissions, or what happens on unsupported camera generations, but for a simple read operation this is a reasonable disclosure level.

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 compact and front-loaded with the main action, allowed values, and Gen2-only constraint. The position constraint and HTTP endpoint are each stated once and in a structured way, with no filler or unnecessary 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?

This is a simple two-parameter getter, and the description sufficiently captures the key compatibility, position values, and API endpoint. Since an output schema exists, the return values do not need to be explained. The only real gap is the format/identifier expected for camera, which the API path partially addresses via {id}.

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. It does add essential meaning: position must be exactly "top" or "bottom", and the API path maps camera to the {id} placeholder. However, the camera parameter itself is not fully explained, so the agent still has to infer what value to pass.

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

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

The description opens with a specific verb and resource: 'Get top or bottom LED brightness (0-100%)'. It also adds the Gen2-only compatibility constraint and the allowed positions, making it clear this is a read tool. It does not explicitly name the corresponding sibling, bosch_camera_led_brightness_set, to differentiate, so it stops just short of a 5.

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

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

'Gen2 cameras only' is an explicit compatibility boundary, and 'position must be "top" or "bottom"' clearly states which reading must be made. The description does not explicitly name an alternative for Gen1 cameras or tell the agent when to prefer this tool over the setter sibling, but the overall usage context is clear.

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

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

With no annotations, the description must disclose more of the write/au behavior. It does mention 'API: PUT /v/video_inputs/{id}/lighting/switch' and 'full-body write, GET-merged', which hints at the underlying mechanism. However, it does not state side effects, reversibility, permissions requirements, or whether existing lighting settings get overwritten.

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

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

The description is short and front-loaded, starting with the action and core constraint. The API line adds technical context about the write mode. It is concise, although the 'full-body write, GET-merged' detail could be clearer or more prominently linked to the call flow.

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 gives enough to understand the operation and valid values for two key parameters, but the 'camera' parameter is left to inference. Even with a camera list sibling, trusting the caller to know the schema's camera pattern makes the description less complete than ideal.

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% parameter description coverage, so the description must compensate. It clarifies that position must be 'top' or 'bottom' and that brightness is a 0-100% scale, and the API path suggests 'camera' is the id in the URL. The meaning of 'camera' is still implicit rather than explicitly define 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: 'Set top or bottom LED brightness (0-100%).' It identifies the exact resource being modified and the valid value range. It also adds a compatibility constraint, but does not explicitly distinguish itself from sibling tools such as bosch_camera_light_set or bosch_camera_status_led_set.

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 through the 'Set' verb and supports 'fromally' cameras, but it does not explicitly describe when to choose this tool over siblings like bosch_camera_led_brightness_get or bosch_camera_light_set. The 'Gen2 cameras only' note is a useful exclusion but does not fully route the model to or away from 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?

With no annotations, the description carries the behavioral burden, and it does so well: 'GET' implies read-only access, 'configured' indicates it returns an existing setting rather than changing it, and the Gen2-only restriction is disclosed. It also explains why the value matters, which goes beyond the machine-readable 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?

Three short sentences with no fluff: the purpose and unit are front-loaded, the compatibility caveat is prominent, and the API path provides useful reference. Every sentence earns its place.

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

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

For a single-parameter getter with an output schema, the description covers the operation, scope, units, end-to-end reason, and API shape. A minor gap is that it does not explicitly state that `camera` must be a video input id or name, but the endpoint template largely fills that in.

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 per-parameter description, so the description must help map the lone `camera` parameter. The endpoint path suggests that `{id}` corresponds to `camera`, and the unit/direction of the value is clear, but the mapping is implicit rather than explicit. That is a useful clue but not a full parameter explanation.

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 the exact action ('Get'), the resource ('configured lens mounting height'), the unit (meters), and a key constraint (Gen2 only). The companion setter is clearly distinguished, and the endpoint path is included for disambiguation.

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?

Mentions a concrete use case (perspective correction in person detection) and limits the tool to Gen2 cameras, giving an explicit applicability constraint. It does not name alternative tools or provide a when-not-to-use strategy, but the scope is clear enough for an agent to select it appropriately.

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 behavioral burden. It reveals that this is a write/set operation and gives the HTTP contract, but it does not mention side effects, required permissions, error behavior, reversibility, or whether the change takes effect immediately.

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 compact and well-structured: the primary action and constraints come first, followed by the exact API specification. Every sentence adds operational value with no filler.

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

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

For a two-parameter setter, the description provides enough invocation-critical detail: operation, range, unit, and raw API shape. Since an output schema exists and the schema exposes the two required parameters, the remaining gaps around authentication and side effects are noticeable but not blocking.

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 meaningfully defines the `meters` parameter with units and a valid range (0.5-5.0) and maps it to the API body field "elevation". However, the `camera` parameter is not explicitly described beyond the API path placeholder `{id}`, leaving some interpretation to the agent.

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 as 'Set the lens mounting height in meters (0.5-5.0)', specifying a concrete verb, resource, unit, and allowed range. This also distinguishes the tool from the sibling getter bosch_camera_lens_elevation_get.

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

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

It provides a meaningful usage constraint ('Gen2 cameras only') and the exact API endpoint, which tells the agent when it is not applicable. However, it does not explicitly contrast this with related tools or explain when to prefer the getter or other camera configuration 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. It discloses that the tool raises specific HTTP errors (442 for hardware unsupported, 444 for camera offline), which adds valuable behavioral context beyond the schema. However, it does not explicitly state read-only behavior or idempotency.

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

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

The description is three sentences, starting with the core purpose. It is efficient, but the API endpoint detail could be integrated more concisely.

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 an output schema exists, return values are covered. However, the description lacks parameter help and does not mention any required permissions. For a simple read tool with many siblings, it is adequate but not fully complete.

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

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

The only parameter 'camera' has a type but no description in the input schema (0% coverage). The tool description does not add any meaning about what the 'camera' parameter expects (e.g., format, ID, or valid values), leaving the agent without guidance to fill it correctly.

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 identifies the exact resource 'LED lighting schedule for one outdoor (Eyes) camera'. It clearly distinguishes from sibling tools like 'bosch_camera_lighting_schedule_set' and 'bosch_camera_light_set'.

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 mentions hardware and connectivity prerequisites and error conditions, but does not explicitly state when this tool should be used versus alternatives (e.g., 'use this to read the schedule, use set to change it'). The guidance is implied but not direct.

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 provided, so description carries full burden. Discloses read-modify-write pattern, side effect of forcing scheduleStatus, specific HTTP error codes (hardware_unsupported, api_unreachable), and that only outdoor cameras with LED light are supported. Thoroughly 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?

Description is about 150 words, highly concise. Opens with purpose, then explains behavior pattern, constraints, and parameter list. No redundant sentences. Every sentence adds necessary information.

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

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

Given 5 parameters (1 required), no annotations, and presence of output schema, the description covers purpose, usage, constraints, side effects, error conditions, and parameter formats. It is sufficient for an agent to understand when and how to invoke the tool correctly.

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

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

Schema description coverage is 0%, so description must compensate. Provides a list of all five parameters with brief but meaningful descriptions: camera (case-insensitive), on_time/off_time (format HH:MM[:SS]), light_on_motion (boolean), darkness_threshold (0.0-1.0). Adds value beyond schema titles, though could include more detail like time format validation.

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?

Starts with 'Update the LED lighting schedule for one outdoor (Eyes) camera.' Clearly specifies verb (update), resource (LED lighting schedule), and scope (outdoor camera with LED light). Distinguishes from siblings like bosch_camera_lighting_schedule_get.

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?

Explains when to use: to update the schedule. Notes that at least one optional field must be provided and that writing any field forces scheduleStatus to FOLLOW_SCHEDULE. Mentions availability constraints and error codes. Does not explicitly state when not to use it, but conditions are implied by error scenarios.

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

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

Despite no annotations, the description fully discloses behavioral traits: immediate error for unsupported cameras, local vs cloud path preference, brightness mapping, fallback mechanism, and wallwasher RGB limitation. This goes well beyond the bare minimum.

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

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

The description is concise, with two clear paragraphs. The first sentence states the core action, followed by bullet-like details. Every sentence provides value without redundancy.

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

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

Given the presence of an output schema, the description covers all necessary aspects: purpose, prerequisites, error behavior, parameter details, and edge cases. It is fully sufficient for an agent to use 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?

With 0% schema description coverage, the description fully compensates by explaining the 'enabled' parameter's mapping to brightness 100/0, the 'prefer_local' parameter's effect on execution path and fallback, and implicitly the 'camera' parameter. It adds significant meaning beyond the schema.

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

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

The description clearly states the tool's purpose: 'Turn the camera's spotlight on or off.' It specifies the verb and resource directly, and distinguishes from sibling tools by mentioning spotlight control and camera compatibility.

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

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

The description specifies when to use the tool: only for cameras with 'featureSupport.light=true', and mentions immediate error for unsupported cameras. It implicitly tells when not to use (for non-spotlight tasks), but does not explicitly compare to alternatives like 'bosch_camera_light_set' vs other light-related tools (none exist among siblings).

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

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

The description discloses the output includes online status, but lacks information on potential behavioral aspects like pagination, rate limits, or error handling. Without annotations, more detail would be beneficial.

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 conveys the purpose without waste. It is front-loaded with the key 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?

Given the tool's simplicity (no parameters, output schema exists), the description is complete. It provides enough context for an agent to understand what the tool does without needing additional detail.

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

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

There are no parameters, so the schema coverage is 100% trivially. The description adds nothing about parameters, but none are needed. Baseline score of 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 it lists all configured Bosch cameras with their online status. The verb 'list' and resource 'configured Bosch cameras' are specific, and it distinguishes itself from sibling tools that operate on individual cameras or 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?

No explicit guidance on when to use this tool versus alternatives, but it is implied that listing cameras is a prerequisite for other operations. However, no when-not-to-use or alternative recommendations are provided.

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

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

With no annotations, the description carries the full behavioral burden and does well: it declares the operation read-only, states that a password is never returned, and explains the fallback behavior for unsupported cameras ('unsupported' with 'queried=False'). It does not mention auth or permission requirements, but the core behavior is well disclosed.

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 tight sentences, front-loaded with the purpose and then the compatibility condition. Every sentence earns its place, and the code-formatted sentinel values improve scannability.

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 output schema exists, so return details are largely covered, and the description supplies important version/model gating. However, the single required parameter remains undocumented, leaving the definition incomplete 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?

There is one required 'camera' parameter, but the schema has 0% description coverage and the description does not explain what the camera identifier should be (e.g., name, ID, IP). The description mentions 'cameras' generally but adds no usable meaning beyond the bare parameter name.

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

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

The description names a specific resource ('camera's local data interface') and describes its state as read-only, which is clearer than a generic status tool. It does not explicitly differentiate itself from the many sibling camera-status tools, so it falls short of a 5.

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

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

It gives a meaningful precondition: only Gen2 cameras on firmware >= 9.40.105 are queried. However, it does not say when to use this tool versus other diagnostic or status tools, so the guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool fetches from an RSS feed, returns specific fields, and provides recommended actions based on state. No contradictions.

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

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

The description is well-structured with bullet points and front-loads the purpose. It is slightly verbose but still clear and effective.

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 no parameters and no annotations, the description thoroughly explains the output, including detailed recommended_action logic. It is complete for a diagnostic tool.

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

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

There are no parameters (0 params), so the baseline is 4. The description does not need to add parameter information.

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

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

The description clearly states it fetches cloud maintenance announcements from an RSS feed and specifies the output fields, including recommended actions. It is distinct from sibling tools that focus on camera-specific operations.

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

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

Explicitly says 'Use this tool when users ask why cameras are unavailable or when the cloud returns 5xx errors.' This provides clear context, though no explicit 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?

Without annotations, the description carries full burden. It discloses using ffmpeg, pulling a single frame from RTSPS stream (inst=3 sub-stream), saving to a specific cache directory, and noting lower resolution but faster speed. It does not cover error handling or missing dependencies, but provides substantial behavioral detail.

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

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

The description is well-structured with a one-sentence summary, followed by technical details and prerequisites. It is not overly verbose, though the phrase 'Direct LAN MJPEG snapshot via RTSP inst=3 (Gen2 only)' could be slightly condensed. Still efficient.

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

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

Given the complexity (local ffmpeg command, prerequisites) and presence of an output schema, the description covers behavior and constraints adequately. However, the missing parameter semantics and lack of guidance on how to specify the camera leave a gap. It is complete enough for agents with domain knowledge but incomplete for naive agents.

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

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

Only one parameter 'camera' with type string, and schema description coverage is 0%. The description does not explain what value the 'camera' parameter expects (e.g., ID, name, IP). This is a gap, especially since the tool likely requires a specific camera identifier.

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

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

The description clearly states it performs a 'Direct LAN MJPEG snapshot' via RTSP, specifies it's for Gen2 only, and contrasts with 'snap.jpg' to distinguish from sibling tools like bosch_camera_snapshot. The verb 'snapshot' and resource 'camera MJPEG stream' are precise.

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 tells when to use (for a faster local snapshot vs cloud) and prerequisites: ffmpeg installed, MCP host on same LAN, and Gen2 camera only. It implies when not to use (if these conditions aren't met) but doesn't explicitly mention alternatives beyond snap.jpg.

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

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

Describes return value format (enabled, sensitivity) with enumerated values, and provides API endpoint. No annotations, so description carries burden well.

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

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

Three concise sentences with no redundant text. First sentence states purpose, subsequent ones add useful 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?

Given output schema exists and single parameter, description adequately covers return value and API. Could mention read-only nature but not required.

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

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

Only parameter 'camera' is mentioned in description as 'for one camera', but not explicitly described. Schema coverage is 0%, so description partially compensates but could be clearer.

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

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

Description uses specific verb 'Get' and resource 'motion detection settings', clearly distinguishing from sibling 'bosch_camera_motion_set'. Scope 'for one camera' is explicit.

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

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

No explicit when-to-use or when-not-to-use guidance. Usage is implied by name and description, but no enrichment over 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?

With no annotations, the description compensates by disclosing the implicit enable when only sensitivity is set, and mentions the API endpoint. However, it lacks details on permissions, reversibility, or side effects.

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

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

The description is concise and well-structured with a bullet for sensitivity values. The API line is somewhat extra but not harmful. Could be slightly tighter without losing meaning.

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

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

The description covers the main parameter interactions and implicit behavior. However, it lacks prerequisites (e.g., camera must exist, permissions needed) and does not reference the get counterpart or explain the output schema. Given moderate complexity and existing output schema, it is minimally 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?

Schema description coverage is 0%, but the description explains the required combination of parameters, enumerates sensitivity values, and explains the implicit behavior. It does not describe the 'camera' parameter beyond its name.

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 function: 'Set motion detection enabled state and/or sensitivity for one camera.' The verb 'set' and resource 'motion detection' are specific. It distinguishes from sibling tools like bosch_camera_motion_get (which gets) and other set tools for different 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 specifies constraints: 'At least one of enabled or sensitivity must be provided' and explains the sensitivity values and implicit enabling behavior. However, it does not explicitly compare with sibling tools or provide when-not use cases.

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

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

Discloses that the tool removes all zones (destructive hint implied) and returns an empty list. However, with no annotations, the description is the sole source; it lacks details like irreversibility or state requirements. Acceptable but minimal 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?

Extremely concise (one sentence), but sacrifices necessary details. Under-specification reduces effectiveness; conciseness alone does not suffice.

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 (clear action, one parameter, output schema exists), the description is mostly adequate but lacks parameter clarification and usage context, leaving room for misinterpretation.

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 sole parameter 'camera' is a string with no description in the schema. The description does not clarify what the camera parameter refers to (e.g., ID, name, or IP). With 0% schema coverage, the description fails to compensate.

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

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

The description clearly states the action ('Remove all motion-detection zones'), the resource ('for one camera'), and the return value ('Returns the (empty) list'). This distinguishes it from sibling tools like motion_zones_get and motion_zones_set.

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

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

No guidance on when to use this tool versus alternatives (e.g., removing zones individually via motion_zones_set). No prerequisites or context for appropriate usage.

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

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

With no annotations provided, the description adequately covers behavior: coordinates are normalized 0.0-1.0, returns empty list if no zones, and raises privacy_blocked error when camera is in privacy mode. It also implies read-only nature. Could add details about response structure, but given the existence of an output schema, the description remains 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?

Three concise sentences: first states purpose, second explains coordinate normalization, third covers boundary cases (no zones, privacy mode). No redundant information, front-loaded with the core action.

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

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

Given the tool's simplicity (one parameter, list output), the description covers essential behavioral aspects. It mentions coordinates, empty list, and error handling. With an output schema in place, the description is sufficiently complete for an agent to invoke 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 single parameter 'camera' is self-explanatory by name and tool context, but the description does not elaborate on its format, allowed values, or how to obtain a camera identifier. Since schema coverage is 0%, the description could add more value but the parameter is simple enough.

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

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

The description clearly states 'List the motion-detection zone rectangles configured for one camera,' specifying the action (list), resource (motion-detection zone rectangles), and scope (one camera). This effectively distinguishes it from sibling tools like bosch_camera_motion_zones_set and bosch_camera_motion_zones_clear.

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

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

The description implies use for retrieving zones of a single camera, but does not explicitly state when to use or when not to use compared to alternatives. However, the purpose is straightforward, and the mention of the privacy_blocked error condition gives guidance on a specific scenario to watch for.

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 full burden. It discloses that the operation is a destructive full replace, that empty list clears zones, and specifies the zone format with normalized coordinates. This goes beyond the input schema by explaining behavioral traits.

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

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

The description is two sentences long and front-loaded with the main action. Every sentence provides necessary information without redundancy.

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

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

Given the tool has 2 parameters, an output schema exists, and no nested objects, the description covers purpose, usage, parameter format, and behavioral notes. No critical information is missing.

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

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

Schema description coverage is 0%, but the description compensates by explaining the 'zones' parameter: each zone is an object with x, y, w, h normalized 0.0-1.0. It also clarifies that the 'camera' parameter identifies one camera. This adds meaning beyond the raw 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 replaces ALL motion-detection zones for one camera with a given list. It uses a specific verb ('Replace') and resource ('motion-detection zones'), and distinguishes from sibling tools like bosch_camera_motion_zones_clear and bosch_camera_motion_zones_get by clarifying it's a full replace.

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

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

The description explicitly states 'This is a full replace, not a merge — pass every zone you want to keep.' It also explains that passing an empty list is equivalent to clearing all zones, referencing the sibling tool bosch_camera_motion_zones_clear. This provides clear guidance on when to use this tool versus alternatives.

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