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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description contributes useful domain semantics about what actions represent, but says nothing about auth requirements, paging behavior, or what the returned objects contain beyond the schema.

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

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

Three short sentences with the core operation front-loaded; the second paragraph is domain explanation rather than padding, though it could be trimmed slightly.

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 a full output schema, rich annotations, and 91% schema coverage, the description only needs to frame the resource, which it does. It is adequate for correct invocation, with only usage routing left implicit.

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 91%, so the schema already documents nearly every parameter including limit, offset, search and the id filters. The description adds no parameter guidance, so the baseline 3 applies.

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

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

It states a specific verb and resource ('Get actions from Zabbix') and adds a concise definition of what an action is (automated responses to problems/triggers). The resource is unambiguous and no sibling shares it, though there is no explicit differentiation text.

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 explains what actions are but not when to call this tool versus alternatives, nor when to filter by hostids/groupids/actionids versus using search. The agent must infer usage entirely from the schema.

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

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

The annotations already declare this as read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds useful behavioral context by explaining that the result reflects the connected Zabbix API version and matters for version-dependent feature compatibility.

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 definition is short and front-loaded with the core action. The second sentence partly restates the first by explaining that it retrieves the current API version, but the compatibility rationale still earns its place.

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

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

For a zero-parameter, read-only tool with an output schema and annotations covering safety traits, the description supplies the needed operational context. An agent can understand what the tool returns conceptually and why to call it without needing more detail.

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

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

The tool has zero parameters, so there are no parameter semantics to explain, which meets the baseline of 4. The description appropriately does not invent parameter details for a no-argument call.

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

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

The description states a specific verb and resource: retrieving the current Zabbix API version. It clearly distinguishes this metadata/version-check tool from the many CRUD sibling tools such as host_get, item_get, and user_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 gives clear usage context: understanding API capabilities and checking compatibility with version-dependent features. It does not explicitly state when not to use it or name alternatives, but no sibling tool provides the same version-information function.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description earns credit by disclosing the scope of what gets pulled in (items, triggers, discovery rules, graphs, macros, host groups, inventory), which tells the agent the output is large and cascading. It does not state what happens when both hostids and templateids are omitted, which is the main behavioral unknown.

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?

Purpose is front-loaded in the first line, followed by the format/output summary and then a scannable inclusion list. The only filler is the closing 'And all other configuration elements', which is forgivable as a catch-all.

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 a full input schema, an output schema, and read-only annotations, the description covers what an agent needs to invoke it correctly. The one gap is default behavior with zero IDs (export everything vs. error), which matters because no parameters are 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?

Schema coverage is 100%, so the baseline is 3; the description adds real meaning on top by explaining that exporting a host or template transitively includes its dependent objects, which reframes what hostids/templateids actually select. It does not explain the interaction of the two ID lists or the validation of format_type values beyond what the schema lists.

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+resource ("Export Zabbix configurations") and immediately narrows to hosts, templates, and their full configuration, which distinguishes it cleanly from the sibling configuration_import and from the many *_get tools that return single-object data. An agent can pick this 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?

It gives clear use contexts: backup, migration, disaster recovery, and sharing configurations. It does not name exclusions or point at a specific alternative (e.g. 'use configuration_import to restore', or 'use host_get for a single host'), so it stops short of full routing guidance.

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

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

Annotations flag destructiveHint=true and idempotentHint=false, yet the description never mentions that an import can overwrite or delete existing objects, nor that repeated imports are not idempotent. For a destructive bulk-mutation tool this silence is a significant gap – the description adds no behavioural context beyond the annotations themselves.

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 operation and resource, with no filler. The second line about formats is slightly redundant with the schema but does not waste much space.

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

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

An output schema exists so return values need not be explained, and the schema covers parameters well. However, given a destructive, non-idempotent bulk import across many object types, the description omits any warning about overwrite/delete behaviour or conflict handling that an agent would need before invoking 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?

Schema description coverage is 100%, so the schema already documents 'content', 'format_type', 'rules' and 'delete_missing' thoroughly, including the interaction between them. The description's mention of JSON/XML/YAML merely restates what the schema says, so the baseline holds.

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 ('Import configurations into Zabbix') and enumerates the object types and accepted formats, which is more than the title alone provides. It does not differentiate itself from the obvious sibling configuration_export, but the import/export split is self-evident.

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

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

Gives usage contexts ('migration, cloning, or restoring') but no when-not guidance, no pointer to configuration_export or to per-object tools, and no prerequisites. Usage is implied rather than directed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful domain context about what discovery rules do, but it does not add behavioral details beyond annotations, such as paging, filtering, or response behavior; the output schema covers return values.

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-loads the core action in the first sentence. The second sentence provides domain background rather than invocation guidance, so it is not maximally efficient, but it is not excessive.

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, rich schema, annotations, and output schema together make the tool callable. Still, for an 11-parameter list/get tool with a closely related sibling, the missing usage guidance and sibling differentiation leave a meaningful contextual 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 description coverage is 91%, so the schema already documents nearly all 11 parameters. The description adds no parameter-specific semantics, but with such high coverage the baseline of 3 is appropriate.

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

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

The description uses a clear verb+resource phrase, 'Get discovery rules from Zabbix,' and explains what discovery rules are. However, it does not distinguish this tool from the similarly named sibling 'drule_get' or clarify when this should be used instead.

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 retrieves but provides no explicit when-to-use guidance, no exclusions, and no alternatives. With siblings such as 'drule_get' and 'item_get', an agent is left to infer the correct choice from the name alone.

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

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

The annotations already establish that this is a read-only, idempotent, non-destructive operation. The description adds useful domain context about what network discovery rules do, but it does not disclose behavioral details such as pagination behavior, permissions, or response characteristics beyond what the schema provides.

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-loads the core action. The second sentence about network scanning is useful domain context, though not strictly required for selecting or invoking the tool.

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

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

Given that annotations cover safety and an output schema exists, the description is adequate for understanding the resource. However, it lacks guidance on alternatives such as 'discoveryrule_get' and does not explain when filtering or paging should be used, leaving some context 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 high at 89%, so the schema already documents most parameters well. The description adds no parameter-specific meaning or syntax, which is acceptable given the strong schema coverage but does not raise it above the baseline.

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

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

The description states a specific verb and resource: 'Get network discovery rules from Zabbix,' and clarifies that 'drule' means network discovery rules. It explains the domain well, but it does not distinguish this tool from the sibling 'discoveryrule_get,' which appears closely related.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites, filtering use cases, or any when-not-to-use conditions. It only implies usage by saying it retrieves network discovery rules.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true and destructiveHint=true, so the safety profile is carried structurally. The description adds real context about what acknowledgement means operationally and hints that closing is possible, but it never warns that the action bitmask can close problems or change severity — the destructive edges of this tool go unmentioned.

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 action and followed by the operational rationale. No filler, though the last sentence about closing drifts slightly from the tool's core purpose.

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

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

An output schema exists so return values need no explanation, and the three parameters are fully documented in schema. What remains thin is bulk semantics — whether multiple eventids are all-or-nothing — but overall an agent has enough to invoke it correctly.

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

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

Schema coverage is 100%, and the schema itself documents the action bitmask and the auto-adding of flag 4 for messages in detail. The description adds nothing about eventids (single vs. bulk), partial failures, or the action parameter, so the baseline 3 is appropriate.

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

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

The description opens with a specific verb+resource ('Acknowledge events in Zabbix') and clarifies that the targets are problems/alerts, which separates it from the read-side sibling event_get. It does not explicitly name the 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?

It gives the operational intent (show staff are aware and working the issue) and notes that events can also be closed if resolved, which implies when to reach for it. There is no explicit guidance on when not to use it, no mention of the alternate siblings (event_get, problem_get), and no stated prerequisites.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered structurally. The description adds useful semantic context (event lifecycle, ack meaning) but says nothing about result volume, default limit of 100, or that paging requires a deterministic sort — the one behavior an agent most needs to know before calling.

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 action, and no redundant restatement of the tool name. The trailing explanatory sentences are slightly verbose but earn their place by defining what an event is.

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 17 optional parameters and rich per-parameter documentation plus an output schema, the description only needs to frame the resource, which it does. Minor gaps remain around how filters combine and default truncation at 100 results, but nothing essential for correct invocation 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 94%, so nearly every parameter is already documented, including default limit, offset paging via has_more/total, and empty-list-matches-none semantics. The description adds no parameter meaning beyond that, which is the expected baseline when the schema does the work.

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 definition opens with a clear specific verb+resource ("Get events from Zabbix") and explains the domain: state-change events from trigger transitions plus recovery events. It implicitly separates itself from problem_get (current state) and event_acknowledge (mutating acknowledgement), though it never names those siblings explicitly.

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

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

Usage is only implied through domain explanation; the description never states when to use this versus problem_get or event_acknowledge, nor any prerequisites or filter-combination rules. The mention that events "can be acknowledged" hints at a related tool without routing the agent to it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds no behavioral context beyond that — no mention of pagination semantics, large-result behavior, or how filtering and select_* flags affect cost/size. The remaining sentences are domain trivia about what graphs are used for, not 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?

The first sentence is front-loaded and earns its place. The second paragraph (charts, dashboards, reports, custom views) is generic product blurb that adds no actionable information for an agent and inflates the definition without improving call accuracy.

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 schema is rich and an output schema exists, so return values need not be explained. For a 14-parameter read tool with no required args, the description is adequate but thin: it says nothing about paging discipline, how to combine graphids/hostids/templateids, or what count_output returns in context, which are the places an agent is most likely to mis-call.

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 93%, so the 14 parameters (including limit/offset paging, search, ids lists, and select_* flags) are already well documented in structured data. The description contributes no additional parameter meaning, so the baseline 3 applies.

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

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

The description opens with a specific verb and resource ("Get graphs from Zabbix"), which unambiguously separates this tool from the other resource-scoped siblings in the list (host_get, item_get, trigger_get). However, it does not sharpen that distinction by explaining what a 'graph' object is relative to its underlying items, leaving only the resource name to differentiate.

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 call this tool versus alternatives such as item_get or history_get/trend_get, which return the data that graphs render. The second paragraph describes what graphs are in general terms but gives no selection guidance, exclusions, or prerequisites.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that results are raw individual collected data points with timestamps, but does not discuss volume, performance, or pagination behavior beyond what the schema already documents.

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 with the core action. The second sentence is helpful but slightly overlaps with the first by restating that history contains individual data points.

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, full schema description coverage, and annotations covering safety, the description is complete enough for an agent to understand that this tool returns raw historical metric values. Minor missing context includes explicit guidance versus trend_get, but the structured fields carry the detailed contract.

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

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

Schema description coverage is 100%, so all eight parameters are documented in the schema, including history type matching, time filters, sorting, limit, and count_output. The description adds no parameter-specific meaning beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb and resource: retrieves raw metric values collected by items from Zabbix, with timestamps. It implicitly distinguishes history from aggregate trend data by emphasizing individual raw data points, but does not explicitly name alternatives like trend_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?

Provides implied usage for detailed system behavior analysis over time, but does not state when to use this instead of sibling tools such as trend_get or item_get, nor does it give exclusions or prerequisites.

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

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

Annotations already declare non-readOnly, non-idempotent, non-destructive, so the safety profile is covered by structured data. The description adds the practical requirement that a host name and groups are mandatory and that interfaces/templates are optional, which is useful context beyond annotations, but says nothing about duplicate-name behavior, permissions, or side effects of attaching templates.

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?

Short and front-loaded, opening with the action and then requirements. The second sentence ('Adds a new monitored host to Zabbix') largely restates the first, a minor redundancy, but the remainder each contributes a distinct constraint or capability.

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

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

An output schema exists, so return values need not be described, and the description covers the effective required fields plus the optional interfaces and template linkage that define a create call. Combined with full schema coverage and annotations, an agent has enough to invoke it correctly.

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

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

Schema coverage is 100%, so the schema already documents all eight parameters, making 3 the baseline. The description's note that host name and groups are effectively required (despite zero formally required fields) is a genuinely useful addition, but interfaces, templates, status, and the raw 'params' passthrough are not explained further.

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 ('Create a new host in Zabbix') and clarifies it adds a monitored host, so an agent knows what object is produced. It never names or contrasts with siblings like host_update or host_get, so differentiation relies on the agent inferring from names.

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 'essential for starting to monitor a new server or device' implies the situation in which to use it, but there is no explicit when-not-to-use or reference to the update/get/delete siblings. Adequate but leaves the agent to infer the boundary between create and update.

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

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

The annotations already declare destructiveHint=true, but the description adds important scope: deletion is permanent and removes all associated data including history and alerts. This is exactly the kind of behavioral consequence an agent needs beyond the annotation flags.

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, and structured around the core action, its permanence, and the destructive warning. Every sentence contributes useful information without unnecessary elaboration.

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

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

Given the single fully documented parameter, existing annotations, and an output schema, the description provides everything needed for correct invocation. It covers the action, scope of deletion, and the critical destructive consequence.

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 100% description coverage and clearly documents hostids as the list of host IDs to delete. The description adds only that one or more hosts are removed, which aligns with the schema but does not expand on parameter semantics beyond it.

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

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

The description uses a specific verb and resource: "Delete hosts from Zabbix" and "Permanently removes one or more hosts." It clearly distinguishes this tool from sibling operations like host_create, host_update, and host_get by stating the destructive host-removal purpose.

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

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

It clearly establishes the destructive context and warns "Use with caution," which helps an agent decide when this tool is appropriate. However, it does not explicitly name alternatives or conditions where deletion should not be used, such as preferring host_update for changes.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds that filtering is optional and that it returns a list, but says nothing about default paging behavior (limit=100), the has_more/total response fields it enables, or that count_output switches to a scalar return — all left to the schema.

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

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

Three short sentences, front-loaded with the verb and resource. Minor waste: the first and second sentences largely restate each other ('Get hosts from Zabbix' / 'Retrieves a list of monitored hosts from Zabbix').

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 18 fully documented parameters, an output schema, and complete annotations, the description only needs to frame the tool's role — which it does. It omits any mention of paging strategy or response-expansion flags, but those are well covered elsewhere, so the gap is small.

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

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

Schema description coverage is 100%, so baseline is 3. The description restates the filter dimensions (host IDs, groups, templates, proxies, search) that already appear as schema properties but adds no semantics of its own — e.g., that an empty ID list matches nothing, or that a deterministic sortfield is required for stable paging.

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 ('hosts from Zabbix') and names the filterable dimensions. It is clear what the tool returns (a list of monitored hosts), but it never distinguishes itself from siblings like hostgroup_get or template_get beyond the resource noun.

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?

'This is useful for discovering which hosts are available in your monitoring system' is an implied usage context rather than explicit guidance. No when-not-to-use cases and no named alternative (e.g., that mutations belong to host_create/host_update) are given, though the read-only nature of the operation makes the choice fairly obvious.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the agent knows this is a non-destructive, non-idempotent write. The description adds useful domain context about why host groups matter (permissions, templates, maintenance windows) but does not say what happens if the name already exists, which is the most likely failure mode for a non-idempotent create.

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 core action is front-loaded in the first sentence, and the follow-up paragraph is brief and informative rather than repetitive. It could be tightened, but nothing is wasted verbatim on restating the name or title.

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

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

An output schema exists, so return values need no explanation, and annotations cover the safety profile. However, for a non-idempotent create the description should mention duplicate-name behavior or scope (per-host vs global), which it omits; the tool is simple, but that remaining gap is a real one an agent would hit.

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 parameter with 100% schema description coverage, which sets the baseline at 3. The description adds no meaning beyond the schema — nothing about name uniqueness, allowed characters, or length — so it neither compensates nor subtracts.

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 first sentence names a specific verb and resource: "Create a new host group in Zabbix." That is unambiguous and the create/get/update/delete siblings make the intent obvious. It stops short of explicitly contrasting itself with hostgroup_update or hostgroup_get, so it is clear but not sibling-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?

The description never says when to use this versus hostgroup_update or host_create, and gives no prerequisites such as required auth or whether the host group must already exist somewhere. The second paragraph explains what host groups are for conceptually, which is background rather than invocation guidance.

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

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

Annotations already declare destructiveHint=true, so the description earns credit for going further: it states deletion is permanent and explains the cascade — group membership is severed while host entities persist unless separately deleted. It stops short of covering downstream objects tied to the group (items, triggers) 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?

Three short sentences, front-loaded with the action, and the cascade note is placed where it matters. The first two sentences overlap slightly ('Delete host groups' / 'Permanently removes one or more host groups'), a minor 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?

With an output schema present and 100% schema coverage, the description needn't detail return values, and it covers the destructive semantics well. The remaining gap is the fate of items, triggers, and templates associated with the deleted group, which an agent doing impact assessment would want.

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

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

Schema coverage is 100% and the single groupids parameter is documented in-schema as 'Group IDs to delete.' The description's 'one or more host groups' only mildly reinforces that the parameter accepts a list, so baseline 3 applies.

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

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

The description leads with a specific verb and resource ('Delete host groups from Zabbix') and restates the scope as one or more groups. It's unambiguous what the tool does, but it doesn't differentiate itself from siblings like hostgroup_update or hostgroup_create beyond the verb.

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

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

Usage is implied by the delete verb but there is no explicit when-to-use / when-not-to-use guidance, no mention of prerequisites like permissions, and no pointer to hostgroup_update as the non-destructive alternative. The note that hosts survive deletion gives partial context, but routing guidance is absent.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds domain context about what host groups represent, but says nothing about result size, paging behavior, or permission scoping beyond the schema.

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

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

Two short paragraphs with the action front-loaded in the first sentence. The second paragraph is explanatory domain filler that aids understanding but does not directly help invocation, keeping it just short of a 5.

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

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

With an output schema, full parameter documentation, and read-only annotations, the description does not need to restate return values or paging mechanics. What remains thin is guidance on when to reach for this tool, which is covered under usage rather than completeness.

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

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

Schema description coverage is 100% and each parameter (limit, offset, search, group_name_contains, select_hosts, count_output) is documented inline with defaults and semantics. The description only generically mentions 'optional filtering' and adds nothing beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Get host groups from Zabbix') and clarifies the object being retrieved, which distinguishes it from host_get or trigger_get by resource. It does not explicitly contrast with siblings like hostgroup_create/update/delete, 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?

Says retrieval supports 'optional filtering' but gives no guidance on when to use this versus host_get, trigger_get, or the hostgroup mutation siblings, and no prerequisites or exclusions. An agent must infer usage from parameter names alone.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the safety profile is covered. The description usefully narrows the mutation scope to renaming only, but it does not address behavior the annotations flag, such as non-idempotency or what happens when the groupid does not 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 first two sentences restate the same fact ('Update an existing host group' / 'Modifies properties of an existing host group'), which is wasted space. The genuinely useful line about specifying only changed fields is buried last rather than front-loaded.

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

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

An output schema exists so return values need not be explained, and the annotations cover the safety profile. For a mutation tool, however, the description says nothing about error conditions or whether group names must be unique — a gap an agent would likely hit.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantic meaning by stating that fields are optional and only changed fields should be sent — critical since groupid is the sole required parameter. It does not add format or constraint detail beyond that.

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

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

States a specific verb and resource ('Update an existing host group in Zabbix') and clarifies via the schema that only the group name is mutable. The sibling set (hostgroup_create/delete/get) makes the distinction by name straightforward, though the description itself does not call out those siblings.

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?

'Only specify the fields you want to change' gives concrete guidance on how to invoke it as a partial update, which is the main decision an agent faces here. It stops short of explicit when-to-use/when-not or naming alternatives like hostgroup_create.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=true, and the description adds partial-update semantics beyond that. It does not itself disclose that template changes unlink templates or delete collected data (that lives only in the schema), nor does it mention permission requirements or the effect of omitted fields beyond the generic instruction.

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 the core action front-loaded and the partial-update rule placed last where it is most actionable. The middle sentence slightly overlaps the first in listing properties, but there is no real padding.

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

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

With an output schema present and full schema coverage, the description only needs to frame the operation, which it does adequately. The remaining gap is behavioral rather than structural: side effects of template replacement and required auth level are left to the schema and annotations.

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

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

Schema description coverage is 100%, so every parameter is already documented, including the destructive semantics of templates and templates_clear. The description restates the set of editable fields but adds no syntax, format, or edge-case detail beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource ("Update an existing host in Zabbix") and enumerates the mutable properties, which makes clear it is the mutation counterpart to host_create/host_delete. It never explicitly differentiates itself from those siblings in text, relying on the reader to infer from the name.

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

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

"Only specify the fields you want to change" is genuinely useful partial-update guidance. However, there is no explicit statement of when to use this versus host_create, host_delete, or template_update, and no prerequisites (e.g., permissions, host must exist) 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description adds domain context about what an item represents (metric, collection method, interval, data type) but does not disclose creation side effects, uniqueness constraints, required permissions, or failure behavior. With annotations covering the safety profile, this is adequate but incomplete.

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 and front-loads the action. The item-model explanation is useful and compact, though the latter sentences are more conceptual than invocation-critical.

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 9 parameters, 5 required, with full schema descriptions, annotations, and an output schema, so return values and most parameter detail are covered elsewhere. The description supplies purpose and item-model context, but omits operational prerequisites and sibling-routing guidance, leaving it complete enough but not rich.

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

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

Schema coverage is 100%, and the schema documents types, defaults, and conditional requirements such as delay=0 for trapper/dependent items and interfaceid being required for certain item types. The description only echoes the high-level fields and adds no syntax or conditional guidance beyond the schema.

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

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

The description opens with a specific verb and resource ("Create a new item in Zabbix") and explains what an item is. It does not explicitly differentiate from siblings such as item_update or item_get, so it is clear but lacks sibling-routing language.

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 guidance, and it never mentions item_update for modifying existing items or prerequisites for creation. Usage is only implied by the verb "Create".

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the safety profile is covered. The description still adds genuine value beyond them by disclosing that deletion is permanent and that historical data removal depends on Zabbix configuration.

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 core action is front-loaded in the first line, with two short supporting sentences. The hedged clause about configuration slightly dilutes the second sentence but still earns its place by warning about irreversible data loss.

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

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

An output schema exists, so return values need not be explained, and the single parameter is fully documented in the schema. Destruction consequences are covered; only permission requirements and effects on dependent triggers/entities 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?

Only one parameter exists with 100% schema description coverage, so the schema already documents itemids. The description reinforces that multiple IDs are accepted but adds no format or retrieval details beyond that, making baseline 3 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?

States a specific verb+resource (delete items from Zabbix) and clarifies scope as 'one or more items', which matches the itemids array. It is trivially distinguishable from item_create/item_update/item_get siblings, and there is no competing item-deletion tool to confuse it with.

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

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

Usage is implied by the destructive framing ('Permanently removes'), which signals caution, but there is no explicit guidance on when to delete versus alternatives such as disabling or updating an item, and no stated prerequisites or required permissions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds domain context that items define collected metrics and produce value streams, but it does not add operational behavior such as pagination, permissions, or response effects. With annotations carrying the safety signal, this is adequate but not rich.

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

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

The definition is front-loaded with the purpose in the first sentence and then uses two short sentences to define items. It is appropriately sized and has little waste. The extra definitional context is useful but not strictly essential.

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 18 parameters, but 94% schema coverage and an output schema mean the description does not need to explain parameters or return values. Annotations cover the read-only/idempotent safety profile. The missing piece is explicit guidance on when to use this tool versus related read tools such as history_get or trend_get.

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 94%, so the 18 parameters are already well documented in the schema. The description adds no parameter-specific meaning beyond the schema. A baseline 3 is appropriate when the schema does nearly all 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?

The first sentence states a specific read verb and resource: 'Get items (metrics) from Zabbix.' The follow-up explains what items are, which helps distinguish this data-source resource from adjacent tools. However, it does not explicitly contrast with siblings such as itemprototype_get or item_update/create/delete.

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 explicit when-to-use guidance or alternatives. It never says when to choose item_get over history_get, trend_get, or itemprototype_get, nor when not to use it. Usage is only implied by the verb '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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds useful domain context (what a prototype is and how it is produced) but says nothing about pagination behavior, the count_output mode, or result size limits that the schema hints at.

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 no filler. The second sentence earns its place by disambiguating the domain term, though it is arguably the only thing beyond the 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?

With an output schema present and annotations covering safety, the description need not explain return values. But for an 11-parameter, filter-heavy list tool it omits any mention of filtering capabilities, deterministic sorting for paging, or the count-only mode, leaving a gap the schema only partially fills.

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 91%, so nearly all 11 parameters are documented inline (limit/offset paging, hostids, itemids, discoveryids, count_output, sortfield). The description adds no parameter-level meaning beyond the schema, which is the correct baseline behavior here.

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 item prototypes from Zabbix") and even explains the domain concept (template items generated by discovery rules). However, it never distinguishes itself from close siblings like item_get or discoveryrule_get, so the agent must infer the boundary.

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

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

There is no explicit guidance on when to call this versus item_get, discoveryrule_get, or template_get. The only hint is the conceptual note that prototypes come from discovery rules, which implies usage but never states a selection condition or exclusion.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds that only supplied fields are changed, but is silent on permissions, what happens to omitted/null fields, and failure behavior for non-existent items. No contradiction with annotations.

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

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

Front-loaded with the action, then scope, then the key partial-update rule. Slightly redundant: 'Modifies properties of an existing monitoring item' restates the opening sentence without adding 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?

A 6-parameter mutation tool with full schema coverage, an output schema, and annotations covering the safety profile. The description is adequate; the only minor gap is that omitted-field behavior and permissions are left implicit.

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

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

Schema description coverage is 100%, so each of the 6 parameters is already documented. The description echoes four of them (name, interval, units, status) without adding format or constraint detail beyond the schema (e.g., delay syntax '30s'/'5m' comes from the schema, not the description). Baseline 3 applies.

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

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

States a specific verb and resource ('Update an existing item in Zabbix') and clarifies it modifies properties of an existing monitoring item rather than creating one. The verb alone distinguishes it from item_create/item_delete/item_get siblings, 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?

'Only specify the fields you want to change' gives useful partial-update guidance and implies the item must already exist. However, it never states prerequisites (permissions, item lifecycle state) or when to prefer item_create versus this tool.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutating-but-non-destructive profile is covered structurally. The description's genuine addition is the effect semantics: alerts are suppressed during the window, which motivates creation. It does not mention overlap with existing maintenance, permission requirements, or that non-idempotent calls create duplicates, so a 3 is appropriate.

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

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

Three short sentences, front-loaded with the action, then the semantic explanation, then use cases. No filler or restatement of the title.

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

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

With an output schema, full parameter documentation, and annotations present, the description only needs to supply purpose and context, which it does. Minor gaps remain around target scoping (hosts vs. groups) and scheduling edge cases, but nothing blocks a correct call.

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

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

Schema description coverage is 100%, including the subtle constraint that at least one of groupids/hostids is required and the timeperiods fallback behavior, so the schema does the heavy lifting and a 3 baseline applies. The description adds no parameter-level meaning of its own — no mention of target scoping or timestamp units.

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 ('Create a new maintenance period in Zabbix') and immediately explains what that object means ('Schedules a maintenance window when monitoring alerts are suppressed'). The verb distinguishes it cleanly from maintenance_get, maintenance_update, and maintenance_delete in the sibling list.

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

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

Gives concrete when-to-use context — 'planned upgrades, patching, or system maintenance without triggering false alarms' — which tells the agent the operational scenario. It stops short of exclusions or naming alternatives (e.g. use maintenance_update to extend an existing window instead of creating a duplicate), so it is clear but not fully directive.

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

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

Annotations already set destructiveHint=true and idempotentHint=false, so the bar is lower. The description still adds genuine behavioral context beyond those flags: alert generation resumes immediately on cancel, and already-passed periods keep their historical suppression, which affects how an agent should reason about the consequences of deletion.

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 the purpose front-loaded followed by two clauses that each carry distinct behavioral information: immediate alert resumption and retained historical suppression.

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 destructive mutation with annotations and an output schema, the description covers the essential side effects a caller must know. The only remaining gap is error behavior for invalid or not-found IDs, which is a minor omission.

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

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

Schema description coverage is 100% and the single required parameter (maintenanceids array) is documented there, so baseline is 3. The description adds nothing about batching, how nonexistent or already-deleted IDs are handled, or whether partial success is possible.

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 ('Delete maintenance periods from Zabbix'), which an agent can immediately distinguish from the maintenance_get, maintenance_create, and maintenance_update siblings. It doesn't explicitly name those alternatives, 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 makes clear what deleting accomplishes (cancels windows, resumes alert generation), which implies when to reach for it, but it never states when-not to use it or points to maintenance_update as the way to modify rather than remove a window. 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful domain semantics — that alerts are suppressed during these windows — but says nothing about result size, paging behavior, or the count_only mode, which are the operationally relevant traits.

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

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

Three short sentences, front-loaded with the action, then useful domain context. Slight redundancy between sentences two and three, but 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 an output schema present, well-covered parameters, and explicit read-only annotations, the description covers what remains needed. Only the routing question (why choose this over other getters) is left unanswered.

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 89%, with limit, offset, hostids, groupids, maintenanceids, sortfield, sortorder, and count_output all documented inline. The description contributes no additional parameter meaning, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get maintenance periods from Zabbix') and clarifies what a maintenance window is. It does not explicitly contrast with maintenance_create/update/delete, but the naming makes the read-vs-write split 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?

Explains what maintenance windows are conceptually, but gives no guidance on when an agent should call this versus siblings such as problem_get, host_get, or maintenance_create. No exclusions, no typical triggers for invoking it.

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

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

Annotations declare destructiveHint=true and idempotentHint=false, so the description should warn about the destructive behavior; instead it merely says time periods "can be changed" without disclosing (as the schema does) that the array replaces all existing periods. The partial-update sentence adds genuine value beyond annotations, but the destructive/idempotency implications are left undisclosed.

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

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

The core action is front-loaded in the first sentence and the operative guidance is short and actionable. The second sentence ("Modifies properties of an existing maintenance window") largely restates the first, so a small amount of text does not fully earn 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?

An output schema exists, so return values need not be explained. But for a destructive, non-idempotent mutation the description omits the risk context an agent needs — that passing timeperiods wipes and replaces all periods, and that maintenanceid must reference an existing window.

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

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

Schema description coverage is 100%, so the baseline is 3. The description enumerates the mutable fields (name, start time, end time, time periods, description) consistent with the schema, but adds no format, timestamp-unit, or nesting semantics beyond what the schema already documents.

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 ("Update an existing maintenance period in Zabbix") and the word "existing" implicitly separates it from maintenance_create/maintenance_delete. It stops short of naming those siblings or the maintenance_get read path, so differentiation is inferred rather than 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?

"Only specify the fields you want to change" gives useful partial-update guidance, which is real usage context. However there is no statement of when to use this versus maintenance_create, no prerequisites (permissions, whether the window must be active), and no 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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is fully covered without description help. The description adds useful domain context about media types being notification channels consumed by actions, but says nothing about result shape, paging or filtering behavior beyond what the schema provides.

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 the retrieval statement front-loaded. The two explanatory sentences on media types are background rather than invocation guidance, but they are brief and help ground the resource without bloat.

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

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

For a simple read-only list tool with 9 well-documented optional parameters and an output schema, the description plus structured fields are sufficient to call it correctly. The only real gap is routing guidance relative to sibling getters.

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 89%, so nearly every parameter is already documented in the schema (limit, offset, search, sortfield, mediatypeids all carry explanations). The description contributes no additional parameter semantics, which is acceptable at this coverage level but not value-adding.

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 media types from Zabbix') and explains what a media type is, so an agent knows exactly what this retrieves. It does not explicitly distinguish itself from sibling list tools such as action_get, though the resource noun is 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 explains what media types are used for in Zabbix but never says when an agent should call this tool versus the many other *_get siblings, nor any preconditions or exclusions. Usage must be inferred purely from the resource 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?

The readOnly/idempotent/non-destructive annotations establish the safety profile, so the description's burden is lighter. It adds useful domain semantics — that problems are tied to triggers and are operator-acknowledgeable, hinting at a follow-up with event_acknowledge — but says nothing about pagination behavior, result size, or ordering despite a deterministic-sort requirement for paging that the schema itself flags.

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 the core action front-loaded and no filler; the domain definition earns its place by clarifying what a 'problem' is. It could still be tighter given how little of it is actionable.

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

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

With an output schema present and near-total parameter coverage, the description needn't explain returns or fields. But for an 18-parameter, zero-required query tool, it offers no guidance on which filters matter or how to page safely, so the agent must reconstruct calling strategy from the schema alone.

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 94%, so all 18 parameters are already documented in the schema, including paging, filtering, severity, and the name_contains shortcut. The description adds no parameter-level meaning beyond that, which is acceptable at this coverage level but earns only the baseline.

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 definition gives a specific verb and resource ("Get problems from Zabbix") and defines what a problem is — an active trigger state indicating an infrastructure issue — which implicitly distinguishes it from trigger_get or event_get. However, it does not name any sibling tool, so the agent has to infer that problems are the current-state view rather than the historical event view.

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 never says when to call this tool versus event_get (event history), trigger_get (trigger definitions), or event_acknowledge (acknowledging). It gives domain context but no usage conditions, alternatives, or prerequisites, leaving the agent to infer the routing from the tool name alone.

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

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

Annotations already declare a non-readonly, non-idempotent, non-destructive write, so the agent knows this mutates state. The description adds domain background about distributed monitoring but nothing beyond annotations about failure modes (duplicate name, auth requirements, TLS setup) or what is returned, which are the details a create call actually needs.

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 action statement is front-loaded in the first line and the second paragraph is short explanatory context rather than filler. It is slightly verbose for a three-parameter create tool, but nothing is redundant.

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

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

An output schema exists, so return values need not be explained, and all three parameters are documented, leaving the description to establish what a proxy is and why one would create it – which it does. The only real gap is post-creation behavior on naming conflicts or permissions.

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

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

Schema description coverage is 100%, with name, optional description, and operating_mode (0=active, 1=passive) all documented in the schema. The description adds no formatting, defaults, or semantics beyond what the schema already states, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Create a new proxy in Zabbix') and follows with what a proxy is for, so the object is unambiguous. It does not explicitly contrast with the sibling proxy_get/proxy_update/proxy_delete, relying on the name to do that routing work.

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 paragraph gives a use case ('firewall-separated networks or high-latency connections'), which hints at when this capability matters, but it never says when to choose this tool over proxy_update, proxy_get, or configuration_import, nor any prerequisites such as required permissions or name uniqueness.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds real value beyond that: it warns that host assignments break and must be reassigned, and that proxy data is typically retained — consequences an agent cannot infer from annotations alone. It stops short of saying what happens on invalid IDs or partial batch failure.

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 action and its permanence, followed by the two operational consequences. 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?

The presence of an output schema removes the need to describe return values, and annotations cover the safety profile, so the description's coverage of permanence and host reassignment fills the main gap. A note on how to obtain proxy IDs or behavior on nonexistent IDs would make it 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 100% with a single required 'proxyids' array already documented as 'Proxy IDs to delete.' The description adds no format, source, or batching guidance beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Delete proxies from Zabbix') and reinforces scope with 'Permanently removes proxy definitions.' An agent can immediately distinguish this from proxy_get, proxy_create, and proxy_update in the sibling list.

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

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

Usage is implied by the destructive verb, but the description never states when to use this versus alternatives (e.g., proxy_update to repoint a proxy) or that proxy IDs must first be obtained via proxy_get. No explicit prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered structurally. The description adds only encyclopedic context about what proxies do; it says nothing about pagination behaviour, result ordering, whether an empty proxyids list matches nothing, or which Zabbix version quirks apply — all of which are behavioural and would warrant credit.

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?

Front-loaded with the action in the first four words, then three short sentences with no redundancy. The two explanatory sentences are optional background rather than wasted space, but they push the operational content out of the way slightly.

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

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

Output schema exists and annotations cover safety, so the description does not need to explain return values. However, for a 9-parameter paged list tool with a version-dependent search field, the description leaves the agent without any operational framing beyond a definition of proxies.

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 89%, so the schema already carries the parameter meaning (limit/offset defaults, search rename from host to name in 7.0, empty-list semantics). The description adds nothing about any of the 9 parameters, so the baseline 3 applies rather than a higher score.

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

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

States a specific verb and resource ('Get proxies from Zabbix') and follows with a plain-language definition of what a proxy is, so an agent unfamiliar with Zabbix can place the resource. It does not explicitly contrast itself with proxy_create/proxy_update/proxy_delete, though the read-only verb makes the distinction easy to infer.

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 call this versus other retrieval tools, no mention of the paging pattern (limit/offset/sortfield), no guidance on proxyids vs search vs filter_params, and no mention of when count_output should be preferred. The only 'usage' content is domain background, not invocation routing.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false. The description adds real context beyond them: unspecified fields are left unchanged, which tells the agent this is a safe partial mutation. It omits consequences the agent would want, such as what happens to hosts assigned to a proxy when operating_mode flips, or name-uniqueness constraints.

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?

Short and front-loaded, with the action stated in the first sentence. The second sentence partly restates the first ("Modifies properties of an existing proxy"), costing a little redundancy, but overall it is compact.

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 four-parameter mutation with full schema coverage, annotations, and an output schema, the description covers what the tool does and how minimally to call it. Only the side effects of a proxy-mode change are left unexplained, 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 description coverage is 100%, so the schema already documents all four parameters including the 0=active/1=passive encoding. The description restates the same field list (name, operating mode, description) without adding format, constraints, or edge-case meaning beyond the schema. Baseline 3 applies.

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

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

Names a specific verb and resource ("Update an existing proxy in Zabbix") and enumerates the mutable fields, so the agent knows exactly what changes. It does not explicitly contrast with proxy_create/proxy_delete/proxy_get siblings, though the verb alone makes the distinction fairly obvious.

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

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

"Only specify the fields you want to change" gives useful partial-update guidance that implies this is an edit-in-place operation. However, there is no statement of prerequisites (proxy must already exist, valid proxyid), no exclusions, and no explicit routing to sibling tools.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the risk profile is known. The description adds useful context that this runs arbitrary commands remotely for remediation or configuration changes, which is consistent with the annotations, but it does not warn about irreversibility, permission requirements, or that results depend entirely on the script's contents. It adds some value over the annotations without being rich 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?

Two short sentences with the core action front-loaded. The second sentence earns its place by narrowing the action domain, though it partially restates the first and could be merged.

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

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

An output schema exists, so return values need not be explained, and parameters are fully covered by the schema. However, for a destructive remote-execution tool the description omits key operational caveats — prerequisite of a pre-existing script, execution target type (agent/proxy/server), permission requirements, and whether the call is asynchronous. These are material gaps for correct invocation.

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

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

Schema description coverage is 100% for both required parameters (hostid and scriptid), so the schema fully documents them. The description adds no format, source, or discovery hints (e.g., where to obtain a valid scriptid) beyond what the schema provides. Baseline 3 applies when the schema carries the parameter burden.

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

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

The first sentence gives a specific verb and resource ("Execute a script on a host in Zabbix") that clearly separates it from script_get, the only script-related sibling. The second sentence reinforces scope by naming the kinds of actions performed. It stops short of explicitly contrasting itself with siblings, so it lands at 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?

"Used for executing remediation tasks, configuration changes, or diagnostic commands remotely" implies the usage context, but there is no explicit when-to-use versus when-not, no mention that the script must already be defined in Zabbix, and no guidance on prerequisites such as permissions or target host type. The agent must infer these 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered structurally. The description adds useful domain framing about what scripts are used for, but says nothing about permissions, return volume, or paging behavior beyond what annotations and schema already give.

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?

Front-loaded with the core action in one short sentence; the follow-up definition of scripts is relevant domain context. Slightly padded — the second sentence could be trimmed — but nothing is misleading or wasteful.

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 11 parameters, an output schema present, and rich schema descriptions, the definition is functionally sufficient to call the tool. However, for a list tool with search/host/group filtering, the description gives no hint that these filtering capabilities exist, leaving the agent to discover them purely from 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?

Schema description coverage is 91%, so nearly every parameter (limit, offset, search, hostids, groupids, scriptids, sortfield, count_output) is already documented in the schema. The description adds no parameter-level meaning, which is the baseline-3 case when the schema carries the load.

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 clear verb and resource ('Get scripts from Zabbix') and adds a definition of what a script is. An agent can tell this is a read/list operation on scripts, but the description never distinguishes it from the sibling 'script_execute', which is the key ambiguity an agent faces here.

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 versus 'script_execute' or any other sibling, and no mention of the filtering/paging behavior that would tell an agent how to narrow a query. Usage is only implied by 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful domain context about service hierarchies, but does not disclose operational behavior such as pagination, auth requirements, or response shape beyond what the schema and output schema provide.

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, and appropriately sized. The first sentence identifies the operation, and the following sentences explain the resource domain. The generic service explanation is useful but not strictly necessary, keeping it just below maximally concise.

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 10 optional parameters, 90% schema description coverage, an output schema, and read-only annotations, the description does not need to restate parameter or return details. It could be more complete by mentioning paging/counting or when to choose this over other retrieval tools, but the structured metadata covers most requirements.

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

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

Schema description coverage is 90%, so the schema already documents nearly all parameters, including limit, offset, search, parentids, serviceids, sortfield, sortorder, and count_output. The description adds no parameter-specific meaning beyond the schema, which is acceptable at the baseline for high-coverage schemas.

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

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

The description states a specific verb and resource: 'Get services from Zabbix.' It also clarifies that services are business capabilities/applications and can form dependency hierarchies, which helps distinguish this from other *_get tools. It does not explicitly name sibling alternatives, 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?

The description says what the tool retrieves but gives no explicit guidance on when to use it versus alternatives, nor when to use specific parameters such as parentids, search, count_output, or paging options. Usage is only implied by the tool name and resource domain.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is fully covered structurally. The description adds only background about what SLAs conceptually are, not how the tool behaves — nothing about paging, the count_output mode, sort determinism, or response shape (even though an output schema exists, the paging/count interaction is behavioral context the schema's parameter docs only partially cover).

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 lead sentence is front-loaded and useful; the two following sentences are domain tutorial content that doesn't help an agent invoke the tool. Appropriately short, but with 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?

With an output schema and near-complete parameter docs, an agent can call this correctly. What's missing is the sibling routing context (service_get vs sla_get) and any behavioral note on the two output modes.

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 90%, so limit, offset, slaids, serviceids, count_output and sortfield are already well documented in the schema. The description adds no parameter meaning beyond that; baseline 3 applies.

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

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

States a specific verb and resource ("Get SLAs from Zabbix") and the definitional sentence clarifies what an SLA is. However, it does nothing to distinguish this from the closely-related sibling service_get, which also retrieves availability objects.

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 indication of when to use this versus service_get, nor any prerequisite or exclusion guidance. The only implied usage is 'retrieve SLAs', which the name already conveys.

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

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

Annotations already declare readOnlyHint=false and idempotentHint=false, so the write nature is covered, but the description adds no behavioral context beyond that. It does not mention that repeated calls create duplicates, that the 'host' technical name must be unique, or what happens when a group id is invalid.

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?

Front-loaded with the action in the first sentence, with the explanatory paragraph following. The conceptual explanation is slightly verbose for a tool definition but not wasteful.

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 annotations, an output schema, and full schema coverage, the structured data covers most needs, but for a non-idempotent create operation the description omits uniqueness constraints and group-existence prerequisites, leaving a meaningful 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 description coverage is 100%, so the four parameters are fully documented in the schema, and the description adds no parameter-level detail. Baseline 3 applies when the schema carries the burden.

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

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

States a specific verb and resource ('Create a new template in Zabbix') and clarifies what a template is, making it easy to distinguish from template_get, template_update, and template_delete. The second paragraph adds domain meaning without obscuring the action.

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

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

The description explains why templates are useful but never states when to choose this tool over siblings (e.g., template_update for existing templates), nor does it mention prerequisites such as groups needing to exist first. Usage is only inferable from the verb.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds substantial behavioral context beyond those flags: deletion is permanent, applied hosts lose the template's items, triggers, and graphs, but the hosts themselves remain. This is exactly the kind of impact disclosure an agent needs for a destructive 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 three short sentences with the core action front-loaded. Every sentence adds value, especially the cascade impact note, and there is no redundant boilerplate.

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 destructive template-deletion tool with complete input schema coverage, annotations, and an output schema, the description supplies the critical behavioral detail an agent would otherwise lack: permanence and downstream effects on hosts. Nothing essential to correct invocation 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 100%, and the single parameter 'templateids' is already documented as an array of template IDs. The description's phrase 'one or more templates' is consistent with the schema but does not add meaningful syntax or usage detail beyond it. Baseline 3 is appropriate when the schema carries the parameter documentation.

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

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

The description states a specific verb and resource: delete templates from Zabbix. It is clearly distinguishable from sibling tools such as template_get, template_create, and template_update. The additional sentence about permanent removal reinforces rather than obscures the purpose.

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

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

The description makes the use case clear: permanently removing one or more templates. It does not explicitly name alternatives like template_update for non-destructive changes, but the deletion context is unambiguous. The warning about affected hosts gives useful context for when caution is needed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds domain context about what templates are, but does not disclose operational details like pagination behavior, default result size, or that count_output changes the return type. Given annotation coverage, a 3 is appropriate.

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

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

The purpose is front-loaded in the first sentence. The second and third sentences are definitional rather than behavioral, which is mildly extraneous for a retrieval tool but still useful context for agents unfamiliar with Zabbix templates.

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 a 16-parameter schema, an output schema present, and safety annotations, the structured fields compensate for much of the description's brevity. Still, the description does not mention filtering, sorting, or selection capabilities at all, which is a notable gap for a tool of this complexity.

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

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

Schema description coverage is 94%, so the schema already documents nearly all of the 16 parameters in detail. The description itself provides no parameter-specific semantics, so the baseline of 3 applies when the schema does the heavy lifting.

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

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

The first sentence states a clear verb and resource: 'Get templates from Zabbix.' An agent can distinguish this from write siblings like template_create/template_update by the verb. However, it does not explicitly differentiate from other read tools such as host_get or item_get, relying on the resource 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 description offers no guidance on when to use this tool versus alternatives, nor any conditions or exclusions. It does not mention the available filtering modes (templateids, hostids, groupids, search) or when to prefer one over another, leaving the agent to infer usage entirely from the schema.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds that only name and description are editable and supports partial updates, but it does not mention permissions, side effects, or 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?

The description is short and front-loaded with the core action. It has mild redundancy between "Update an existing template" and "Modifies properties of an existing template," but remains 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 presence of an output schema, full parameter schema coverage, and annotations, the description is largely complete for a simple mutation tool. It could mention required templateid or permissions, but those are reasonably covered by structured data.

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