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

No annotations are provided, so the description carries full burden. It describes the return dictionary (status, device, task_id, message) and provides examples. It could disclose more about error handling or what happens if a device already exists, but overall it is transparent about core 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 well-structured with Args, Returns, and Examples sections. It is informative without being overly verbose, though it could be slightly more concise by merging some explanatory lines.

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

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

Given the complexity (10 parameters, no annotations) and the presence of an output schema, the description is comprehensive. It covers device types, required vs optional parameters, return format, and examples. Minor omission: it does not explain possible values for mgmt_mode beyond the default.

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

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

The schema has 0% description coverage, so the description must add meaning for all parameters. It thoroughly explains each parameter (adom, name, ip, serial_number, admin_user, admin_pass, description, platform, mgmt_mode, flags) with defaults and examples, far exceeding basic schema information.

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

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

The description explicitly states 'Add a new device to FortiManager' and distinguishes between adding a real device (with IP) and a model device (with serial number). This effectively differentiates it from sibling tools like add_model_device and add_devices_bulk.

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

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

The description provides clear context on when to use the tool by detailing two use cases (real device with IP, model device with serial number) with examples. However, it does not explicitly state when not to use it or mention alternatives like add_model_device, which could lead to slight ambiguity.

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

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

No annotations provided, so description carries full burden. It explains return values and background task behavior via flags, but does not disclose prerequisites, authentication needs, or potential side effects beyond what's implied.

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

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

Description is well-structured with Args, Returns, and Example sections. The main purpose is front-loaded. Slightly verbose but remains clear and organized.

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 complexity (3 params, one nested object) and presence of output schema (return value described), the description is fairly complete. Could mention prerequisites or error conditions not covered in the example.

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

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

Schema coverage is 0%, but description provides detailed explanations for all three parameters, including a breakdown of the device object fields. This adds significant meaning beyond the schema.

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

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

Description clearly states 'Add multiple devices to FortiManager in bulk' with specific verb and resource. The 'bulk' qualifier distinguishes it from the sibling tool 'add_device' which adds a single device.

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?

Description implies usage for efficiency when adding many devices ('Registers multiple devices at once for efficiency'), but does not explicitly state when to use instead of 'add_device' or 'add_model_device', nor provides exclusions.

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

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

No annotations provided, so description carries full burden. It describes the tool's purpose (adding a model device) but does not disclose behavioral traits like permissions needed, side effects, or that it does not add an actual device. The description is adequate but lacks depth.

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

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

The description is well-structured: introductory sentence, conceptual explanation, then clear Args, Returns, and Example sections. Every part is useful and front-loaded.

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

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

Given the presence of an output schema (mentioned in context), the description still includes a helpful Returns section. It covers purpose, parameters, returns, and an example. Could mention prerequisites like ADOM existence, but otherwise 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 has 0% description coverage, but the description provides clear explanations for all 6 parameters in the Args section, including default values and an example serial number. This adds significant meaning beyond the raw schema.

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

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

The description clearly states 'Add a model device for offline provisioning' and explains that model devices allow pre-configuring policies and settings before the actual device connects. This distinguishes it from sibling tools like add_device (adds actual device) and add_devices_bulk.

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

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

The description mentions usefulness for zero-touch provisioning workflows but does not explicitly say when not to use this tool or compare it directly with alternatives like add_device. Usage context is implied but not fully explicit.

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

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

Basic behavioral info: associates package with devices for later installation. Does not disclose side effects, permissions, or safety profile. No annotations exist, so description carries the burden but provides limited 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?

Concise and well-structured: brief statement, then Args, Returns, and Example. No redundant information, every sentence adds value.

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

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

Covers purpose, parameters, return values, and example. However, lacks details on prerequisites (e.g., existence of ADOM/package/devices) and does not clarify synchronous/asynchronous behavior. Output schema is described in Returns.

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?

While schema coverage is 0%, the description adds meaning by listing and describing each parameter (adom, package, devices with format example), compensating for the lack of schema descriptions.

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

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

The description clearly states 'Assign a policy package to devices.' with specific verb and resource, distinguishing it from sibling tools like assign_sdwan_template or assign_system_template.

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

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

No guidance on when to use this tool versus alternatives. It lacks context on prerequisites, when not to use, or comparison with similar assign tools.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as whether existing assignments are overwritten, the impact on device state, or required permissions. The return type 'Assignment result' is vague and lacks detail.

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

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

The description is short and front-loads the purpose. The Args and Returns sections are clear and structured efficiently, with no unnecessary words.

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

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

For a mutation tool with no annotations, the description lacks completeness. It does not cover error conditions, side effects, prerequisites, or the format of the return value. The agent has insufficient context to use the tool safely.

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

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

With 0% schema description coverage, the description adds value by listing parameters and stating the default value for 'vdom'. However, it does not explain the meaning of each parameter (e.g., what ADOM is) or provide format constraints beyond names.

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

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

The description clearly states the verb 'Assign' and resource 'SD-WAN template to a device', distinguishing it from bulk and system template assignments. However, it does not explicitly mention that it assigns to a single device, which is implied by the name and bulk sibling.

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

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

No guidance on when to use this tool versus alternatives like assign_sdwan_template_bulk, assign_system_template, or assign_template_group. No prerequisites or preconditions are mentioned, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description bears the full burden. It only states the action and basic parameters, but fails to disclose behavioral traits such as whether the assignment overwrites existing configurations, if it is synchronous or asynchronous, whether the ADOM must be locked, or error handling. This is insufficient for a mutation tool.

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

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

The description is concise, with a brief summary followed by parameter explanations. It avoids unnecessary words. However, it could be slightly more structured (e.g., using bullet points) for readability, but overall it is efficient.

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

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

Given the tool's complexity (writes to multiple devices) and lack of annotations, the description is incomplete. It does not cover prerequisites (e.g., adom lock), side effects (e.g., overwriting existing assignments), error scenarios, or execution outcomes beyond a vague 'Assignment result.' The output schema exists but does not compensate for missing behavioral context.

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

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

Schema coverage is 0%, but the description adds meaningful parameter semantics: 'adom: ADOM name', 'template: SD-WAN template name', and 'devices: List of devices [{"name": "dev1", "vdom": "root"}, ...]' – clarifying the expected structure of devices. This compensates for the lack of schema descriptions.

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

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

The description clearly states 'Assign an SD-WAN template to multiple devices,' specifying the verb (assign), resource (SD-WAN template), and scope (multiple devices). It distinguishes from sibling tools like assign_sdwan_template (single device) and assign_system_template_bulk (system template).

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 does not provide guidance on when to use this tool versus alternatives like assign_sdwan_template (single device) or assign_system_template_bulk. It lacks explicit when-to-use, when-not-to-use, or prerequisite information.

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

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

No annotations are present, so the description must fully disclose behavioral traits. It only states the action without mentioning side effects (e.g., overwriting existing assignments), authorization requirements, whether the operation is synchronous, or error handling. This severely limits an agent's ability to predict the tool's 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 extremely concise: one sentence for purpose, followed by a compact parameter list, and a one-line return statement. It is front-loaded and contains no superfluous information, making it easy for an agent to parse quickly.

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

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

Despite having an output schema (context signal), the description only states 'Returns: Assignment result' without specifying the structure (e.g., success flag, task ID, error details). The tool has 4 parameters and no enums, but the description lacks behavioral context (e.g., prerequisites, effects on device state). An agent would need additional information to use this tool reliably in a workflow.

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 'Args' section adds meaningful descriptions beyond the input schema's titles (e.g., 'ADOM name', 'System template name', 'Device name to assign', 'VDOM name (default: root)'). With schema description coverage at 0%, this compensation is effective, though some parameters (like adom) could benefit from more precise context (e.g., which ADOM scope applies).

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

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

The description clearly states the tool's action: 'Assign a system template to a device.' This specific verb+resource pairing distinguishes it from sibling tools like assign_sdwan_template and assign_system_template_bulk, which handle different template types or bulk operations.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., assign_system_template_bulk for multiple devices, assign_template_group for group assignments). An agent would have to infer context from the parameter list, which is insufficient for informed selection.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does not mention whether the assignment overwrites or merges, what happens on partial failure, or required permissions. This lack of detail limits the agent's ability to anticipate side effects.

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

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

The description is very concise with four lines of text plus the docstring-style args list. Every sentence is functional, though the format could be more structured (e.g., bullet 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?

The description is minimal for a bulk operation. Although there is an output schema (not shown), the description only says 'Assignment result' without hinting at the structure or success/error handling. It is complete enough for basic usage but lacks depth.

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

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

Schema description coverage is 0%, so the description must compensate. It lists the three parameters and provides an example format for the 'devices' array, adding some meaning beyond the schema. However, it does not document constraints or allowed values for adom or template.

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

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

The description clearly states the action: 'Assign a system template to multiple devices.' It uses a specific verb 'assign' and resource 'system template', and the 'bulk' suffix implies operating on multiple devices, distinguishing it from similar tools like assign_system_template.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or conditions. For a bulk operation among many similar assignment tools, explicit usage context is missing.

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

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

With no annotations, the description must fully convey behavioral traits. It states only that the tool 'assigns', which implies a create/update operation, but does not disclose idempotency, destructiveness, locking requirements, or whether the assignment replaces existing ones. This is insufficient for safe invocation.

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

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

The description is concise with a clear structure: one-line purpose, a bullet-like list of arguments, and a returns line. No extraneous information, though the returns line adds minimal value.

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

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

Given 4 parameters, no annotations, and a sparse description, the tool definition lacks completeness. It does not explain error conditions, required object existence (e.g., template_group must exist), or ADOM context. The returns line is vague. An agent would struggle to use this tool reliably without additional documentation.

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

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

Schema description coverage is 0%, so the description must add meaning beyond parameter names. It merely lists the parameter names (adom, template_group, device, vdom) without explaining their roles or constraints. The schema already provides these names, so no added value.

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

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

The description clearly states the action ('assign') and the resource ('template group to a device'), making the core purpose understandable. However, it does not differentiate from sibling tools like assign_package or assign_system_template, which share the same verb-resource pattern.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., assign_package for provisioning templates). There are no prerequisites, context, or exclusions mentioned, leaving the agent without decision support.

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

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

No annotations are provided, so the description must carry the full burden of behavioral transparency. It states 'Creates a copy' indicating a write operation, but it does not disclose important behaviors such as whether existing packages with the same name are overwritten, if the operation is idempotent, or any required permissions. The return format is described, but side effects are understated.

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 reasonably concise and well-structured with a clear docstring format (Args, Returns, Example). It includes only necessary information without redundancy. However, the example is a bit lengthy but adds value, so not penalized heavily.

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

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

Given the tool's simplicity and the presence of an output schema in the description, the context is fairly complete. It covers the function, all parameters, return structure, and an example. It could improve by mentioning preconditions (e.g., the source package must exist) or error behavior, but overall it is adequate.

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

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

The input schema has 0% description coverage, so the description's parameter details ('adom: ADOM name', 'package: Source package name', 'new_name: Name for the cloned package') add essential meaning beyond the schema. While concise, these descriptions compensate for the lack of schema annotations, meeting the baseline expectation for 0% coverage.

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

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

The description clearly states 'Clone a policy package. Creates a copy of an existing package with all its policies.' It uses a specific verb ('clone') and resource ('policy package'), and it distinguishes from siblings like create_package or delete_package by specifying that it duplicates an existing package.

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

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

The description implies when to use this tool (when you want to duplicate a package), but it does not explicitly state when not to use it or mention alternatives such as create_package. No guidance on prerequisites or comparisons is provided, so usage guidance is only implied.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It states that commits persist pending changes and is required before unlock, which is essential for a commit tool. However, it does not mention side effects, permissions, idempotency, or error handling.

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

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

The description is extremely concise, with a single-sentence functional description, a critical usage note, and clearly separated args/returns sections. Every sentence adds value with no wasted words.

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

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

For a simple commit tool with one parameter and an output schema, the description covers the essential purpose, usage timing, and return format. It could mention error conditions or prerequisites, but is largely complete given the tool's simplicity.

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

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

The schema description coverage is 0%, so the description must compensate. It describes the single parameter 'adom: ADOM name to commit', which adds minimal context beyond the schema property name and type. It does not provide format, constraints, or examples.

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

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

The description clearly states 'Commit changes to an ADOM' using a specific verb and resource, and explicitly mentions 'Saves all pending changes made to the ADOM.' It also distinguishes from sibling tools like lock_adom and unlock_adom by specifying the required order of operations ('Must be called before unlocking to persist changes').

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

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

The description provides clear guidance on when to use the tool: 'Must be called before unlocking to persist changes.' It implies usage after making changes and before unlocking, but does not explicitly exclude other scenarios or mention alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses that FQDN addresses are resolved dynamically, which is a key behavioral trait. However, it omits details on permissions, side effects, or return value behavior 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?

The description is well-organized with a docstring structure: summary, behavioral note, Args, Returns, and Example. Every sentence adds value, and it is appropriately sized with no wasted words.

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

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

The tool has an output schema, and the description includes the return structure. It also mentions dynamic resolution behavior. For a create function, this covers essential context, though error handling and prerequisites are not addressed.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all parameters with brief explanations, e.g., fqdn: 'Domain name (e.g., "www.example.com")'. This adds meaningful context beyond the raw schema property types.

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

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

The description clearly states the action ('Create an FQDN ... address object') and the resource (FQDN address object). Among siblings like create_address_host and create_address_subnet, it uniquely identifies its focus on fully qualified domain 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 description notes that FQDN addresses are resolved dynamically, which guides when to use this tool. It provides a concrete example but does not explicitly contrast with alternatives or list when not to use it.

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

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

No annotations are provided, so the description fully explains what the tool does: creates an address group, lists parameters, and specifies the return format. It could mention idempotency or error cases, but overall behavior is clear.

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

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

The description is well-structured with clear sections for purpose, args, returns, and an example. Every sentence adds value, and it is 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?

Given the tool's complexity and the presence of siblings, the description fully covers what an agent needs to know: input requirements, output format, and a usage example. It is complete.

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

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

With 0% schema description coverage, the description compensates by explaining each parameter (adom, name, members, comment) and provides a concrete example. This adds significant meaning beyond the schema.

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

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

The description clearly states 'Create an address group' and distinguishes it from siblings like create_address_fqdn or create_address_subnet by specifying it groups address objects. The example reinforces 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 implies usage for creating address groups but does not explicitly state when to use this tool versus other address creation tools. No alternatives or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention idempotency, side effects, authentication requirements, or what happens on duplicate IPs. The return format is described, but safety and mutability traits are missing.

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 structured with Args, Returns, and Example sections. It is longer than minimal but every part adds value: purpose, parameter explanations, return format, and a concrete example. No redundant sentences.

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

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

Given the tool has 4 parameters (3 required) and an output schema, the description covers parameters, provides an example, and describes the return value. It is complete for a creation tool, though behavioral context is missing. The presence of an output schema in context reduces the need to explain return values, but the description does it anyway.

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

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

Schema description coverage is 0%, but the description compensates by explaining each parameter: adom (ADOM name), name (object name), ip (with example), comment (optional). The return schema is also described in text. This adds significant meaning beyond the bare schema.

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

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

The description explicitly states 'Create a host address object (single IP)', providing a specific verb and resource. The tool name includes 'address_host', and the description clarifies it's for single IP addresses, distinguishing it from siblings like create_address_fqdn or create_address_range.

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 does not explicitly mention when to use this tool over alternatives. While the purpose 'single IP' implies the use case, there is no guidance on when not to use it or comparison with other address creation tools. The example provides context but not explicit usage 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?

No annotations provided, so description carries full burden. It describes creation, required parameters, and return format, but lacks details on idempotency, duplicate handling, or side effects.

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

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

The description is well-structured with Args, Returns, and Example sections. It is concise and front-loaded with the main purpose, earning its place without 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?

Given the tool's complexity (5 parameters, output schema), the description covers inputs and outputs well. It lacks prerequisites (e.g., ADOM existence) but is largely complete for a creation tool.

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

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

Schema description coverage is 0%, but the description provides clear explanations for all parameters (adom, name, start_ip, end_ip, comment) and includes an example, adding significant meaning beyond the schema.

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

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

The description clearly states 'Create an IP range address object.' and distinguishes from siblings like create_address_fqdn, create_address_host, etc., which are listed among sibling tools.

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

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

The description explains what the tool does but does not provide explicit guidance on when to use it vs. alternatives (e.g., create_address_host). Usage context is implied but not stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the creation action and return format, without addressing potential side effects, permissions, or constraints (e.g., handling duplicates, overwrite behavior). This is minimal transparency for a mutation tool.

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

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

The description is well-structured as a docstring with clear sections (Args, Returns, Example). It is comprehensive without being verbose, though the opening line could be slightly more concise. Every sentence adds value.

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

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

Given the tool's simplicity (4 parameters, output schema defined), the description provides a complete picture: what it does, required inputs, acceptable formats, and expected return values. It lacks edge-case behavior (e.g., duplicate handling) but is sufficient for standard use.

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

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

The schema has 0% coverage (no descriptions), but the description compensates fully by explaining each parameter: adom, name, subnet (with example formats), and comment (optional). This adds significant meaning beyond the schema's bare titles.

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 explicitly states 'Create a subnet/network address object,' using a specific verb+resource. Among sibling tools like create_address_fqdn, create_address_host, etc., it clearly distinguishes this tool as specializing in subnet addresses.

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

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

The description implies usage for creating subnet addresses by specifying the subnet parameter format (CIDR or netmask). However, it does not provide explicit guidance on when to use this tool versus alternatives (e.g., for FQDN or host addresses), nor does it mention when not to use it.

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

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

No annotations provided, so description carries full burden. It states 'create' (write operation) and 'Returns: Created CLI template group', but does not disclose potential side effects, error handling, or whether the operation is idempotent. Limited transparency for a mutable action.

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

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

Description is very short and frontloaded with the purpose. The use of 'Args:' and 'Returns:' provides a clean structure. However, it could be slightly more structured (e.g., bullet points) but is already 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?

Simple creation tool with output schema available, so description covers basic purpose and parameters. However, it lacks context about prerequisites (e.g., does the ADOM need to exist?) and behavior on conflicts. Adequate but not complete.

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

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

Schema coverage is 0%, and the description provides basic mappings for each parameter (e.g., 'adom: ADOM name'). This adds some meaning beyond the raw schema, but lacks examples, constraints, or context about valid values, making it minimally helpful.

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

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

The description clearly states 'Create a new CLI template group' with a specific verb and resource. The name itself distinguishes it from sibling create tools for other entities like packages or scripts, making purpose unambiguous.

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

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

No explicit guidance on when to use this tool versus alternatives. The name implies its purpose, but there is no mention of prerequisites or exclusions. Usage is implied but not elaborated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states that the policy is not active until installed, explains the default values for parameters like action, nat, logtraffic, and indicates that policyid is optional and auto-assigned. It does not discuss permissions or other side effects, but covers the key behavioral trait.

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

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

The description is well-organized with separate sections for Args, Returns, and an Example. It is front-loaded with the main purpose. While slightly long, every sentence provides value, and the structure aids readability.

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

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

Given the complexity (15 parameters, 8 required) and the presence of an output schema description in the Returns section, the description is complete. It covers the creation process, defaults, optional parameters, and the response format, leaving no critical gaps.

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

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

The input schema has 0% description coverage, so the description completely compensates by providing detailed explanations for all 15 parameters, including examples, defaults, and allowed values. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool creates a new firewall policy, specifies the resource (policy in a package), and differentiates from siblings like update_firewall_policy, delete_firewall_policy, etc. The verb 'create' is specific and the scope is well-defined.

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

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

The description mentions that the policy won't be active until the package is installed, providing important usage context. However, it does not explicitly state when to use this tool versus alternatives like update_firewall_policy or delete_firewall_policy, though the distinction is implied.

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

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

Without annotations, the description provides basic behavioral info (creates, returns dict) but lacks details on side effects, prerequisites, or failure modes.

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

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

The description is well-structured with a clear one-line summary, Args, Returns, and an Example, with no unnecessary information.

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

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

The description explains parameters and return value well, but lacks mention of prerequisites (e.g., ADOM must exist) or edge cases like duplicate names.

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?

Since schema description coverage is 0%, the description fully compensates by listing each parameter with type, default, and meaning in the Args section.

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

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

The description clearly states 'Create a new policy package' and explains what policy packages contain, distinguishing it from clone_package or delete_package.

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

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

The description implies it is for creating new packages but does not explicitly state when to use it vs. alternatives like clone_package or when not to use it.

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

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

With no annotations, the description must disclose behavior. It only states it creates a script and returns details, but fails to mention side effects like overwriting existing scripts, required permissions, or idempotency.

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

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

The description is structured as a clear list of arguments and a return note. It is concise without unnecessary fluff, though it could be slightly more 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?

While the description covers all parameters and mentions return value, it lacks details on error handling, prerequisites, or what the output schema contains. With 6 parameters and an output schema, more context would improve completeness.

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

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

Schema coverage is 0%, so the description compensates by explaining all parameters, including enum values for script_type and target with their defaults. However, 'adom' is only described as 'ADOM name', lacking deeper context.

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

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

The description clearly states 'Create a new CLI script.' with a specific verb and resource. It distinguishes from siblings like execute_script_on_device and update_script through the action of creation.

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

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

No guidance on when to use this tool versus alternatives (e.g., execute_script_on_device, update_script). The description lacks context for appropriate use cases or prerequisites.

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

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

No annotations are provided, so the description must convey behavioral traits. It mentions creating an empty template but omits details on permissions, idempotency, error behavior (e.g., duplicate names), or side effects. The description lacks sufficient behavioral context.

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

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

The description is concise with a clear header, a brief paragraph, and an Args/Returns section. It is well-structured and front-loaded with the main action. No extraneous text.

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

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

Given the tool has 3 parameters, no annotations, and an output schema, the description covers the basic purpose and parameters but lacks guidance on usage context, prerequisites, and behavioral details. It is minimally adequate but not comprehensive.

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

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

Schema coverage is 0% (no descriptions in schema), so the description's parameter explanations add value but are minimal: 'ADOM name', 'SD-WAN template name', 'Optional description'. These are basic synonyms of the parameter names. No constraints, defaults, or format hints beyond the schema.

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

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

The description clearly states 'Create a new SD-WAN template' and explains it creates an empty template for later configuration with interfaces, SLAs, and routing rules. This distinguishes it from sibling tools like assign, delete, get, and list operations.

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

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

The description does not provide guidance on when to use this tool versus alternatives (e.g., when to create vs clone, prerequisites like existing ADOM, or situations where an empty template is needed). No explicit when-to-use or when-not-to-use information.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It describes a creation operation and return format, but fails to mention error handling (e.g., duplicate group name), required permissions, or whether the group can be updated later. Missing typical concerns for a mutation tool.

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

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

The description is well-structured: one-line summary, bullet-style Args, Returns, and an example. It is front-loaded with the core purpose, and every sentence is informative. No redundancy or fluff.

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

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

The description covers purpose, parameters, return format with keys, and a concrete example. It is fairly complete for a simple create tool, but lacks mention of prerequisites (e.g., whether member services must exist) and conflict behavior. Still, it provides a solid functional 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 coverage is 0%, so the description must compensate. It adds meaning by defining each parameter (e.g., 'members: List of service names to include') and clarifying the optional comment. The example further illustrates usage. This exceeds baseline, though param descriptions are brief.

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

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

The description clearly states 'Create a service group' with a specific verb and resource. It distinguishes from sibling tools like create_service_icmp and create_service_tcp_udp by focusing on grouping existing services, making its purpose unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives like create_service_icmp or list_service_groups. While the function signature implies grouping, there is no guidance on selection criteria or when not to use it (e.g., for single-service creation).

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

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

No annotations exist, so the description carries the full burden. It clearly explains that this tool creates an ICMP service, defines all parameters with ranges, and specifies the return format (dict with status, name, message). It does not disclose potential side effects or permissions, but for a simple create operation, this is adequate. No contradictions with annotations.

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

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

Description is concise and well-structured with clear sections (Args, Returns, Example). The first sentence immediately states the purpose. No unnecessary words. Suitable length for the tool's complexity.

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

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

Given the tool's parameter count (5) and lack of annotations, the description covers inputs, outputs, and provides an example. The output schema exists but description still explains return fields. This is complete for an AI agent to understand and invoke the tool correctly.

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

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

Schema coverage is 0%, so the description must compensate. Each parameter is described: adom as 'ADOM name', name as 'Service object name', icmp_type with range '0-255, optional for all types', icmp_code with range '0-255, optional', and comment as 'Optional comment'. The example adds practical context (icmp_type=8 for ping). This fully explains parameter semantics 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?

Description clearly states 'Create an ICMP service object' with a specific verb and resource. The example (ping with ICMP type 8) further clarifies. This distinguishes from siblings like create_service_tcp_udp and create_service_group, which are for other service types.

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

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

The description implies usage for ICMP service objects but does not explicitly state when to use this tool vs alternatives like create_service_tcp_udp. No 'when to use' or 'when not to use' guidance is provided. Sibling tools exist for TCP/UDP and service groups, but no comparison is made.

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

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

No annotations are provided, so the description carries the full burden. It clearly describes the creation behavior, input parameters, and return format. It does not explicitly state idempotency or whether duplicates are allowed, but the examples and return schema provide sufficient context for a standard create 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 thorough but fairly long due to extensive examples. While well-structured with a clear flow (Args, Returns, Example), some redundancy exists in examples. It is acceptable but could be more 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?

Given the output schema is provided, the description covers all necessary aspects: parameter details, return format, and examples. It does not mention creation constraints like unique names or ADOM limitations, but the examples and standard service object concept imply these.

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

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

Schema coverage is 0%, meaning the description must fully compensate. It does so by explaining each parameter (tcp_portrange, udp_portrange, etc.) with format examples like '80', '8080-8090', '80 443 8080'. This adds significant meaning beyond the schema's type definitions.

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

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

The description clearly states 'Create a TCP/UDP/SCTP/UDP-Lite service object.' This is a specific verb+resource combination that distinguishes it from sibling tools like create_service_icmp or create_service_group.

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 includes multiple examples showing when to use TCP, UDP, SCTP, and UDP-Lite parameters. It implicitly guides the agent by demonstrating different use cases. However, it does not explicitly state when not to use this tool (e.g., for ICMP services), but the sibling context and name provide differentiation.

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

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

With no annotations, the description carries full burden. It discloses the failure condition (address in use) and return structure, but lacks details on permissions, side effects, or behavior when the address does not exist. Adequate but not comprehensive.

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

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

The description is concise (2 sentences plus structured Args/Returns) and front-loads the purpose and warning. Every sentence serves a purpose, though the Args/Returns could be more 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?

Given a simple delete tool with an output schema, the description covers the purpose, a key failure condition, and return format. Missing details like behavior for non-existent addresses, but overall sufficient for effective use.

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

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

Schema coverage is 0%, so the description must explain parameters. It provides basic explanations ('ADOM name', 'Address object name to delete'), which adds minimal value over the raw schema. With only two simple parameters, this is acceptable but not exemplary.

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

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

The description clearly states the verb 'Delete' and the resource 'firewall address object'. Among sibling tools like 'delete_address_group' and 'delete_firewall_policy', this tool's purpose is well differentiated.

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

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

The description includes a warning about failure when the address is in use, but does not provide explicit guidance on when to use this tool versus alternatives like 'update_address' or other delete tools. No alternatives are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It states the tool deletes (mutation) and may fail, but it does not disclose permission requirements, reversibility, or side effects (e.g., no mention of cascading effects). The return structure is described, but behavioral traits are minimal.

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

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

The description is extremely concise: one sentence for purpose, one warning, two parameter clarifications, and a return type. Every sentence earns its place with no redundancy. The structure front-loads the action and warning.

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

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

Given the simplicity (two required string parameters, no nested objects), the description covers the basic operation and output schema. However, it omits error cases beyond the warning, whether the tool is idempotent, and the expected behavior if the group does not exist. For a mutation tool, this is adequate but not complete.

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

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

The input schema provides only titles ('Adom', 'Name'), but the description adds meaning by labeling them 'ADOM name' and 'Group name to delete', which clarifies the purpose of each parameter. With 0% schema description coverage, this compensation is effective, though it could be more detailed (e.g., allowed values).

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

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

The description clearly states 'Delete an address group.' This is a specific verb and resource combination. Among siblings like delete_address, delete_service_group, etc., it is distinct because it explicitly targets address groups, not individual addresses or other 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?

The description includes a warning that deletion will fail if the group is in use by policies, but it does not provide explicit guidance on when to use this tool versus alternatives (e.g., update_address_group or delete_address). There is no mention of prerequisites or when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool deletes a group, but does not explain whether the action is reversible, what cascading effects occur, or what permissions are required. The description is too minimal.

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

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

The description is very concise, with no unnecessary words. Every sentence adds value, but it could be slightly expanded to include usage context without being verbose.

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

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

Given that no annotations are present and there is an output schema, the description still lacks details about destructive behavior, permissions, and special cases (e.g., what happens if the group is in use). It is insufficient for a delete operation.

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

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

Schema description coverage is 0%, but the description adds basic meaning to both parameters: 'adom: ADOM name' and 'name: CLI template group name'. This adds value beyond the schema, though it does not provide format or constraints.

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

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

The description clearly states 'Delete a CLI template group', which is a specific verb ('Delete') and resource ('CLI template group'), and it distinguishes itself from sibling tools like create_cli_template_group, get_cli_template_group, and list_cli_template_groups.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites, conditions, or limitations. It only lists the arguments.

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

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

No annotations are provided, so the description carries full burden. It discloses the destructive nature ('cannot be undone'), that it does not affect the actual device, and describes the return structure. It lacks details on auth needs or rate limits, but provides sufficient context.

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

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

The description is well-structured: brief one-liner, paragraph, Args/Returns sections, and an example. Every sentence adds value with no fluff, making it efficient and easy to parse.

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

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

Given the presence of an output schema and sibling tools, the description covers purpose, effect, parameters, return values, and provides an example. It is fairly complete, though it could mention what happens if the device does not exist.

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

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

With 0% schema description coverage, the description adds meaning by explaining each parameter: adom, device, and flags (with example). This compensates for the schema's lack of descriptions.

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

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

The description clearly states 'Delete a device from FortiManager' and explains the scope: 'Removes a device registration. Does not affect the actual device or its configuration.' This distinguishes it from sibling tools like add_device or get_device.

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 when to use the tool (to remove a device from FortiManager management) and warns that it cannot be undone. It does not explicitly mention alternatives or prerequisites, but given the sibling tools, no other deletion tool exists for devices.

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

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

Discloses destructive nature (cannot be undone), return format, and task mechanism via flags, though lacks permissions or prerequisites.

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

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

Concise yet complete: includes warning, parameter descriptions, return dictionary, and example. Every sentence adds value.

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

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

Covers purpose, parameters, returns, and example. Lacks detail on partial failure or concurrency, but sufficient for a delete tool.

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

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

Adds substantial meaning to all three parameters beyond schema: explains adom, devices list, and flags with example value 'create_task'.

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

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

Clearly states it deletes multiple devices in bulk, distinguishing from singular delete_device and bulk add tools.

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

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

Provides clear context for bulk deletion with a warning about irreversibility, but does not explicitly mention when not to use or alternatives.

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

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

With no annotations, the description carries full burden. It warns that the operation cannot be undone and provides a detailed return structure, disclosing behavioral traits beyond the input schema.

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

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

The description is concise and well-structured with a main statement, warning, Args, Returns, and an example. Every section adds value without unnecessary text.

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

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

The description covers parameters and returns with an example, but lacks mention of prerequisites like ADOM locking or permissions. Given the output schema exists, it is fairly complete but misses minor context.

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

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

The input schema has 0% description coverage, but the description fully compensates by explaining each parameter (adom, package, policyids) with clear semantics, adding meaning beyond types.

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

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

The description clearly states the tool deletes multiple firewall policies at once, with a specific verb and resource, and distinguishes from sibling tools like delete_firewall_policy (single) and delete_devices_bulk (different resource).

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 warning about irreversibility provides usage context, but the description does not explicitly state when to use this tool versus alternatives (e.g., delete_firewall_policy for single deletions), nor when not to use it.

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

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

The description warns that the operation cannot be undone and specifies the return format, but lacks details on idempotency, error behavior for non-existent policy, or dependencies. With no annotations, this is adequate but not comprehensive.

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 efficient: one sentence for the action, a warning line, and structured Args/Returns sections. No extraneous text.

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

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

The tool is simple, and the description covers purpose, irreversibility, parameters, and return structure. It could mention the need for ADOM write access or lock, but overall it is sufficient for a straightforward delete operation.

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

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

The description adds concise descriptions for each parameter (e.g., 'Policy ID to delete') which is valuable given 0% schema description coverage. It clarifies the meaning of each required parameter.

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

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

The description clearly states the action ('Delete') and the resource ('a firewall policy'), distinguishing it from sibling delete tools like delete_address or delete_device.

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

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

The description implies use for deleting a single policy by ID but does not provide explicit guidance on when to use this tool versus alternatives like delete_firewall_policies_bulk, nor does it mention prerequisites (e.g., ADOM lock).

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

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

With no annotations, the description carries full burden. It explicitly warns that the package and all its policies are deleted and that the operation cannot be undone, covering the key behavioral traits.

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

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

The description is concise and front-loaded with the purpose and warning. The Args/Returns section is clear but adds verbosity; could be more 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 simple delete tool with two parameters, the description covers inputs, warnings, and return format. It lacks prerequisites like ADOM lock status, but overall is adequate.

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

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

Schema description coverage is 0%, so the description must compensate. It adds only basic labels ('ADOM name', 'Package name to delete') without further context like format, allowed values, or examples.

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

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

The description clearly identifies the verb ('Delete') and resource ('policy package'), and the warning distinguishes it from non-destructive sibling tools like `get_package` or `clone_package`.

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 includes a warning about irreversibility but does not explicitly state when to use this tool versus alternatives like `delete_firewall_policy` or `update_package`. Usage context is implied but not 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?

The description only notes that it deletes a script and returns a result, but without any annotations to supplement, it fails to disclose potential side effects (e.g., irreversibility, dependencies, permission requirements). The behavioral profile is insufficient for an agent to assess risk.

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

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

The description is extremely concise at two sentences plus parameter/return lines. It is front-loaded with the primary action 'Delete a CLI script' and contains no redundant information, effectively communicating the core functionality.

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

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

Given the tool's simplicity (2 params, no annotations) and the presence of an output schema (not detailed), the description is minimally adequate. It covers the basic action and parameters but lacks context on return value structure, error conditions, or integration with other tools, leaving gaps for an agent.

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

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

With 0% schema description coverage, the description must compensate. It identifies 'adom' as an ADOM name and 'name' as the script name, adding minimal meaning beyond the schema titles. However, no additional details like format, constraints, or examples are provided, resulting in limited added value.

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

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

The description explicitly states 'Delete a CLI script', using a specific verb (delete) and resource (script), which clearly identifies the tool's function. Sibling tools like create_script, update_script, and get_script further distinguish it, confirming its unique purpose.

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

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

No guidance is provided on when to use this tool versus alternatives like delete_device or delete_address. There is no mention of prerequisites, conditions, or when not to use it, leaving the agent without contextual decision support.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only notes the assignment precondition but omits crucial details such as irreversibility, permission requirements, error behavior when the template is still assigned, and side effects on associated configurations. This is insufficient for a deletion tool.

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

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

The description is concise, using two sentences plus a compact Args/Returns structure. Essential information is front-loaded. No unnecessary words or redundancy.

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

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

The description covers the basic purpose and a key precondition, but given the lack of annotations and low parameter coverage, it fails to provide sufficient behavioral context. The presence of an output schema mitigates the need for exhaustive return details, but missing ownership, error cases, and side effects leave gaps.

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

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

Schema description coverage is 0%, so the description must compensate. However, it merely restates the parameter names ('ADOM name', 'SD-WAN template name') without providing additional context like valid formats, constraints, or examples. The added value over the schema is minimal.

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

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

The description clearly states the action ('Delete') and the resource ('SD-WAN template'), making the tool's purpose unambiguous. It is distinct from sibling tools like create_sdwan_template, assign_sdwan_template, or unassign_sdwan_template, so no confusion.

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 includes a useful precondition ('Template must not be assigned to any devices before deletion'), but it does not provide explicit guidance on when to use this tool versus alternatives. It lacks instructions on unassigning the template first, which is a prerequisite.

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

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

With no annotations provided, the description carries the full burden of disclosure. It warns that deletion will fail if the service is in use by policies, a key behavioral trait. However, it does not mention that deletion is irreversible or any authentication requirements.

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