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

No annotations are provided, so the description carries the full burden, and it does disclose meaningful post-conditions: the zone is unconfigured, appears immediately, is waterable, and requires in-app calibration because cloud-only path mapping is impossible. It still omits permissions, error behavior, and reversibility, so it falls short of a 5.

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 what is created and then the important operational caveat. No filler or repetition.

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

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

For a mutation with no annotations and no output schema, the description handles the behavioral side well but leaves the four undocumented parameters entirely to inference, which is a substantial gap for a tool requiring device_id and name.

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 across four parameters, the description should compensate but does not: name, enabled, and water_depth_mm are never mentioned, and device_id is only obliquely suggested by 'on a device' without format or source guidance. Only the device relationship is conveyed.

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

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

The description gives a specific verb and resource ('Create a new ... zone') plus a distinguishing qualifier ('unconfigured'). It is easy to separate from siblings like rename_zone, delete_zone, list_zones, and get_zone.

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

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

Usage is implied rather than stated: the creation scenario is clear, but there is no explicit when-to-use/when-not guidance, no mention of the required device_id path, and no alternative tool named for zones that already exist.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose a non-obvious trait: cancel=false un-cancels a rain-skipped event and forces it to water anyway, revealing the tool's inverse capability. However, it omits permissions, reversibility, and side effects, leaving significant gaps 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?

A single efficient sentence with the primary action front-loaded and the edge case in a parenthetical. No waste, though the parenthetical could be split out for clarity.

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

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

No annotations and no output schema mean the description is the sole source of behavioral detail. It covers the dual behavior but not the return value or schedule_id semantics. Adequate but with clear gaps for a 2-parameter mutation tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the cancel parameter's dual meaning (cancel vs force-water), but schedule_id — the required parameter — gets no explanation of what schedule it references or its format. Partial compensation for one of two params.

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

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

States a specific verb and resource ('Cancel a scheduled irrigation event'), which is clear on its own. The parenthetical adds the inverse operation (un-cancel/force watering), which helps distinguish it from stop_watering and water_zone. It stops short of explicitly contrasting those siblings, so 4 rather than 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?

The parenthetical implies a use case — set cancel=false for a rain-skipped event — but gives no explicit when-to-use vs alternatives, no prerequisites, and no guidance on when cancel=true is preferred. Usage is only implied.

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

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

With no annotations, the description carries the full burden. It usefully discloses that deletion is irreversible from this tool yet briefly recoverable, but omits side effects (e.g., attached watering schedules/routines), required permissions, and error behavior for a destructive mutation.

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

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

Two short sentences with the action front-loaded and the irreversibility caveat immediately following. No waste.

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

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

Adds the one behavioral fact that matters most for a delete (recoverability window), but for a parameterized destructive tool with no annotations and no output schema, the effects on related entities and failure modes are left unstated.

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 says only 'a zone', leaving both zone_id and device_id completely undocumented in schema and prose. It does not compensate for the coverage gap or clarify why device_id is required alongside zone_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?

Specific verb+resource ('Delete a zone') that is unmistakably distinct from siblings like rename_zone, add_zone, and set_zone_enabled. It does not explicitly name alternatives, but the destructive operation is self-differentiating.

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, and no routing to alternatives. The recoverability caveat implies the action is consequential, but the agent must infer the operational context.

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

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

With no annotations, the description carries the full burden. It discloses the return shape (percent values, one per day), which is genuinely useful since there is no output schema, but it says nothing about how far back history goes, permissions, or rate limits.

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

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

A single front-loaded sentence with zero waste that conveys purpose and return granularity in one pass.

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

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

Adequate for a simple one-param read tool, but the time span of the history and the exact semantics of the daily values are left unspecified, which are the main things an agent would want before calling it.

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

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

There is a single required parameter at 0% schema description coverage, so the description must compensate and does not. The name device_id is largely self-explanatory, which keeps this from dropping lower, but no format or source for the ID is given.

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

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

States a specific verb (Get) and resource (device's battery level history) with added scope detail (percent values, one per day). This naturally separates it from siblings like get_device_logs and get_device_status, though it never names an alternative explicitly.

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

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

No when-to-use guidance, no prerequisites, and no routing to or away from any sibling tool. The agent must infer the use case entirely.

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 itself; it does disclose useful behavior beyond the schema by stating ordering ('newest first') and the categories of entries returned. It stops short of stating that the call is a non-mutating read, what 'recent' is bounded by, or whether results are capped by the limit parameter.

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

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

A single front-loaded sentence with the resource and verb first, the content taxonomy in a compact parenthetical, and the ordering constraint last. No filler.

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

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

With no annotations, no output schema, and 0% parameter coverage, the description covers the return content and ordering but leaves the limit parameter and the read-only nature unstated. Adequate for a simple two-parameter getter, but not fully self-sufficient.

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

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

Schema description coverage is 0%, so both parameters rely entirely on their names. The description mentions 'recent' but never explains the limit parameter, its default of 20, or whether it caps the number of log entries returned; device_id is at least inferable from 'the device's'.

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

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

States a specific verb and resource ('Get the device's recent log entries') and enumerates the entry types covered (watering, errors, battery, connectivity), which lets an agent distinguish it from the battery-only sibling get_device_battery_history. It does not, however, distinguish it from the closer siblings list_events or get_device_status.

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

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

The description gives no when-to-use guidance and never names an alternative, even though list_events, get_device_status, and get_device_battery_history overlap in scope. The agent must infer from the parenthetical content list alone whether this or list_events is the right call.

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 supplied, so the description carries the behavioral burden. It discloses the payload categories (a read-style operation, by implication), but says nothing about permissions, freshness/latency of 'live', rate limits, or behavior for an unknown device_id.

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

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

A single front-loaded sentence with zero filler; the scope ('one device') comes before the field list. Slightly list-heavy, but every item named is informative given there is no output schema.

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 output schema, the description usefully enumerates the returned data categories, which is the main completeness gap it must fill, and it does so adequately. It stops short of covering error/empty-result behavior or auth requirements, which keeps it out of the top tier.

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% for the single required device_id parameter. The description adds only 'for one device', implying the ID selects a single device rather than a list, but gives no format, source (e.g. list_devices), or error behavior, so it does not compensate for the coverage gap.

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

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

States a specific verb ('Get') and resource ('live hardware status for one device') and enumerates what is returned: battery voltage/current, charge state, comms info, error data. The word 'live' implicitly separates it from the sibling get_device_battery_history, though no sibling is named explicitly.

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

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

There is no explicit when-to-use or when-not-to-use statement, but 'live' implies the real-time snapshot case versus the historical sibling get_device_battery_history. The agent can infer the routing, but nothing is stated outright.

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 behavioral burden. It usefully lists the returned data categories, but does not disclose freshness, units, location resolution, or read-only semantics (though implied by 'Get'). Adequate but with notable gaps for a no-annotation 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?

A single sentence that front-loads the verb and resource, then uses a colon to list the returned data efficiently. Every part earns its place 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 zero-parameter read tool with no output schema, the description gives a reasonable sketch of what is returned (current conditions, weekly forecast, historical rain). It could specify units or location source, but the core selection information is present.

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

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

The tool takes zero parameters, so the baseline is 4. The description does not need to add parameter meaning, and it correctly avoids discussing nonexistent inputs.

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

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

States a specific verb (Get) and resource (local weather), then enumerates exactly what data is returned: current conditions, weekly rain/temperature forecast, and historical rain. This makes the tool clearly distinguishable from all sibling tools, none of which provide weather data.

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 says what the tool returns but gives no guidance on when to call it, no prerequisites, and no alternatives. An agent must infer that it should be used for weather-dependent irrigation decisions without any explicit instruction.

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

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

No annotations exist, so the description carries the full burden. 'Get' implies a read-only, non-destructive call, and the description usefully discloses what the payload contains, but it says nothing about auth requirements, error behavior for unknown IDs, or whether the data is cached/live.

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

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

A single front-loaded sentence with a colon-delimited field list and no filler. The enumeration is slightly long but earns its place because there is no output schema.

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

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

For a simple read tool with no annotations and no output schema, describing the returned fields covers the largest gap. However, the two required parameters remain completely unexplained, which is the main missing piece for correct invocation.

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

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

Schema description coverage is 0% and both required parameters (device_id, zone_id) are bare strings. The description never explains what these identifiers are, where to obtain them, or that zone_id is scoped to device_id, so it fails to compensate for the coverage gap.

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

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

Specific verb+resource ('Get full details of one zone') and it enumerates the returned facets (paths, nozzle angles, water amounts, bottle/fertilizer state, scheduling). The singular 'one zone' implicitly separates it from list_zones, but no sibling is named explicitly.

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

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

Usage is only implied: 'one zone' suggests single-zone retrieval versus list_zones for enumeration, but there is no explicit when-to-use statement, no mention of alternatives like get_device_status, and no prerequisites (e.g., needing a valid zone_id).

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 usefully discloses the returned fields (names, winter-mode state), but says nothing about pagination, account scoping limits, permissions, or whether offline devices are included.

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

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

A single front-loaded sentence with no filler. The core action and the payload are stated immediately.

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

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

For a zero-param list tool with no output schema, the description covers the essentials but omits pagination/result-size behavior and any hint about the relationship to the per-device siblings. Adequate but leaves minor gaps.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies for a parameterless definition.

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

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

States a specific verb (List) and resource (OtO devices), and even names the returned fields (names, winter-mode state). It does not distinguish itself from siblings like get_device_status or get_device_logs, 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?

There is no statement of when to use this tool versus get_device_status, get_device_logs, or get_device_battery_history. The agent must infer that this is the broad inventory call rather than a per-device detail call.

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

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

With no annotations, the description carries the full burden and does deliver real behavioral detail: end is inclusive, the default window is 7 days back through 14 days ahead, and only_active narrows results to scheduled/pending/executing states. It remains silent on read-only guarantees (only implied by 'List'), pagination, and result size, so it is not fully 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 tight sentences, front-loaded with purpose then date semantics then the filter flag. Every clause conveys actionable information with no filler.

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

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

For a zero-annotation, no-output-schema read tool, the definition covers defaults, date format, and filter semantics well. The unexplained zone_id parameter is the one meaningful gap; return-shape detail is not required since this is a simple list operation.

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

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

Schema coverage is 0%, so the description must compensate, and it does for three of four parameters: start/end get the YYYY-MM-DD format and inclusivity rule plus default windowing, and only_active gets its precise filter semantics. zone_id is never mentioned anywhere, leaving one parameter completely undefined.

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

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

States a specific verb and resource: 'List irrigation events.' That is unambiguous and distinct from siblings like cancel_event or list_zones. It does not, however, name or contrast itself against any related sibling, so it stops 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?

The description implies usage by documenting the default 7-day-back/14-day-ahead window and the only_active filter, which tells the agent what happens if it omits arguments. It never states when to choose this tool over alternatives such as cancel_event or get_device_status, and there are no explicit exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that only recent messages are returned, but says nothing about ordering, pagination, default count, read-only nature, or whether messages can be marked read. Thin for a tool with zero annotation coverage.

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

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

One tight, front-loaded sentence with no filler. It is not padded, though that brevity comes partly at the cost of the missing detail noted elsewhere.

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

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

For a simple read-only list tool with no output schema and one optional param, the description covers the essentials of what is returned, but leaves the limit parameter and result ordering/volume unspecified, which an agent calling it would want to know.

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 'limit' has no schema description (0% coverage) and the description never explains it, not even its default of 10 or the meaning of the cap. The description does not compensate for the documentation gap.

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

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

States a specific verb 'List' and resource 'account messages from OtO', with parenthetical examples (announcements, tips) that clarify the content type. It is clearly distinguishable from the device/zone focused siblings, though it does not name a sibling explicitly.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. 'Recent' hints at scope but the agent gets no rule for choosing this over list_events or other listing 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, the description carries the full behavioral burden. It usefully enumerates the shape of each returned routine (pattern, start time, enabled flag, member zones), which is genuine context. However, it never states that this is a non-mutating read, and says nothing about pagination, ordering or result limits.

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

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

A single front-loaded sentence that identifies the resource first and then details the fields. The parenthetical enum list is dense but each token earns its place by pre-explaining values the caller will see.

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?

There is no output schema, so the description carries the job of describing return content, and it does so at a reasonable level of detail. The main remaining gap is the absence of read-only framing and any pagination/volume expectations, but for a zero-argument list tool this is close to sufficient.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate - baseline 4 applies. The schema is empty and correctly so; the description does not need to add parameter detail.

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

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

States a specific verb+resource ('List watering schedules') and even disambiguates the resource as '(routine definitions)', which separates it from zone/device listings. It does not name any sibling tool, so differentiation is inferable but not 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?

Usage is only implied by the verb 'List' - an agent can infer this is the way to inspect existing routines. There is no statement about when to prefer this over get_device_status, list_events or the mutation sibling set_routine_enabled, and no prerequisites mentioned.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the return payload's fields, which signals a read operation, but says nothing about permissions, ordering, or pagination behavior.

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

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

One front-loaded sentence with no redundancy; the scope qualifier and the returned field list both earn their 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 simple read-only list tool with no output schema and one optional filter, the description covers scope, the optional parameter's effect, and the returned fields. Only pagination/ordering expectations are absent, which is a minor gap.

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

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

Schema coverage is 0%, so the description must compensate for the single device_id parameter. It does so by explaining that omitting it lists zones across all devices and supplying it scopes to one device, which is the key semantic an agent needs.

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

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

States a specific verb (List) and resource (watering zones) with clear scope, plus enumerates what each zone carries (name, enabled state, water amount, schedule days). It is clearly distinct from the singular get_zone sibling, though it does not name that sibling explicitly.

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

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

The parenthetical 'across all devices or for one device' implies the two usage modes and that device_id is an optional filter, but it never states when to prefer this over get_zone or list_devices. Usage is implied rather than guided.

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, yet it says nothing about whether the rename requires device ownership, whether the old name is recoverable, or what side effects occur across zones. Only the mutation intent is implied by the verb.

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

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

A single clean, front-loaded sentence with zero waste. It is appropriately sized for the phrasing, though its brevity is a symptom of under-specification rather than disciplined economy.

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 3-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description leaves far too much unsaid. An agent has no way to confirm return behavior, error conditions, or parameter roles.

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% across 3 required parameters, and the description only obliquely implies the 'name' input. It adds no meaning for device_id or zone_id, nor any format, length, or uniqueness constraints on the new 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?

States a specific verb (rename) and resource (watering zone), so the operation is unambiguous. However, it offers no differentiation from siblings like add_zone, delete_zone, or set_zone_enabled, which is what would push this to 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?

There is no guidance on when to use this instead of add_zone, delete_zone, or other zone-mutating siblings, and no mention of prerequisites or alternatives. The agent must infer usage entirely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose a genuinely useful implementation trait — fetch-current-then-merge, so other schedule settings are preserved — which reassures the agent this is not a destructive overwrite. It says nothing about permissions, idempotency, or error behavior, which leaves meaningful gaps for a mutation tool with zero annotation coverage.

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

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

Two short sentences, action first, behavioral caveat second. No filler, no redundancy; every clause carries information.

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

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

For a two-param mutation tool with no annotations and no output schema, the description covers purpose and one behavioral nuance but omits permission requirements, failure modes, and what happens if the routine id is unknown. Adequate but not 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%, so both parameters are undocumented in the schema. The description's 'enable or disable' maps implicitly to the boolean 'enabled' parameter, but 'routine_id' format/identity is never addressed. It partially compensates for the coverage gap but not fully.

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

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

States a specific verb pair (enable/disable) and resource (watering schedule), which cleanly distinguishes it from the sibling set_zone_enabled (zones vs schedules). It does not explicitly name an alternative, but the resource noun alone makes the scope 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 makes clear this is the toggle for a routine's active state, implying its usage context. However, it gives no guidance on prerequisites (e.g. the routine must already exist) or when an agent should prefer this over list_routines/set_zone_watering style 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 full burden. It does disclose real behavioral context: disabled zones are skipped by schedules while manual watering remains possible. It omits other traits an agent would want, such as whether the change is reversible (implied by 'enable or disable'), idempotency, or permission requirements.

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

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

Two short sentences with the core action front-loaded and the behavioral caveat immediately after. No filler, no repetition of the tool name.

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 3-required-parameter mutation with no annotations and no output schema, the description covers the effect but leaves the parameter contract entirely to the schema, which documents nothing. It is adequate as a conceptual summary but not complete enough to call the tool confidently without inspecting the schema.

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

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

All three parameters (device_id, zone_id, enabled) have 0% schema description coverage, so the schema contributes nothing. The description implies the existence of an on/off flag via 'enable or disable' but never maps it to the boolean 'enabled' parameter or explains the identifiers, leaving the parameters effectively undocumented.

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

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

States a specific verb pair (enable/disable) and resource (zone), so an agent can distinguish it from set_zone_watering and set_routine_enabled by resource alone. It stops short of explicitly naming which sibling handles watering vs. enabling, so it is clear but not fully sibling-differentiated.

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

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

The second sentence explains the consequence of disabling (schedules skip the zone) and clarifies that manual watering is still allowed, which implies when the setting matters. However, there is no explicit when-to-use-vs-alternatives guidance, such as when to disable a zone rather than delete it or stop its watering.

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 never states whether this overwrites an existing schedule, whether the change takes effect immediately, what happens if both water_depth_mm and minutes are supplied, or what permissions/connectivity the device requires. Only the units semantics are 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?

Three short sentences, front-loaded with the purpose, then parameter guidance, then a concrete calibration example. Every sentence earns its place and nothing is padded.

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 mutation tool with zero annotation coverage, no output schema, and 0% parameter documentation, the description covers the core meaning but leaves key operational questions open: mutual exclusivity of the two amount parameters, override behavior, and device/zone requirements. Adequate to start, incomplete for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate: it usefully defines water_depth_mm as 'depth of water the zone should receive per watering day' and gives a concrete 9.5 mm example, plus hints that minutes is an alternative unit. But it does not resolve the either/or precedence between the two, does not mention they default to null, and says nothing about device_id or zone_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?

Clear verb+resource ('Set the scheduled water amount for a zone'), and the word 'scheduled' meaningfully distinguishes it from the sibling water_zone, which implies immediate watering. It stops short of naming that sibling explicitly, so the differentiation must be inferred from the name alone.

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

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

The phrase 'scheduled water amount' implicitly signals this configures a recurring schedule rather than triggering a one-off watering like water_zone, and 'per watering day' reinforces it. However, there is no explicit when-to-use statement, no mention of prerequisites, and no named alternative for manual watering.

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 only partially: it implies mutation and that a run must currently be active, but says nothing about what happens if no run is active, whether the action is reversible, required permissions, or any error/response behavior.

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

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

Two short sentences, front-loaded with the action and followed by the parameter-sourcing hint. No filler text and nothing that could be trimmed without losing information.

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

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

For a one-parameter mutation tool with no annotations and no output schema, the description covers intent and parameter provenance but omits failure modes and side effects, which are the remaining things an agent needs to call this safely. Adequate but with a clear gap.

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

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

Schema coverage is 0% – the schema only names 'Schedule Id' with no explanation. The description partially compensates by telling the agent where the scheduleId originates (water_zone or the device event list), but adds no format, type, or null/empty handling detail.

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

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

States a specific verb and resource ('Stop an active manual watering run'), scoping it to manual runs rather than schedules. It also names the sibling tool (water_zone) that produces the required identifier, so an agent can distinguish it from adjacent tools without opening schemas.

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

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

The description gives clear triggering context (an active manual run exists) and tells the agent exactly how to obtain the required schedule_id, from water_zone or the device event list. It stops short of an explicit 'when not' clause, e.g. distinguishing this from cancel_event for scheduled events.

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 load and does so well: it discloses the ~2 minute startup delay, that a scheduleId is returned for stopping the run, and that allow_conflicts=false makes the call fail when the device is already scheduled to water. Auth/permission behavior is not mentioned, but the operational traits are unusually well surfaced.

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?

Roughly four sentences, front-loaded with the imperative action, then parameters, timing, return value, and the conflict rule. Every sentence adds information with no filler.

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

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

For a 5-parameter mutation tool with no annotations and no output schema, the description covers action, parameter meaning, timing behavior, return identifier, and the conflict-failure case. Only the permissible combination of water_depth_mm vs minutes and any permission requirements remain unstated.

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 the description must compensate, and it does: it explains water_depth_mm (with an example range 0.5-10), minutes as runtime, and the semantics of allow_conflicts. device_id and zone_id are left implicit and the 'or' between water_depth_mm/minutes is not clarified as mutually exclusive, keeping it short of a 5.

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

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

States a specific verb and resource ('START WATERING a zone now, manually'), with emphasis that clearly separates it from scheduling siblings like set_zone_watering and from stop_watering. An agent can identify the operation without opening the schema.

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

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

The word 'manually'/'now' frames this as the immediate-run option versus the scheduled set_zone_watering sibling, and it explains the allow_conflicts failure condition. It stops short of explicitly naming the alternative tool for scheduled watering, so it is clear context rather than full when/when-not routing.

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