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 mentions the outcome ('snippet's configuration is applied to firewalls'), implying a write operation, but lacks details on permissions, side effects, error conditions, or response format. This leaves significant behavioral gaps for a mutation tool.

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

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

The description is front-loaded with the core purpose, followed by parameter details in a structured 'Args' section. It avoids unnecessary fluff, but the second sentence could be integrated more seamlessly, and the overall length is appropriate for the 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 no annotations, no output schema, and a mutation tool with 3 parameters, the description is incomplete. It explains parameters well but lacks critical behavioral details like success/failure responses, idempotency, or system impact, making it insufficient for safe and effective use by an AI 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?

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for all three parameters: snippet_id and folder_id as UUIDs, and tsg_id as optional with a default. This adds meaningful context beyond the bare schema, though it could specify 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 the verb 'associate' and the resources 'snippet' and 'folder', making the purpose specific and understandable. However, it does not explicitly differentiate from its sibling 'scm_disassociate_snippet_from_folder', which is a closely related operation, leaving some ambiguity in sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to choose association over other snippet or folder operations. It mentions the effect ('snippet's configuration is applied to firewalls in that folder') but does not specify prerequisites, dependencies, or contextual usage scenarios.

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

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

With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it's a write operation (commit/push), it's asynchronous, it offers sync/async modes with timeout control, and it references an audit log. However, it doesn't mention potential side effects like configuration locks, error handling, or 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.

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

The description is efficiently structured: a clear purpose statement followed by a focused explanation of asynchronous behavior, then a well-organized Args section. Every sentence adds value with no redundancy, and key information is front-loaded.

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

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

For a complex write operation with 5 parameters, no annotations, and no output schema, the description is quite complete—covering purpose, behavior, and all parameters. It could be improved by mentioning the return format (e.g., job ID vs. completion status) or error conditions, but it provides sufficient context 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?

Given 0% schema description coverage, the description fully compensates by explaining all 5 parameters in detail: what 'folders' represents with examples, the purpose of 'description', how 'sync' affects behavior, what 'timeout' controls, and the default for 'tsg_id'. This adds substantial 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 clearly states the specific action ('commit pending configuration changes and push to devices') and resource ('staged changes in the specified folders to the managed firewalls'), distinguishing it from sibling tools that primarily create, delete, get, list, or update individual configuration objects rather than committing batches of 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 context for when to use the tool (to push staged changes) and mentions the asynchronous nature, but does not explicitly state when NOT to use it or name specific alternatives among the many sibling tools, such as whether to use scm_get_job_status for tracking async jobs.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates an address object but doesn't mention whether this is a mutation requiring permissions, if it's idempotent, what happens on conflicts (e.g., duplicate names), or any rate limits. The description adds minimal behavioral context beyond the basic action, which is insufficient for a creation tool with zero annotation coverage.

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

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

The description is efficiently structured with a clear purpose statement upfront, followed by a critical constraint, and then a well-organized parameter list with brief explanations and examples. Every sentence adds value without redundancy, making it easy to scan and understand 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?

Given the tool's complexity (9 parameters, creation operation), no annotations, and no output schema, the description is partially complete. It excels in parameter semantics but lacks behavioral details like error handling, response format, or side effects. For a creation tool, this leaves gaps that could hinder an agent's ability to use it correctly without trial and error.

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

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

The description adds significant value beyond the input schema, which has 0% schema description coverage. It explains the mutual exclusivity constraint ('Exactly one of ip_netmask, ip_range, ip_wildcard, or fqdn must be provided'), provides examples for each parameter (e.g., '10.0.0.0/8' for ip_netmask), clarifies optional vs. required parameters, and notes defaults (e.g., 'Defaults to SCM_TSG_ID' for tsg_id). This compensates fully 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 the verb ('Create') and resource ('address object'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'scm_create_address_group' or 'scm_update_address', which would require mentioning what makes an address object distinct from an address group or update operation.

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

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

The description provides implied usage through the 'Exactly one of...' constraint, which helps guide parameter selection, but it lacks explicit guidance on when to use this tool versus alternatives like 'scm_update_address' or 'scm_delete_address'. No prerequisites or exclusions are mentioned, leaving gaps in contextual decision-making.

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. It clearly indicates this is a creation operation (mutating/write), mentions the 'not both' constraint for static/dynamic_filter, and provides a default for tsg_id. However, it doesn't disclose permissions needed, rate limits, whether the operation is idempotent, or what happens on conflicts.

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 purpose statement, key constraint, then parameter explanations. It's appropriately sized for a 7-parameter tool. Minor improvement could be front-loading the 'not both' constraint more prominently, but overall it's efficient with zero wasted 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?

For a creation tool with 7 parameters, 0% schema coverage, no annotations, and no output schema, the description does well on parameters but lacks behavioral context. It doesn't explain what gets returned, error conditions, or system impacts. Given the complexity and lack of structured data, it should provide more operational guidance.

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

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

With 0% schema description coverage, the description fully compensates by explaining all 7 parameters. It clarifies that name must be unique, folder specifies location, static/dynamic_filter are mutually exclusive alternatives, description/tag are optional, and tsg_id has a default. It even provides a dynamic_filter example: "'tag1' and 'tag2'".

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 'Create' and resource 'address group', specifying it's for creating either static or dynamic address groups. It distinguishes from sibling tools like scm_create_address (individual addresses) and scm_update_address_group (updates rather than creates).

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

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

The description provides explicit usage guidance: 'Provide either static or dynamic_filter, not both.' This gives clear constraints on parameter usage. However, it doesn't specify when to choose static vs dynamic groups or mention alternatives like scm_update_address_group for modifications.

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 mentions the tool creates with default settings and references a follow-up update tool, but doesn't disclose critical behavioral traits like whether this is a write operation (implied but not stated), what permissions are needed, whether it's idempotent, or what happens on failure. For a creation tool with zero annotation coverage, this is insufficient.

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 purpose statement, usage guidance, and parameter explanations in a clear format. It's appropriately sized with no wasted sentences, though the parameter section could be slightly 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?

For a creation tool with 4 parameters, no annotations, and no output schema, the description does well on parameters and basic usage but lacks behavioral context. It doesn't explain what the tool returns, error conditions, or system impacts. Given the complexity and missing structured data, it's partially complete but has significant gaps.

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

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

Schema description coverage is 0%, so the description must fully compensate. It provides clear semantic explanations for all 4 parameters: name (unique), folder (location), description (optional), and tsg_id (optional with default). This adds substantial value beyond the bare schema.

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

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

The description clearly states the action ('Create an anti-spyware security profile') and specifies it creates with default settings. It distinguishes from sibling tools by mentioning scm_update_anti_spyware_profile for post-creation modifications, but doesn't explicitly differentiate from other creation tools in the list.

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

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

The description provides clear guidance on when to use this tool (initial creation with defaults) and when to use an alternative (scm_update_anti_spyware_profile for adding threat exception rules). However, it doesn't mention prerequisites like authentication or when not to use it versus other creation tools.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Create' implies a write/mutation operation, the description doesn't address critical behavioral aspects: whether this requires specific permissions, if it's idempotent, what happens on conflicts (e.g., duplicate names), what the response contains, or any rate limits. It only documents parameter defaults, which 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 well-structured with a clear opening statement followed by detailed parameter documentation. While lengthy due to many parameters, every sentence serves a purpose in explaining parameter semantics. It could be more front-loaded with critical behavioral information, but the parameter documentation is efficiently 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?

For a mutation tool with 18 parameters, no annotations, and no output schema, the description provides excellent parameter semantics but lacks critical behavioral context. The agent knows what parameters to provide but not what to expect in return, what permissions are needed, or how the system will behave. This creates significant gaps despite the thorough parameter 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?

With 0% schema description coverage and 18 parameters, the description provides comprehensive semantic information for all parameters. It explains what each parameter represents (e.g., 'risk: Risk level 1-5 (1=low, 5=critical)'), provides examples (e.g., 'category: Application category (e.g. 'business-systems', 'collaboration')'), and indicates optionality and defaults. This fully 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 the verb 'Create' and the resource 'custom application object', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'scm_create_application_group' or 'scm_create_application_filter', which would require more context about what distinguishes a 'custom application object' from other application-related entities.

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. With many sibling tools for creating different objects (e.g., scm_create_application_group, scm_create_application_filter), there's no indication of when this specific creation tool is appropriate, nor any prerequisites or exclusions 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?

With no annotations provided, the description carries full burden but only minimally addresses behavior. It mentions that filters match dynamically and at least one criterion is needed, but doesn't disclose whether this is a write operation (implied by 'create'), what permissions are required, whether it's idempotent, what happens on duplicate names, or what the response contains. For a creation tool with 12 parameters, this is inadequate behavioral disclosure.

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

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

The description is well-structured with a clear purpose statement followed by detailed parameter documentation. It's appropriately sized for a tool with many parameters. However, the first sentence could be more front-loaded with key behavioral information, and some repetition exists in parameter descriptions.

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 (12 parameters, creation tool), no annotations, and no output schema, the description is partially complete. It covers parameters well but lacks crucial context about the creation operation's behavior, response format, error handling, and relationship to other tools. The parameter documentation is strong, but other aspects are underdeveloped.

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 and 12 parameters, the description compensates excellently by providing detailed parameter explanations in the Args section. Each parameter gets a clear semantic explanation beyond just names (e.g., 'Match applications in these categories', 'Match applications with these risk levels 1-5', 'Optional TSG ID or named alias'). This adds significant value beyond the bare schema.

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

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

The description clearly states the tool creates an application filter and explains that filters match applications dynamically by their attributes. It distinguishes from siblings like scm_create_application or scm_create_application_group by focusing on filtering criteria rather than creating applications or groups directly. However, it doesn't explicitly contrast with scm_get_application_filter or scm_list_application_filters.

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 implied usage by stating 'At least one filter criterion should be specified' and listing optional parameters, but lacks explicit guidance on when to use this vs. alternatives like scm_create_application_group or scm_search. It doesn't mention prerequisites, error conditions, or typical use cases beyond the basic functionality.

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 states 'Create' which implies a write/mutation operation, but doesn't disclose behavioral traits like required permissions, whether the creation is idempotent, what happens on duplicate names, or error conditions. The mention of 'Defaults to SCM_TSG_ID' for tsg_id adds some context about default behavior, but overall transparency is minimal for a creation 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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a structured 'Args:' section that efficiently documents parameters. Every sentence earns its place with no redundant information, making it easy to scan and understand.

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

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

Given the complexity (creation tool with 4 parameters), no annotations, and no output schema, the description is moderately complete. It covers the purpose and parameters well, but lacks context on behavioral aspects (e.g., permissions, idempotency) and doesn't explain return values or error handling. This is adequate for basic use but has clear gaps for robust agent 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%, so the description must compensate. It provides meaningful semantics for all 4 parameters: 'name' as a unique identifier, 'folder' as the location, 'members' as a list of application names, and 'tsg_id' with default behavior. This adds significant value beyond the bare schema, though it lacks details like 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 the action ('Create') and resource ('application group'), making the purpose immediately understandable. It distinguishes from siblings like 'scm_create_application' or 'scm_create_application_filter' by specifying it creates a group of applications rather than individual applications or filters. However, it doesn't explicitly contrast with 'scm_create_application_group' vs 'scm_update_application_group' or deletion 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., existing applications for members, folder existence), when not to use it (e.g., if updating instead), or compare with sibling tools like 'scm_update_application_group' or 'scm_delete_application_group'. Usage is implied only through the action 'Create'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates rules but doesn't mention whether this is a write operation requiring specific permissions, if changes are reversible, potential side effects, or what happens on success/failure. For a mutation tool with 13 parameters and no annotation coverage, this is a significant gap in transparency.

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

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

The description is appropriately sized and well-structured with a clear purpose statement followed by a parameter glossary. Each parameter explanation is concise and earns its place. However, the 'Args:' section could be more tightly integrated with the purpose statement for better front-loading.

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 complex mutation tool with 13 parameters, no annotations, and no output schema, the description is partially complete. It excels at parameter documentation but lacks behavioral context, usage guidelines, and information about what the tool returns. Given the complexity, it should provide more about authentication rule behavior and system impact.

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?

Given the schema description coverage is 0%, the description compensates fully by providing detailed parameter semantics for all 13 parameters. It explains each parameter's purpose, data types (e.g., 'List of source zone names'), default values (e.g., "default ['any']"), and optional/required status. This adds substantial value beyond the bare schema.

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

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

The description clearly states the tool's purpose as 'Create an authentication policy rule' with a specific verb ('Create') and resource ('authentication policy rule'). It distinguishes from siblings like 'scm_create_security_rule' by specifying the rule type, though it doesn't explicitly contrast with other authentication-related tools like 'scm_update_authentication_rule' or 'scm_delete_authentication_rule'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., existing folders or profiles), when not to use it, or how it relates to sibling tools like 'scm_update_authentication_rule' or 'scm_delete_authentication_rule'. The only implied usage is for creating rules, but no contextual boundaries are defined.

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 states this is a creation tool but provides no information about permissions required, whether this is a destructive operation, what happens on success/failure, or any system constraints. The mention of 'Defaults to SCM_TSG_ID' for tsg_id is helpful context but 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 well-structured with a clear purpose statement followed by detailed parameter documentation. While somewhat lengthy due to parameter details, every sentence adds value. The parameter documentation is organized with clear labels and formatting, making it 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?

For a creation tool with 6 parameters, 0% schema coverage, no annotations, and no output schema, the description does a good job documenting parameters but lacks critical behavioral context. It doesn't explain what a decryption profile is, what happens after creation, error conditions, or system implications. The parameter documentation is strong, but overall completeness is limited.

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 and 6 parameters, the description provides excellent parameter semantics. It explains what each parameter represents, indicates which are optional, provides default values, and details the structure of complex dictionary parameters with specific keys and enum values for ssl_forward_proxy.min_version.

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

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

The description clearly states the tool's purpose with the verb 'Create' and resource 'decryption profile', making it immediately understandable. However, it doesn't differentiate this from sibling tools like 'scm_create_decryption_rule' or explain what distinguishes a decryption profile from other security profile types in the system.

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. With many sibling tools for creating different security profiles (decryption_rule, anti_spyware_profile, etc.), there's no indication of when a decryption profile is appropriate versus other profile types or what prerequisites might be needed.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a rule, implying a write operation, but fails to mention critical behavioral aspects such as required permissions, whether the rule is immediately active, potential side effects (e.g., impact on traffic), or error handling. This is a significant gap for a mutation tool with 14 parameters.

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 and appropriately sized. It front-loads the purpose in the first sentence, followed by a clear 'Args:' section listing each parameter with brief explanations. There is minimal waste, though some sentences could be more concise (e.g., merging default explanations).

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 (14 parameters, no annotations, no output schema), the description is partially complete. It covers parameter semantics thoroughly but misses behavioral context (e.g., creation effects, error responses) and output details. For a creation tool with many parameters, this leaves gaps that could hinder 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?

The schema description coverage is 0%, so the description must compensate. It provides detailed semantic explanations for all 14 parameters, including defaults (e.g., 'default ['any']', 'default False'), optional status, and enumerations (e.g., action options 'decrypt', 'no-decrypt'). This adds substantial value beyond the bare schema, though it lacks format examples 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 the tool's purpose: 'Create a decryption policy rule.' It specifies the verb ('Create') and resource ('decryption policy rule'), making the intent unambiguous. However, it does not explicitly differentiate this from sibling tools like 'scm_create_decryption_profile' or 'scm_create_security_rule', which could cause confusion in selection.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lacks context about prerequisites (e.g., needing a decryption profile first), exclusions, or comparisons to sibling tools like 'scm_update_decryption_rule' or 'scm_delete_decryption_rule'. This absence leaves the agent without usage direction.

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

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

With no annotations provided, the description carries full burden but lacks critical behavioral details. It states it 'Create[s] a DNS security profile' implying a mutation, but doesn't disclose permissions needed, whether creation is idempotent, error conditions, or what happens on success (e.g., returns a profile ID). This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is well-structured with a brief purpose statement followed by parameter details. Each parameter explanation is efficient, though the botnet_domains example is slightly verbose but necessary for clarity. No wasted 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?

For a creation tool with 5 parameters, 0% schema coverage, no annotations, and no output schema, the description does a decent job on parameters but lacks behavioral context. It covers what to provide but not what happens during/after execution, leaving gaps in understanding the tool's full 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%, so the description must compensate. It provides meaningful semantics for all 5 parameters: 'name' as 'Unique name', 'folder' as 'Folder to create the profile in', 'description' as 'Optional description', 'botnet_domains' with a detailed example, and 'tsg_id' with default behavior. This adds substantial value beyond the bare schema.

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

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

The description clearly states the verb 'Create' and resource 'DNS security profile', making the purpose unambiguous. It distinguishes from sibling tools like 'scm_get_dns_security_profile' (read) and 'scm_delete_dns_security_profile' (delete) by its creation action, though it doesn't explicitly name these alternatives.

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 updating or deleting profiles, or prerequisites such as required permissions or system state. The description only lists parameters without contextual usage instructions.

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. It clearly indicates this is a creation operation (implying mutation), describes the recurring fetch behavior for list types, and mentions default values. However, it doesn't disclose permission requirements, rate limits, error conditions, or what happens on duplicate names. The behavioral context is adequate but incomplete 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 with a clear purpose statement followed by detailed parameter documentation. Each sentence adds value, though the 'list_type' explanation is quite detailed (which is necessary given complexity). It could be slightly more concise in the recurring frequency examples, but overall efficiently communicates essential information.

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

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

For a mutation tool with 4 parameters (including a complex nested object), 0% schema coverage, and no output schema, the description does a good job on parameters but lacks important context. It doesn't explain what the tool returns, error conditions, or system behavior aspects. The parameter documentation is excellent, but other aspects are under-specified 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?

With 0% schema description coverage, the description fully compensates by providing detailed semantic information for all 4 parameters. It explains what each parameter represents, provides format examples for the complex 'list_type' object, documents the optional nature of 'tsg_id', and specifies default values. This goes well beyond what the bare schema provides.

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 an external dynamic list (EDL), specifying the verb 'create' and resource 'external dynamic list'. It distinguishes from siblings like 'scm_update_external_dynamic_list' and 'scm_delete_external_dynamic_list' by focusing on creation, but doesn't explicitly differentiate from other 'create_' tools in the same domain.

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

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

The description implies usage when needing to create an EDL with specific configurations, but doesn't explicitly state when to use this tool versus alternatives like 'scm_update_external_dynamic_list' or 'scm_create_folder'. It mentions the 'tsg_id' defaults to SCM_TSG_ID, providing some context, but lacks clear when-not-to-use guidance 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?

With no annotations provided, the description carries full burden but offers minimal behavioral context. It states this is a creation operation but doesn't mention whether this requires specific permissions, what happens on success/failure, if it's idempotent, or how it interacts with the system. The mention of 'tsg_id' defaulting to 'SCM_TSG_ID' is helpful but 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 efficiently structured with a clear purpose statement followed by parameter explanations. Each parameter earns its place by providing necessary context. The formatting with bullet-like structure for 'rules' enhances readability without unnecessary verbosity.

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 5 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It explains parameters well but lacks crucial behavioral context about permissions, side effects, error conditions, and what constitutes successful creation. The absence of output information is particularly problematic.

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 well by explaining all 5 parameters. It clarifies that 'name' must be unique, 'folder' specifies location, 'description' is optional, 'rules' includes detailed structure with nested fields, and 'tsg_id' has a default value. This adds substantial 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 clearly states the verb 'Create' and resource 'file blocking profile', making the purpose immediately understandable. It distinguishes this as a creation tool among siblings that include various other create/update/delete operations, though it doesn't explicitly differentiate from similar creation tools like 'scm_create_anti_spyware_profile'.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools including 'scm_get_file_blocking_profile', 'scm_delete_file_blocking_profile', and 'scm_list_file_blocking_profiles', there's no indication of prerequisites, dependencies, or appropriate contexts for creation versus retrieval or deletion.

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 but only states it's a creation operation. It doesn't disclose behavioral traits like required permissions, whether the operation is idempotent, what happens on duplicate names, or what the response contains. The description adds minimal value beyond the obvious 'create' implication.

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 purpose statement followed by parameter documentation. It's appropriately sized with no redundant information. The only minor issue is that the parameter documentation could be more integrated with the main description.

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 creation tool with no annotations and no output schema, the description provides adequate parameter semantics but lacks important behavioral context. It doesn't explain what the tool returns, error conditions, or system constraints. The parameter documentation is good, but overall completeness is only moderate.

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 provides meaningful semantic information for all 4 parameters: name uniqueness requirement, parent folder examples, description optionality, and tsg_id default behavior. This significantly 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 the action ('Create a new folder') and resource ('in Strata Cloud Manager'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'scm_create_snippet' or 'scm_create_tag', which also create resources in the same system.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites, dependencies, or when this tool is appropriate versus other folder-related tools like 'scm_update_folder' or 'scm_delete_folder'.

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 this is a creation tool, implying a write/mutation operation, but doesn't disclose behavioral traits like required permissions, whether it's idempotent, error conditions, or what happens on success (e.g., returns a profile ID). The description adds minimal context beyond the basic 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?

The description is well-structured with a brief purpose statement followed by an Args section. Each parameter explanation is concise and to the point. There's no wasted text, though the formatting as a docstring might be slightly verbose. Every sentence earns its place by clarifying parameter details.

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 6 parameters with 0% schema coverage and no output schema or annotations, the description does a good job on parameters but lacks completeness in other areas. It doesn't cover behavioral aspects (e.g., side effects, errors) or output details. For a creation tool with moderate complexity, this is adequate but has clear gaps in transparency and guidelines.

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 fully. It provides detailed semantics for all 6 parameters: explains 'name' must be unique, 'folder' is the target location, 'server' requires specific fields with defaults and options, 'description' is optional, 'tag_registration' has a default, and 'tsg_id' has a default value. 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 clearly states the tool creates an HTTP server profile, which is a specific verb+resource combination. It distinguishes from siblings like scm_get_http_server_profile (read) and scm_delete_http_server_profile (delete), though it doesn't explicitly contrast with them. The purpose is unambiguous but lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing folder), when not to use it, or how it relates to sibling tools like scm_update_http_server_profile (which doesn't exist in the list, suggesting creation is the primary method). 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 full burden for behavioral disclosure. While 'Create' implies a write/mutation operation, the description doesn't mention required permissions, whether this operation is idempotent, what happens on conflict, or any rate limits. It provides basic parameter info but lacks crucial behavioral context for a creation 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 with a clear purpose statement followed by organized parameter documentation. Each parameter explanation is concise and focused. While efficient, the 'Args:' section formatting could be slightly more integrated with the main description 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?

For a creation tool with 6 parameters, no annotations, and no output schema, the description does a good job with parameters but lacks important context. It doesn't explain what a log forwarding profile is, what happens after creation, error conditions, or return values. The parameter documentation is strong, but other contextual gaps remain.

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

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

With 0% schema description coverage, the description fully compensates by providing detailed parameter documentation. It explains all 6 parameters, their purposes, optionality, defaults, and even provides specific structure details for the complex 'match_list' parameter. This adds significant value beyond the bare schema.

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

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

The description clearly states the action ('Create') and resource ('log forwarding profile'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'scm_get_log_forwarding_profile' or 'scm_delete_log_forwarding_profile' beyond the obvious verb difference, so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, dependencies, or when this creation operation is appropriate versus using other log forwarding profile tools. The only implicit guidance comes from the tool name itself.

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 but offers minimal behavioral disclosure. It states this is a creation tool (implying mutation) but doesn't mention permission requirements, whether changes are immediate or require commit, error conditions, rate limits, or what the tool returns. For a 14-parameter creation tool with zero annotation coverage, this is inadequate.

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 brief purpose statement followed by organized parameter documentation. Each parameter explanation is concise yet informative. While slightly lengthy due to 14 parameters, every sentence earns its place by adding semantic value not present in the schema.

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

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

For a complex creation tool with 14 parameters, no annotations, and no output schema, the description is incomplete. While parameter semantics are well-covered, it lacks crucial context about the creation process: what permissions are needed, whether a commit is required, what the return value contains, error handling, and how this integrates with the broader SCM workflow. The parameter documentation is strong, but overall completeness is insufficient.

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

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

With 0% schema description coverage, the description fully compensates by providing detailed parameter explanations beyond just names. It clarifies defaults ('any', False, null), gives nat_type enum values, provides concrete examples for complex parameters (source_translation, destination_translation), and explains optional vs required parameters. This adds substantial value over the bare schema.

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

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

The description clearly states the tool creates a NAT rule, specifying the verb 'Create' and resource 'NAT rule'. It distinguishes itself from siblings like 'scm_update_nat_rule' and 'scm_delete_nat_rule' by its creation purpose, but doesn't explicitly contrast with other rule types like security or PBF rules.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., existing zones, addresses), when NAT rules are appropriate versus other rule types, or what happens after creation (e.g., need for commit). With many sibling tools available, this lack of context is a significant gap.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create' implying a write operation but doesn't mention permissions required, whether changes are immediate or require commit, error handling, or rate limits. It lacks critical behavioral context for a creation tool in a network security 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 with a clear purpose statement followed by a parameter list. Each parameter explanation is concise and to the point. While slightly lengthy due to 13 parameters, every sentence earns its place by providing essential information, 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?

For a creation tool with 13 parameters, no annotations, and no output schema, the description covers parameters thoroughly but lacks behavioral context (e.g., commit requirements, error responses). It's adequate for parameter semantics but incomplete for overall tool understanding, given the complexity and mutation nature of the 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?

Given 0% schema description coverage and 13 parameters (4 required), the description compensates fully by explaining each parameter's purpose, format, and defaults. It provides concrete examples for the 'action' parameter (nexthop, discard, no-pbf), clarifies defaults (e.g., source defaults to ['any']), and explains optional vs. required fields, adding significant value beyond the bare schema.

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

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

The description clearly states the specific action ('Create a policy-based forwarding rule') and distinguishes it from siblings like 'scm_update_pbf_rule' (update) and 'scm_delete_pbf_rule' (delete). It specifies the resource type (PBF rule) and the creation context, making the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'scm_update_pbf_rule' or 'scm_delete_pbf_rule', nor does it mention prerequisites (e.g., existing folder, zones). It only lists parameters without contextual usage advice, leaving the agent to infer when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a creation tool, implying a write/mutation operation, but doesn't mention critical aspects like required permissions, whether changes are immediate or require a commit, error handling, or side effects. The example for 'action' is helpful but insufficient for comprehensive behavioral understanding.

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 brief purpose statement followed by a parameter list. Each parameter explanation is concise and informative. While slightly lengthy due to 14 parameters, every sentence earns its place by clarifying semantics, making it efficient for an agent 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 complexity (14 parameters, no annotations, no output schema), the description does a good job on parameters but lacks broader context. It doesn't explain the tool's role in a larger workflow (e.g., commit requirements), error conditions, or return values. For a creation tool with many parameters, this leaves gaps in operational understanding.

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 fully. It provides detailed parameter explanations, including defaults (e.g., 'any' for source_zone), optional vs. required status, format examples (e.g., action dict), and contextual meanings (e.g., rulebase options 'pre' or 'post'). This adds significant value beyond the bare schema.

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

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

The description clearly states the verb 'Create' and resource 'QoS policy rule', making the purpose immediately understandable. It distinguishes this tool from siblings like 'scm_update_qos_rule' or 'scm_delete_qos_rule' by its creation function, though it doesn't explicitly contrast with other QoS-related tools beyond the naming 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 like 'scm_update_qos_rule' or other rule creation tools (e.g., security rules). The description lists parameters but offers no context about prerequisites, dependencies, or typical workflows, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries full burden. It states this is a creation operation, implying mutation, but doesn't disclose behavioral traits like required permissions, whether the schedule is immediately active, what happens on duplicate names, or error conditions. The description adds minimal context beyond the basic 'create' action, leaving significant gaps for a mutation tool.

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

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

The description is appropriately sized and front-loaded with the core purpose. The parameter explanations are necessary given the 0% schema coverage. However, the formatting with 'Args:' and code-like examples is slightly verbose but earns its place by clarifying complex nested structures. No wasted 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 4 parameters with nested objects, 0% schema coverage, no annotations, and no output schema, the description is moderately complete. It explains parameters well but lacks behavioral context (e.g., mutation effects, error handling) and output details. For a creation tool with this complexity, it should do more to compensate for missing structured data, but the parameter coverage raises it above minimal adequacy.

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 provides detailed semantics for all 4 parameters: name (unique identifier), folder (location), schedule_type (with explicit format examples for recurring and non-recurring schedules), and tsg_id (optional with default). This adds substantial meaning beyond the bare schema, though it could clarify data types or constraints more formally.

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 schedule object, which is a specific verb+resource combination. It distinguishes from siblings like scm_update_schedule (update) and scm_delete_schedule (delete), but doesn't explicitly differentiate from scm_get_schedule or scm_list_schedules, which are read operations. The purpose is clear but could be more specific about what a 'schedule object' entails in this context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing folder), when not to use it (e.g., for updating existing schedules), or refer to sibling tools like scm_update_schedule for modifications. The agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It states this is a creation tool, implying a write operation, but doesn't disclose behavioral traits like whether it requires specific permissions, if it's idempotent, what happens on conflicts (e.g., duplicate names), or if changes are immediate or require a commit. For a mutation tool with zero annotation coverage, this is a significant gap.

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 appropriately sized and front-loaded: the purpose is stated first, followed by a structured parameter list. Each parameter explanation is concise and adds value. However, the 'Args:' section could be slightly more integrated with the initial sentence for better flow.

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

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

Given the complexity (16 parameters, mutation tool), no annotations, and no output schema, the description is partially complete. It excels in parameter documentation but lacks behavioral context (e.g., error handling, side effects) and output details. For a creation tool in a security context, more completeness is needed despite the strong parameter coverage.

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

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

Schema description coverage is 0%, so the description must compensate. It provides detailed semantics for all 16 parameters, including explanations, examples (e.g., action values, default lists), and optional/default behaviors. This adds substantial meaning beyond the bare schema, fully documenting the parameters.

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

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

The description clearly states the tool's purpose: 'Create a security policy rule.' It specifies the verb ('create') and resource ('security policy rule'), which is unambiguous. However, it doesn't explicitly differentiate from siblings like 'scm_update_security_rule' or 'scm_delete_security_rule', though the action 'create' implies a distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., existing folders or zones), exclusions, or comparisons to sibling tools like 'scm_update_security_rule' or 'scm_move_security_rule'. Usage is implied by the action 'create', but no explicit context is given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Create' implies a write operation, the description doesn't mention permissions required, whether this is idempotent, what happens on failure, or any rate limits. It lacks critical behavioral context for a creation 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 with a brief purpose statement followed by a parameter list. Every sentence earns its place, though the initial statement 'Create a security zone.' is somewhat minimal and could be slightly more informative.

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

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

For a creation tool with 7 parameters, no annotations, and no output schema, the description is incomplete. It covers parameters well but lacks behavioral context, error handling, return values, and usage guidelines, making it inadequate for safe and effective tool invocation.

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

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

With 0% schema description coverage and 7 parameters (2 required), the description compensates fully by providing clear explanations for each parameter in the 'Args' section. It adds meaning beyond the bare schema, including purpose, defaults, and optionality details.

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

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

The description clearly states the verb ('Create') and resource ('a security zone'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'scm_create_folder' or 'scm_create_address', which would be needed for a perfect score.

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. With many sibling tools available (e.g., 'scm_create_folder', 'scm_create_address'), there's no indication of prerequisites, dependencies, or contextual usage scenarios.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Create' implies a write/mutation operation, it doesn't mention permissions required, whether the creation is idempotent, what happens on conflicts (e.g., duplicate names), or any rate limits. The description provides basic parameter info but misses critical behavioral context for a creation 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 with a brief purpose statement followed by a clear parameter list. Every sentence earns its place by explaining parameters, though it could be slightly more front-loaded with context about what a 'service object' represents in this system.

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 creation tool with 8 parameters, no annotations, and no output schema, the description does a decent job explaining parameters but lacks broader context. It doesn't explain what a 'service object' is, how it fits into the system, what happens after creation, or error conditions. Given the complexity, more completeness would be helpful.

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 and 8 parameters (4 required), the description compensates excellently by explaining each parameter's purpose and providing examples (e.g., protocol values 'tcp' or 'udp', port format '8080-8090', defaults for tsg_id). This adds substantial meaning beyond the bare schema, making parameter usage clear.

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

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

The description clearly states the verb ('Create') and resource ('a service object'), making the purpose specific and understandable. However, it doesn't differentiate this tool from other 'create' siblings like scm_create_address or scm_create_security_rule, which would require mentioning what distinguishes a 'service object' from those other resources.

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. With many sibling tools (including other 'create' operations and scm_update_service), the description lacks any context about prerequisites, dependencies, or typical workflows that would help an agent choose appropriately.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool creates something, implying a write operation, but doesn't disclose permissions needed, whether it's idempotent, what happens on failure, or any rate limits. The default value for 'tsg_id' is mentioned, but overall behavioral context is lacking for a creation 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 appropriately sized and front-loaded: the purpose is stated first in a clear sentence, followed by a structured 'Args:' section. Each parameter explanation is brief and to the point, with no redundant information. It could be slightly more concise by integrating the args into the main text, but overall it's efficient.

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

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

Given the complexity (a creation tool with 5 parameters), no annotations, and no output schema, the description is incomplete. It covers basic parameter semantics but lacks critical context: no information on return values (e.g., success confirmation, created object details), error handling, or behavioral traits like side effects. For a tool that modifies state, this is a significant gap.

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

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

Schema description coverage is 0%, so the description must compensate. It provides brief explanations for all 5 parameters (e.g., 'Unique name for the service group', 'Folder to create the group in'), adding meaning beyond the bare schema. However, it doesn't detail format constraints (e.g., naming conventions for 'name', folder path structure) or elaborate on 'members' beyond 'List of service object names', leaving gaps in semantic clarity.

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

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

The description clearly states the action ('Create') and resource ('service group'), which is specific and unambiguous. It distinguishes from siblings like 'scm_create_service' or 'scm_update_service_group' by focusing on creation of groups rather than individual services or updates. However, it doesn't explicitly differentiate from other 'create' tools beyond the resource type.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (like needing an existing folder), when not to use it (e.g., for updating existing groups), or refer to sibling tools like 'scm_update_service_group' or 'scm_get_service_group'. Usage is implied only through the action and parameters.

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 but offers minimal behavioral insight. It mentions default values (e.g., enable_prefix default False, tsg_id defaults to SCM_TSG_ID) but fails to disclose critical traits like required permissions, whether creation is idempotent, error handling, or what the tool returns upon success.

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 and front-loaded with the core purpose, followed by a concise Args section listing each parameter with brief explanations. Every sentence earns its place, avoiding redundancy and maintaining clarity without unnecessary detail.

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

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

Given 5 parameters with 0% schema coverage and no output schema or annotations, the description partially compensates by detailing parameters but lacks completeness. It misses behavioral context (e.g., mutation effects, error responses) and doesn't explain the snippet's role in the broader SCM system, leaving gaps 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%, so the description must compensate, which it does effectively by explaining all 5 parameters with clear semantics: name uniqueness, optional fields, default values, and TSG ID behavior. This adds significant meaning beyond the bare schema, though some nuances like label format or prefixing details could be elaborated.

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 'Create' and resource 'configuration snippet', making the purpose specific and understandable. It distinguishes from siblings like scm_update_snippet or scm_delete_snippet by focusing on creation, though it doesn't explicitly contrast with other create tools like scm_create_address or scm_create_folder.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites (e.g., needing a folder or TSG), typical workflows, or comparisons to other creation tools in the sibling list, leaving usage unclear.

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 but only states it 'Create[s]' without behavioral details. It doesn't disclose if this is a write operation requiring permissions, whether it's idempotent, what happens on failure, or any rate limits. The parameter details add some context but lack overall behavioral transparency.

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

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

The description is appropriately sized and front-loaded with the purpose, followed by a structured 'Args:' section. Each sentence adds value, though the parameter explanations could be slightly more concise (e.g., merging server details).

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 with 0% schema coverage and no output schema or annotations, the description does a decent job explaining inputs but lacks completeness. It doesn't cover the return value, error conditions, or behavioral aspects like idempotency, leaving gaps for a creation tool with no structured support.

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 compensates well by explaining all 4 parameters: 'name' (unique), 'folder' (location), 'server' (list with required/optional fields like transport and port defaults), and 'tsg_id' (optional with default). It adds meaning beyond the bare schema, though it could detail 'folder' format or 'server' dict structure more.

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 ('Create') and resource ('a syslog server profile'), making the purpose specific and understandable. It distinguishes from siblings like 'scm_get_syslog_server_profile' (read) and 'scm_delete_syslog_server_profile' (delete), though it doesn't explicitly contrast with other creation tools (e.g., 'scm_create_log_forwarding_profile').

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

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

No guidance is provided on when to use this tool versus alternatives. While the name implies creation, there's no mention of prerequisites (e.g., needing a folder first), when not to use it, or how it relates to similar tools like 'scm_create_log_forwarding_profile' or 'scm_update_syslog_server_profile' (if exists).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create a tag' which implies a write operation, but fails to mention critical aspects like required permissions, whether the tag name must be globally unique, what happens on duplicate names, or the response format. This leaves significant gaps for a mutation tool.

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

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

The description is efficiently structured with a brief purpose statement followed by a parameter list. Each parameter explanation is succinct and adds necessary context without redundancy. However, the initial 'Create a tag.' is overly terse and could be slightly expanded for clarity.

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

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

Given the tool's complexity as a mutation with 5 parameters, no annotations, and no output schema, the description is incomplete. It lacks information on behavioral traits like error handling, authentication needs, or return values, which are crucial for safe and effective use by an AI 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?

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for all 5 parameters: 'name' as a unique identifier, 'folder' as the location, 'color' with examples, 'comments' as a description, and 'tsg_id' with a default. This adds substantial value beyond the bare schema, though it could detail format constraints like folder paths.

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 'Create' and the resource 'tag', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'scm_update_tag' or 'scm_get_tag', which would require mentioning it's for initial creation rather than modification or retrieval.

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 'scm_update_tag' for modifying existing tags or 'scm_delete_tag' for removal. The description lacks context about prerequisites, such as needing an existing folder, or exclusions, leaving the agent without usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create' which implies a write operation, but doesn't mention permissions, side effects (e.g., impact on existing configurations), or response behavior (e.g., success/failure indicators). This leaves significant gaps for a mutation tool.

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

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

The description is well-structured with a brief purpose statement followed by parameter explanations, making it easy to parse. It's appropriately sized with no redundant information, though the parameter list could be slightly more concise by grouping similar categories.

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 (7 parameters, mutation operation), lack of annotations, and no output schema, the description is moderately complete. It covers parameters well but misses behavioral details (e.g., what happens after creation, error handling) and doesn't reference sibling tools, leaving room for improvement.

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 provides clear explanations for all 7 parameters (e.g., 'Unique name for the profile', 'URL categories to allow (optional)'), adding substantial meaning beyond the bare schema. However, it doesn't detail format constraints (e.g., what constitutes a valid 'folder' or 'tsg_id'), preventing a perfect score.

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

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

The description clearly states the verb ('Create') and resource ('URL access (filtering) profile'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'scm_create_url_category' or 'scm_get_url_access_profile', which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to create a URL access profile versus other profile types (e.g., anti-spyware, vulnerability) or when to use update/delete operations. It lacks context about prerequisites or typical use cases.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions creation but doesn't specify whether this is a write operation requiring permissions, if it's idempotent, what happens on duplicate names, or the expected response format. This leaves significant gaps for a mutation tool.

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

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

The description is well-structured with a clear purpose statement followed by parameter details. Each sentence adds value, though the parameter explanations could be more integrated into the flow rather than listed as 'Args:'.

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 creation tool with 6 parameters and no annotations or output schema, the description covers the basics but lacks critical context like error conditions, permissions needed, or what the tool returns. It's adequate but has clear gaps given the complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It provides meaningful explanations for all 6 parameters, including examples for 'list_entries' and defaults for 'category_type' and 'tsg_id'. This adds substantial value beyond the bare schema, though some details like format constraints are still missing.

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 'Create' and resource 'custom URL category', making the purpose evident. However, it doesn't differentiate from sibling tools like 'scm_create_url_access_profile' or 'scm_update_url_category', which would require more specific context about what makes this creation unique.

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 'scm_update_url_category' or 'scm_delete_url_category'. The description lacks context about prerequisites, such as whether a folder must exist first, or when to choose 'URL List' vs 'Category Match'.

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 states 'Create' implying a write operation, but doesn't disclose behavioral traits like required permissions, whether the profile is immediately active, potential side effects, or error conditions. The description lacks critical context for a mutation tool with zero annotation coverage.

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

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

The description is efficiently structured: a clear purpose statement followed by a bullet-point list of parameters with brief explanations. Every sentence adds value, with no redundant information. It's appropriately sized for a tool with 4 parameters.

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 and no output schema, the description is incomplete. It doesn't explain what happens after creation (e.g., success response, profile ID), error handling, or system behavior. Given the complexity of creating a security profile, more context about the operation's impact is needed.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for all 4 parameters: 'name' as a unique identifier, 'folder' as the location, 'description' as optional details, and 'tsg_id' with a default value. This goes beyond the schema's basic titles, providing practical context for each 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 tool creates a vulnerability protection security profile, specifying the verb 'Create' and resource 'vulnerability protection security profile'. It distinguishes from siblings like 'scm_get_vulnerability_profile' (read) and 'scm_delete_vulnerability_profile' (delete), though it doesn't explicitly contrast with other creation tools like 'scm_create_anti_spyware_profile'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, such as needing a folder to exist, or when to choose this over other profile creation tools (e.g., 'scm_create_anti_spyware_profile'). It only lists parameters without contextual usage advice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create' but doesn't mention whether this is a write operation requiring permissions, if it's idempotent, what happens on failure, or any rate limits. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is well-structured with a brief purpose statement followed by a parameter list. It's front-loaded and wastes no words, though the parameter explanations could be slightly more detailed without losing efficiency.

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

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

Given no annotations, no output schema, and a mutation tool with 4 parameters, the description is incomplete. It covers parameters well but lacks behavioral context (e.g., permissions, side effects) and output details, making it inadequate for safe and effective use by an AI 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?

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for all 4 parameters: 'name' as unique, 'folder' as location, 'description' as optional, and 'tsg_id' as optional with a default. This adds substantial value beyond the bare schema, though it could include format examples 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 the verb 'Create' and resource 'WildFire antivirus security profile', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'scm_create_anti_spyware_profile' or 'scm_create_vulnerability_profile' beyond the resource name, which is why it doesn't reach a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as other profile creation tools in the sibling list (e.g., 'scm_create_anti_spyware_profile'). It also lacks information on prerequisites, dependencies, or typical use cases, leaving the agent with minimal contextual direction.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. It states this is a 'create' operation (implying mutation/write), but doesn't mention permission requirements, whether the profile becomes active immediately, if changes are reversible, rate limits, or what the response contains. The example for 'flood' parameter hints at structure but doesn't fully describe 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 appropriately sized but not optimally structured. The opening sentence is clear, but the parameter documentation uses a mix of brief and detailed explanations (good for 'flood', sparse for others). Some sentences like 'Controls SYN, UDP, ICMP, and other flood thresholds' are useful, but overall organization could be more front-loaded with critical usage info.

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 creation tool with 6 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. While it documents parameters well, it lacks crucial context: what a zone protection profile is, how it integrates with the system, what happens on success/failure, and expected return values. The agent would struggle to use this effectively without external knowledge.

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 provides meaningful semantics for all 6 parameters: explains 'name' must be unique, 'folder' is where to create, 'description' is optional, gives detailed examples for 'flood' and 'reconnaissance' (including nested structure), and clarifies 'tsg_id' default. This adds substantial value beyond the bare schema.

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

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

The description clearly states the tool's purpose as 'Create a zone protection profile' which is a specific verb+resource combination. It distinguishes from siblings like 'scm_get_zone_protection_profile' (read) and 'scm_delete_zone_protection_profile' (delete) by the 'create' action, though it doesn't explicitly mention these alternatives in the description text itself.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing folder), when not to use it, or what happens after creation. While siblings include various 'create_' tools, the description offers no comparative context.

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

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

With no annotations, the description carries full burden but only states the action without disclosing critical behavioral traits: it doesn't mention if deletion is permanent/reversible, permission requirements, side effects (e.g., breaking references), or error handling. The phrase 'Delete' implies mutation 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 front-loaded with the core purpose, followed by parameter details in a clear 'Args:' section. It avoids redundancy and is appropriately sized for a simple delete operation, though the formatting could be slightly more polished.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is incomplete: it lacks information on return values, error cases, confirmation prompts, or impact on related objects. Sibling tools suggest a complex SCM system, requiring more contextual guidance.

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 both parameters: address_id as 'UUID of the address object to delete' and tsg_id as 'Optional TSG ID or named alias' with a default. This adds meaningful context beyond the bare schema.

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

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

The description clearly states the specific action ('Delete') and resource ('an address object by UUID'), distinguishing it from siblings like scm_create_address, scm_update_address, and scm_get_address. It precisely defines the operation without ambiguity.

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., scm_update_address for modification, scm_list_addresses for viewing). It mentions a default for tsg_id but lacks context on prerequisites, dependencies, or error conditions.

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 states this is a deletion operation, which implies it's destructive, but doesn't specify whether deletion is permanent, requires confirmation, affects dependent resources, or has any rate limits. The description provides minimal behavioral context beyond the obvious destructive nature.

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

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

The description is appropriately sized with a clear purpose statement followed by parameter explanations. The two-sentence structure is efficient, though the parameter documentation could be more integrated rather than appearing as a separate 'Args:' section.

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

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

For a destructive deletion tool with no annotations, 0% schema description coverage, and no output schema, the description is insufficient. It doesn't address critical behavioral aspects like permanence, dependencies, error conditions, or what happens upon successful deletion. The description should provide more context given the tool's destructive nature.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that 'group_id' is the 'UUID of the address group to delete' and 'tsg_id' is an 'Optional TSG ID or named alias' with a default value. This adds meaningful context beyond the bare schema, though it doesn't fully explain what TSG represents or how aliases work.

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

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

The description clearly states the action ('Delete') and resource ('address group by UUID'), making the purpose immediately understandable. It distinguishes this as a deletion operation among many sibling tools that include create, update, get, and list operations for address groups and other resources.

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. While the sibling tools include 'scm_delete_address' and 'scm_update_address_group', the description doesn't indicate whether deletion is irreversible, requires specific permissions, or should be used with caution compared to other operations.

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 states the action is 'Delete' which implies a destructive mutation, but doesn't clarify if this is permanent, reversible, requires specific permissions, or has side effects. No information about rate limits, authentication needs, or what happens if the profile is in use is included.

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

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

The description is appropriately sized with two sentences: a clear purpose statement followed by parameter explanations. The 'Args:' section is well-structured, though the formatting could be slightly cleaner. Every sentence adds value without redundancy.

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

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

For a destructive mutation tool with 2 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It explains parameters adequately but lacks critical behavioral context about the deletion operation's consequences, permissions required, error conditions, or what happens to dependent configurations.

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 clearly explains both parameters: 'profile_id' as 'UUID of the anti-spyware profile to delete' and 'tsg_id' as 'Optional TSG ID or named alias' with default behavior. This adds meaningful context beyond the bare schema, though it doesn't fully explain TSG ID semantics.

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

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

The description clearly states the specific action ('Delete') and resource ('an anti-spyware profile by UUID'), distinguishing it from sibling tools like 'scm_create_anti_spyware_profile' and 'scm_get_anti_spyware_profile'. It provides precise verb+resource+identification method.

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. While the description implies deletion of a specific profile, it doesn't mention prerequisites (e.g., whether the profile must exist, be unused), consequences, or when to choose deletion over other operations. The sibling list includes many 'delete_' tools, but no differentiation is offered.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a deletion operation (implying destructive action) but doesn't mention whether deletion is permanent, reversible, requires specific permissions, or what the response looks like (success/failure indicators). For a destructive tool with zero annotation coverage, this is a significant gap.

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

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

The description is efficiently structured with a clear purpose statement followed by parameter explanations. Every sentence serves a purpose, though the parameter section could be slightly more detailed given the lack of schema descriptions.

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

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

For a destructive deletion tool with 2 parameters, 0% schema description coverage, no annotations, and no output schema, the description is incomplete. It lacks critical information about behavioral consequences, error handling, and operational context that would help an agent use it safely and effectively.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that 'app_id' is a 'UUID of the application to delete' and 'tsg_id' is an 'Optional TSG ID or named alias' with a default, adding meaningful context beyond the bare schema. However, it doesn't clarify what 'TSG' stands for or provide examples of valid UUID formats.

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 custom application object by UUID'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling delete tools (like scm_delete_address or scm_delete_application_filter), but the resource specificity is adequate.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an existing application), consequences of deletion, or what happens if the UUID doesn't exist. It simply states what the tool does without context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool performs a deletion (implying a destructive mutation) but does not disclose critical behavioral traits such as required permissions, whether the deletion is reversible, potential side effects (e.g., impact on dependent configurations), or error conditions. This leaves significant gaps for a destructive operation.

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

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

The description is appropriately sized and front-loaded, with the core purpose stated first followed by parameter details. The 'Args:' section is structured but slightly verbose; every sentence earns its place by adding necessary parameter explanations, though it could be more streamlined.

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 (destructive deletion with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It fails to address behavioral aspects like permissions, reversibility, or response format, which are critical for safe and correct usage. The parameter explanations help but do not compensate for the overall gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for both parameters: 'filter_id' is explained as 'UUID of the application filter to delete', and 'tsg_id' is clarified as 'Optional TSG ID or named alias' with a default value. This provides essential context beyond the bare schema, though it could elaborate on TSG ID format or usage.

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 specific action ('Delete') and target resource ('an application filter by UUID'), distinguishing it from sibling tools like 'scm_delete_application' or 'scm_delete_application_group' which target different resources. It precisely communicates the tool's function without ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing an existing filter), consequences of deletion, or how it relates to sibling tools like 'scm_get_application_filter' or 'scm_list_application_filters'. Usage context is implied but not explicitly 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?

No annotations are provided, so the description carries the full burden. It states the action ('Delete') but doesn't disclose behavioral traits like whether deletion is permanent, requires specific permissions, has side effects (e.g., affecting related resources), or what the response looks like (e.g., success/failure indicators). This leaves significant gaps for a destructive operation.

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

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

The description is appropriately sized and front-loaded, with the main purpose stated first followed by parameter details in a structured 'Args:' section. There's minimal waste, though it could be slightly more concise by integrating parameter explanations more seamlessly.

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 of a destructive delete operation with no annotations and no output schema, the description is incomplete. It lacks critical context such as behavioral implications (e.g., irreversibility), error handling, or return values, which are essential for safe and effective tool invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'group_id' is a 'UUID of the application group to delete' and 'tsg_id' is an 'Optional TSG ID or named alias' with a default, which clarifies beyond the schema's basic types. However, it doesn't fully detail parameter constraints or usage examples, leaving some ambiguity.

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

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

The description clearly states the verb ('Delete') and resource ('an application group by UUID'), making the purpose specific and understandable. It distinguishes from siblings like 'scm_delete_application' or 'scm_delete_address_group' by specifying the resource type, though it doesn't explicitly contrast with them in the text.

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

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

No guidance is provided on when to use this tool versus alternatives. While siblings include other delete operations (e.g., 'scm_delete_application'), the description lacks explicit when/when-not instructions or prerequisites, such as dependencies or permissions needed for deletion.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a deletion operation, implying it's destructive, but doesn't clarify if deletion is permanent, reversible, or has side effects. No information about permissions, rate limits, or error conditions is included, leaving significant behavioral gaps for a destructive operation.

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

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

The description is efficiently structured with a clear purpose statement followed by parameter explanations. Every sentence adds value: the first states what the tool does, and the Args section clarifies parameter meanings. No redundant or unnecessary information is included.

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

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

For a destructive deletion tool with no annotations and no output schema, the description is incomplete. It doesn't address critical context like what happens after deletion (confirmation, error handling), whether the operation is atomic, or what permissions are required. The parameter explanations help, but overall context for safe usage is inadequate.

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 well by explaining both parameters: rule_id is 'UUID of the authentication rule to delete' and tsg_id is 'Optional TSG ID or named alias' with a default value. This adds meaningful context beyond the bare schema, though it doesn't specify UUID format or TSG alias 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 the action ('Delete') and resource ('authentication rule by UUID'), making the purpose immediately understandable. It distinguishes from siblings by specifying the exact resource type (authentication rule) rather than a generic delete operation, though it doesn't explicitly contrast with other delete tools like scm_delete_security_rule.

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. While it mentions a sibling tool scm_create_authentication_rule exists, it doesn't explain when deletion is appropriate or what prerequisites might be needed (e.g., rule must exist, no dependencies). No explicit when/when-not or alternative usage context is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is a deletion, implying a destructive mutation, but doesn't mention permissions required, whether the deletion is permanent or reversible, or what happens to associated rules or configurations. For a destructive operation with zero annotation coverage, this leaves critical behavioral aspects unspecified.

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 appropriately sized and front-loaded with the core purpose in the first sentence. The parameter explanations are brief and directly relevant. There's no wasted text, though the structure could be slightly improved by integrating the parameter details more seamlessly rather than as a separate 'Args:' section.

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

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

For a destructive deletion tool with no annotations and no output schema, the description is incomplete. It doesn't address critical context like what happens on success/failure, error conditions, or system impact. Given the complexity of a deletion operation in what appears to be a security configuration management system, more behavioral and outcome information is needed.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for both parameters: 'profile_id' is explained as 'UUID of the decryption profile to delete', and 'tsg_id' as 'Optional TSG ID or named alias' with a default value. This adds meaningful context beyond the bare schema, though it doesn't fully explain what a TSG is or how aliases work.

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

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

The description clearly states the specific action ('Delete') and resource ('a decryption profile by UUID'), distinguishing it from sibling tools like 'scm_create_decryption_profile' and 'scm_get_decryption_profile' which perform different operations on the same resource type. It precisely defines the tool's function without redundancy.

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. While it's clear this deletes a decryption profile, there's no mention of prerequisites (e.g., whether the profile must be unused), consequences, or what to do if deletion fails. The description lacks context about usage scenarios or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It states this is a deletion operation, implying it is destructive, but does not disclose critical behavioral traits like whether the deletion is permanent, requires specific permissions, has side effects, or what the response looks like. This leaves significant gaps for a mutation tool.

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

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

The description is front-loaded with the core purpose, followed by clear parameter explanations in a structured format. Every sentence adds value without redundancy, 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?

For a destructive mutation tool with no annotations and no output schema, the description is incomplete. It lacks information on behavioral consequences, error handling, or return values, which are critical for safe and 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?

With 0% schema description coverage, the description compensates by explaining both parameters: 'rule_id' as the UUID to delete and 'tsg_id' as optional with a default. It adds meaningful context beyond the schema, though it could detail format constraints or alias 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 the specific action ('Delete') and resource ('a decryption rule by UUID'), distinguishing it from sibling tools like 'scm_create_decryption_rule' or 'scm_get_decryption_rule'. It precisely identifies what the tool does without ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when deletion is appropriate or what prerequisites might be needed. It mentions a default for 'tsg_id' but does not explain the context or implications of using this parameter.

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 states this is a deletion operation, implying it's destructive, but doesn't specify if deletion is permanent, requires specific permissions, has side effects, or provides confirmation. This leaves significant gaps for a mutation tool.

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

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

The description is appropriately sized with two sentences: one stating the purpose and another detailing parameters. It's front-loaded with the core action and avoids unnecessary fluff, though the parameter explanations could be slightly more structured.

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

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

For a destructive deletion tool with no annotations and no output schema, the description is insufficient. It lacks critical details like error handling, return values (e.g., success confirmation or job ID), dependencies, or safety warnings, leaving the agent poorly equipped to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains profile_id as 'UUID of the DNS security profile to delete' and tsg_id as 'Optional TSG ID or named alias' with a default, adding meaningful context beyond the schema's basic types. However, it doesn't clarify what SCM_TSG_ID is or provide examples, leaving some ambiguity.

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

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

The description clearly states the action ('Delete') and resource ('DNS security profile by UUID'), making the purpose immediately understandable. However, it doesn't differentiate from sibling delete tools (like scm_delete_address or scm_delete_application) beyond specifying the resource type, which is adequate but not exceptional.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an existing profile), consequences of deletion, or relationships with other tools like scm_get_dns_security_profile or scm_create_dns_security_profile.

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. While 'Delete' implies a destructive operation, the description doesn't disclose important behavioral traits: whether deletion is permanent/reversible, what permissions are required, whether it affects dependent configurations, or what happens on success/failure. For a destructive tool with zero annotation coverage, this is inadequate.

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 appropriately sized and front-loaded with the core purpose. The two-sentence structure with parameter explanations is efficient, though the 'Args:' section formatting could be slightly cleaner. Every sentence adds value without redundancy.

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

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

For a destructive deletion tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't address critical context: what happens after deletion, error conditions, confirmation requirements, or system impact. The parameter explanations help but don't compensate for the missing behavioral transparency.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that 'edl_id' is the 'UUID of the EDL to delete' and 'tsg_id' is an 'Optional TSG ID or named alias' with a default value. This adds meaningful context beyond the bare schema, but doesn't fully cover format expectations (e.g., UUID format) or what TSG represents.

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 specific action ('Delete') and resource ('external dynamic list by UUID'), distinguishing it from sibling tools like 'scm_create_external_dynamic_list' and 'scm_get_external_dynamic_list'. It provides a precise verb+resource combination that leaves no ambiguity about the tool's function.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing EDL), consequences of deletion, or when to choose deletion over other operations like updating. With many sibling tools available, this lack of context is a significant gap.

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 fully disclose behavioral traits. It states this is a deletion operation, implying it's destructive, but doesn't clarify if it's irreversible, requires specific permissions, or has side effects (e.g., breaking dependencies). The description lacks details on error handling, response format, or rate limits, leaving significant gaps in behavioral understanding.

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 appropriately sized and front-loaded, with the main purpose stated first followed by parameter details. The two-sentence structure is efficient, though the parameter explanations could be slightly more integrated into the flow rather than as a separate 'Args:' section.

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 destructive nature, lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like irreversibility, permissions needed, or what the response contains. For a deletion tool with zero annotation coverage, this leaves the agent without sufficient context to use it safely and effectively.

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

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

Schema description coverage is 0%, so the description must compensate. It explains both parameters: 'profile_id' as the UUID to delete and 'tsg_id' as an optional TSG ID with a default. This adds crucial meaning beyond the bare schema, clarifying the purpose and default behavior of each parameter, though it doesn't detail UUID format or TSG alias 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 the action ('Delete') and resource ('file blocking profile by UUID'), making the purpose specific and understandable. It distinguishes from siblings like 'scm_delete_address' or 'scm_delete_security_rule' by specifying the resource type, though it doesn't explicitly differentiate from other delete operations beyond naming the 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 description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing profile), consequences (e.g., what happens to associated rules), or suggest alternatives like 'scm_get_file_blocking_profile' for verification. The only implicit usage hint is the need for a UUID, but this is insufficient for effective tool 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 provided, the description carries the full burden of behavioral disclosure. It effectively communicates critical traits: the action is irreversible (destructive) and has a prerequisite (no dependent configuration objects). This adds significant value beyond the basic schema, though it could mention error handling or confirmation steps.

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 and front-loaded with the core action, followed by a warning and parameter details. Every sentence earns its place, with no wasted words, 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.