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

With no annotations, the description must carry behavioral disclosure, but it only restates the core action. It does not mention side effects, administrative privileges, duplicate UID behavior, password policy requirements, or what happens after creation. 'Create' signals a mutation, but no meaningful behavioral context beyond that is disclosed.

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

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

The description is a single, front-loaded sentence with no wasted words. It communicates the essential action immediately and does not include redundant information.

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

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

Despite full schema coverage, the description omits important operational context for a write operation: required privileges, uniqueness constraints, password handling, and what the tool returns or does after creation. There is no output schema and no annotations to fill these gaps, so the description is not sufficiently complete for a provisioning 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?

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already 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 uses a specific verb ('Create') and resource ('FreeIPA user account'), clearly identifying the operation. It is unambiguous and distinguishable from the sibling tools, which cover retrieval, listing, deletion, and state 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 implies usage for provisioning a new user, but it does not explicitly state when to choose this tool over related operations such as reset_password, enable_user, or add_user_to_group. No exclusions or alternative routing are provided, so the usage context is only implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Add one or more users', but does not explain whether the operation is idempotent, what happens if a user already belongs to the group, what permissions are required, or what the response contains. This is a mutation with unstated side effects.

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

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

The description is a single, front-loaded sentence with no wasted words. Every term carries operational meaning: 'Add', 'one or more users', 'FreeIPA group'. It is concise without sacrificing 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?

The tool is simple, with two fully documented parameters and no output schema. The description is adequate for understanding the core operation, but it omits usage guidance, behavioral edge cases, and return behavior, leaving noticeable gaps for an agent assessing how to call and interpret the result.

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

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

Schema description coverage is 100%, so both 'uid' and 'group_cn' are already fully documented in the schema. The description adds only the phrase 'one or more', which the schema already expresses through the anyOf string/array type for 'uid'. No meaningful additional parameter semantics are provided.

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

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

The description states the specific verb 'Add', the object 'one or more users', and the target 'a FreeIPA group'. This clearly differentiates it from sibling tools like remove_user_from_group (removal) and add_user (creating a new user account).

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. However, the verb 'Add' and the resource 'FreeIPA group' imply the use case of group membership addition, which gives some guidance but left implicit.

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 must carry the behavioral disclosure. 'Permanently delete' explicitly communicates that the operation is destructive and irreversible, which is the most critical behavioral trait here. It does not disclose permission requirements, cascading effects, or error behavior, so it is only partially transparent.

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

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

The description is a single, well-structured sentence with no wasted words. 'Permanently' adds safety-relevant meaning and 'FreeIPA' scopes the resource, making every word valuable.

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

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

For a simple one-parameter destructive tool with no output schema, the description provides the essential facts: what object is affected and that the action is permanent. It lacks explicit alternatives and prerequisites, but the low complexity and complete schema coverage make it adequately complete for correct invocation.

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

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

Schema description coverage is 100%, so the uid parameter is fully documented in the input schema already. The tool description adds no additional parameter semantics beyond the schema. A baseline of 3 is appropriate when the schema carries the parameter documentation burden.

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

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

The description uses a specific verb ('Permanently delete') and a specific resource ('FreeIPA user account'), clearly distinguishing this tool from siblings like add_user, enable_user, disable_user, and get_user. It states exactly what the tool does with no 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 word 'permanently' implies that this tool should be used for irreversible removal rather than temporary suspension via disable_user. However, it does not explicitly state when to use this tool versus alternatives or name the appropriate comparison, leaving the agent to infer from sibling names.

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 does disclose a key behavior: the account is locked rather than deleted. However, it does not mention reversibility, permissions required, effects on active sessions, or any other side effects, leaving meaningful behavioral gaps.

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

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

The description is a single sentence that front-loads the core action and adds a clarifying distinction in parentheses. Every word earns its place, with no repetition or filler.

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

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

For a tool with one fully described parameter and no output schema, the description is nearly complete. It communicates the primary purpose and clarifies the non-destructive nature. It could mention re-enabling via enable_user or note reversibility, but these are minor for this simple action.

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 does not mention the uid parameter, but the input schema provides 100% coverage with a clear description for the sole parameter. Schema coverage is complete, so the baseline score of 3 is appropriate; there is no additional semantic value added by the description.

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

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

The description states a specific verb and resource: 'Disable a FreeIPA user account.' The parenthetical 'locks it without deleting' adds precise scope and clearly distinguishes this from the sibling delete_user tool. An agent can immediately tell what the tool does.

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

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

The description implies this tool is the non-destructive alternative to delete_user by noting 'without deleting,' but it does not explicitly name alternatives or state when to prefer this over enable_user or delete_user. Usage context is implied rather than clearly articulated.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates the operation without mentioning permission requirements, idempotency, side effects, or what happens if the account is already enabled.

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

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

A single, front-loaded sentence contains the action, target, and state with no filler. It is appropriately sized for a one-parameter tool.

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

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

For a simple one-parameter mutation tool, the description communicates the core call. It is incomplete on return behavior and error cases, but the schema covers the only input, so it is minimally viable.

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

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

Schema coverage is 100% and the uid parameter already has a clear description. The tool description adds FreeIPA context but no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Enable'), a specific resource ('a disabled FreeIPA user account'), and the target state. This clearly differentiates it from sibling tools like disable_user, add_user, and get_user.

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

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

The phrase 'disabled FreeIPA user account' gives a clear precondition for use, and the sibling list makes the inverse operation obvious. However, it does not explicitly state when not to use this tool or name alternatives.

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

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

With no annotations, the description carries the full behavioral transparency burden. 'Get' implies a read operation, and it states the scope (zone/record name), but it does not disclose error behavior for nonexistent records, authorization requirements, response shape, or any other operational details.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the verb, the target resource, and the scope.

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

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

For a simple two-parameter getter, the description is usable and complete enough to invoke. However, with no output schema and no annotation coverage, it fails to explain what 'detailed DNS information' includes or what happens when the record does not exist, leaving the agent without some operational expectations.

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

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

Schema description coverage is 100%, so the schema fully documents both 'zone' and 'name'. The description adds no additional meaning beyond restating that the operation targets a specific record name within a zone, so it meets but does not exceed the baseline.

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

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

The description uses a clear verb ('Get') and explicitly identifies the resource: detailed DNS information for a specific record name within a zone. It differentiates from sibling list tools by focusing on a single named record, though it does not explicitly name the sibling 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?

The wording implies this should be used when the agent already knows both the zone and the specific record name. However, it does not explicitly state when to prefer this over list_dns_records, nor does it mention any exclusions or prerequisites, so usage guidance is only implicit.

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 burden of implying safety and side effects. The verb 'Get' reasonably implies a read-only lookup, and the scope is clearly limited to retrieving group information, but the description does not explicitly state that no modifications occur or mention authentication or response behavior.

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

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

The description is a single, direct sentence with no filler. The key object, scope, and parameter are all front-loaded, making it easy to parse quickly.

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

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

This is a simple single-parameter retrieval tool with no output schema, so the description is largely sufficient for an agent to invoke it correctly. It could be slightly richer by hinting at what 'detailed information' includes, but the low complexity keeps the missing detail from being 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 100%, so the schema already documents that cn is the common name of the group to retrieve. The description only restates the parameter concept, adding no new semantic nuance beyond what the 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 states a specific verb and resource: it retrieves detailed information about a single FreeIPA group using its cn. This clearly distinguishes it from list-oriented siblings like list_groups, so an agent can select the right tool without inspecting the schema.

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

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

The description provides clear context: use this tool when you need details about a specific group identified by cn. It does not explicitly name alternatives such as list_groups or state when not to use it, so it falls just short of full exclusion guidance.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb 'Get' signals a read-only retrieval, and 'by its name' indicates the lookup key, but the description does not mention behavior for non-existent rules, required permissions, or what 'detailed information' includes. This is acceptable but not rich for a tool with no annotation safety signals.

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

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

A single, tightly written sentence that front-loads the action, resource, and lookup key. There is no filler or redundant restatement of the tool name.

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

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

For a simple one-parameter lookup with no output schema, the description is largely complete: it identifies the resource, the lookup method, and the kind of result. It does not enumerate the returned fields, but 'detailed information' gives a reasonable expectation, and the tool's low complexity keeps the gaps minor.

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 already fully describes the single parameter cn with 100% coverage. The description's phrase 'by its name' reinforces that cn is the rule name, but it does not add new meaning beyond the schema. Baseline 3 applies because the schema does the heavy lifting.

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

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

The description states a clear verb ('Get'), a specific resource ('detailed information about a specific FreeIPA HBAC rule'), and the selection mechanism ('by its name'). This clearly distinguishes it from list_hbac_rules, which would list rules rather than retrieve one in detail.

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 the correct usage context: when you know the name of a specific HBAC rule and need its details. It does not explicitly compare against alternatives like list_hbac_rules, but the 'specific... by its name' wording makes the intended use clear.

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

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

With no annotations, the description is the only source of behavioral information. It clearly indicates a read operation that returns detailed host information, but it does not describe error behavior, authentication requirements, or the specific fields returned.

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

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

A single, front-loaded sentence that names the action, resource, and input with no fluff. Every word contributes to understanding.

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

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

For a simple one-parameter get operation with no output schema, the description provides the essential purpose and input. It could be more specific about the returned 'detailed information', but an agent can invoke it correctly with the FQDN alone.

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

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

The schema already covers the only parameter (fqdn) with a clear description, so the baseline is 3. The tool description adds 'FreeIPA-enrolled host' context, but it does not meaningfully expand on the parameter's semantics beyond the schema.

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

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

The description states a clear verb ('Get'), a specific resource ('detailed information about a specific FreeIPA-enrolled host'), and the key identifier ('by its FQDN'). This distinguishes it from sibling list_hosts, which handles enumerating hosts.

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

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

The phrase 'specific host' implies this tool is for retrieving one host's details rather than listing hosts, but it does not explicitly mention alternatives like list_hosts or state when not to use it. Usage context is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Get detailed information' and does not explicitly confirm read-only behavior, describe what happens when the rule does not exist, or mention any authorization 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 a single clear sentence with no filler. It front-loads the action and resource, making it quick 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?

For a simple single-parameter getter with no output schema, the description is mostly complete: it identifies the resource type, the lookup key, and the kind of information returned. Some behavioral and alternative-tool context is missing, but it is sufficient for direct 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 coverage is 100% for the single required cn parameter, so the schema already explains the parameter fully. The description's 'by its name' adds no new semantic detail beyond the schema property description.

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

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

The description clearly states the action ('Get'), the resource ('specific FreeIPA sudo rule'), and the selection criterion ('by its name'). It is easily distinguished from sibling list tools like list_sudo_rules, which enumerate multiple 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 makes clear that this tool is for retrieving a single named sudo rule, implying it should be used when the rule's cn is already known. However, it does not explicitly mention alternatives such as list_sudo_rules for enumeration, stopping short of a full 5.

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

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

No annotations are provided, so the description carries the full burden. 'Get detailed information' implies a read-only operation with no side effects, which is accurate, but it does not disclose error behavior, required privileges, or what specific fields will be returned. Minimal but not misleading.

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

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

A single, front-loaded sentence with no filler. The verb, resource, and identifying parameter are all included, and every word contributes to the meaning.

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

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

For a one-parameter lookup the description is adequate for selecting and invoking the tool. However, with no output schema, the phrase 'detailed information' is vague about what user attributes the agent should expect, and no error or edge-case context is provided.

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 already fully documents the only parameter, uid, with 100% description coverage. The description's mention of 'UID (login name)' essentially repeats the schema and adds little semantic value beyond it.

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

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

The description clearly states a specific verb ('Get'), a specific resource ('detailed information about a specific FreeIPA user'), and the identifying key ('by their UID (login name)'). It is immediately distinguishable from sibling tools like list_users and get_group.

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

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

The phrase 'a specific FreeIPA user by their UID' makes clear this is for retrieving one known user rather than listing or modifying users. However, it does not explicitly name alternatives such as list_users or state when not to use it, so it falls short of full explicit routing.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. The 'List' verb signals a read-only operation, and 'Returns all record types (A, AAAA, CNAME, MX, etc.)' adds concrete behavior about the result scope. It does not discuss pagination or edge cases, but the core behavior is transparent.

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

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

Two concise sentences deliver the core action, scope, and return richness without redundancy. There is no filler, and the main purpose 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 simple list operation with fully documented parameters, the description is largely sufficient. It explains the result covers all record types, but since there is no output schema it could have been more explicit about the return shape or any limit effects. Still, an agent can select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents zone (with example format) and limit (with default). The description adds no parameter-level detail beyond 'specific zone', which is the expected baseline value for a fully documented 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 states a specific verb ('List'), a clear resource ('DNS records'), and a clear scope ('within a specific zone in FreeIPA'). It also notes the return scope ('all record types'), which distinguishes it from siblings like list_dns_zones and get_dns_record.

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

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

The phrase 'within a specific zone' implies the caller must already have a zone in mind, and the tool's purpose is clear from context. However, there is no explicit guidance on when to prefer this tool over alternatives like get_dns_record or list_dns_zones, and no when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the return content (zone names and active status), which is useful, but it does not mention read-only behavior, pagination, scope limits, or failure modes. For a simple list operation this is moderate transparency, not 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 two short sentences with no wasted words. The main action is front-loaded, and the return summary is useful without adding noise.

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

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

For a simple list tool with one optional parameter, a clear schema, and no nested objects, the description is largely complete: it states what is listed and what is returned. Minor omissions like pagination or ordering behavior are not critical for basic invocation.

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

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

The input schema already documents the single optional name_filter parameter with 100% coverage, so the description does not need to repeat it. However, the description adds no extra meaning about filter behavior, such as case sensitivity or wildcard matching. Baseline 3 is appropriate because the schema carries the parameter 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 verb ('List'), the resource ('all DNS zones'), the managed environment ('FreeIPA'), and the return fields ('zone names and active status'). It does not explicitly distinguish itself from sibling tools like list_dns_records, but the resource type is specific enough to make the purpose clear.

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

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

No guidance is given about when to use this tool versus alternatives such as list_dns_records or get_dns_record. The description only implies usage by saying it lists all DNS zones; it does not mention when the optional filter is useful or when another tool should be selected.

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

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

With no annotations, the description carries the full burden. It does indicate a read-only list operation via 'List' and 'Returns' and specifies the returned fields. However, it does not disclose sorting, pagination, result-set scope, or what 'member lists' means in practice.

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

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

Two short sentences, both purposeful: one states the action and scope, the other states the output shape. There is no filler, repetition of schema data, or 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?

For a simple list tool with two optional parameters and no output schema, the description covers the core purpose and return fields while the schema covers the parameters. It lacks usage guidance and behavioral caveats, but an agent can invoke the tool correctly with the information provided.

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

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

Schema description coverage is 100%, and both parameters (cn and limit) are already documented in the input schema. The description adds no parameter-specific meaning beyond the schema, so the baseline of 3 applies.

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

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

Description uses a specific verb ('List') and resource ('groups in FreeIPA') and adds exact return fields (name, description, GID, and member lists), so an agent immediately knows what the tool does. It does not explicitly contrast with the sibling get_group, but the plural 'List groups' clearly signals a collection-level 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 gives no guidance about when to use list_groups versus get_group, list_users, or the other list tools. It relies entirely on the tool name and sibling names to imply usage, with no explicit context 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 disclosure burden. 'List' implies a read operation but non-destructiveness and auth requirements are never stated. The scope claim 'all' is also undercut by the optional cn filter, which the description does not acknowledge, and no return behavior is characterized.

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

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

Two short sentences with no filler. The purpose is front-loaded in the first sentence, and the second sentence successfully earns its place by explaining what HBAC rules are, helping an agent unfamiliar with FreeIPA domain terminology.

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 low-complexity tool (1 optional param, schema fully documents it), the description is adequate but has gaps: there is no output schema, so the response shape is opaque; the cn-filtered result being a subset of 'all' is not reconciled; and the relationship to get_hbac_rule for single-rule retrieval is unaddressed.

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

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

Schema description coverage is 100% — cn is fully documented with its substring-match filter semantics. The description adds nothing about parameters, which is acceptable at this coverage level. Baseline 3 applies.

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

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

The description uses a specific verb+resource pair ('List all ... HBAC rules in FreeIPA') and adds a clarifying sentence explaining what HBAC rules do. It is distinguishable from list_sudo_rules by rule type and from get_hbac_rule by the list-vs-single contrast, though it never names these siblings explicitly.

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

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

The description implies the usage context: if you want all HBAC rules, this is the tool. The definition of what HBAC rules govern provides weak routing context against list_sudo_rules. However, there is no explicit guidance on when to prefer get_hbac_rule for a specific rule or any statement about what this tool is NOT for.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It signals a non-mutating listing operation and describes the output fields, but it does not mention the default 100-host limit or the substring semantics of the fqdn filter.

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

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

Two short sentences with no filler. The core purpose is front-loaded first, followed by the return payload.

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

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

The absence of an output schema is largely compensated for by listing the return fields (FQDN, OS, enrollment status, group memberships). The main remaining gap is pagination/default-limit behavior, though the limit is visible in the schema.

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

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

Schema coverage is 100%, so the input schema already documents fqdn substring matching and the limit default. The description adds no additional parameter-level context, keeping this at the baseline.

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

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

The description names a specific verb ('List'), a specific resource ('hosts'), and a domain ('FreeIPA'). The plural resource clearly distinguishes it from get_host and other singular sibling tools.

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

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

The verb 'List' and the returned fields imply the tool is for enumerating hosts, but the description gives no explicit guidance about when to choose it over get_host or how to filter by fqdn. Usage is implied rather than explicitly routed.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly identifies this as a read-only listing operation and describes the kind of data returned. However, it does not mention behavior such as pagination, result size limits, ordering, or error handling, which could matter for large FreeIPA deployments.

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

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

The description is a single front-loaded sentence: 'List all sudo rules defined in FreeIPA' immediately establishes the action and scope, followed by a compact summary of the returned fields. No filler or redundant wording.

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 list tool with one optional parameter and no output schema, the description explains the main purpose and the high-level structure of the return value. It is sufficient for an agent to call it correctly, though it could explicitly mention that omitting the filter returns all rules, which is already implied by 'List all'.

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

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

Schema description coverage is 100% because the sole parameter 'cn' already has a description ('Filter by rule name (cn) — substring match'). The description text adds no further parameter insight; it does not even mention the filter, but the schema fully covers it, so the baseline score of 3 applies.

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

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

The description starts with 'List all sudo rules defined in FreeIPA,' which names a specific verb and resource. It then clarifies the output contents (who rules apply to, hosts, allowed/denied commands), and the plural name distinguishes it from get_sudo_rule (single rule) and list_hbac_rules (different rule type). Clear and unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives. An agent can infer that it is for enumerating sudo rules rather than fetching a single rule (get_sudo_rule) or handling HBAC rules (list_hbac_rules), but this guidance is only implied, not stated.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It clearly signals a read-only listing operation through 'List users,' and mentions optional filters. It does not describe pagination behavior, ordering, or whether results are truncated beyond the schema's limit parameter, leaving some behavioral context undisclosed.

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

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

The description is a single front-loaded sentence with no filler. It states the core action and the optional filtering capability immediately, efficiently conveying the 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 simple, fully-optional-parameter list tool with 100% schema coverage, the description is nearly complete: it identifies the domain, the action, and the available filters. A minor gap is not mentioning that get_user exists for retrieving details of a specific user, but this is not required for a basic invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter and its substring-match behavior. The description adds only a light restatement of the filterable fields, which is useful but does not provide meaningful semantics beyond the schema.

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

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

The description states a clear verb and resource: 'List users in FreeIPA,' and identifies the supported filter fields (UID, cn, mail). It does not explicitly contrast itself with the sibling get_user, which likely retrieves a single user, so it stops short of fully differentiating from 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?

The description implies usage through 'Optionally filter by UID, full name (cn), or email address,' which tells the agent that all filters are optional and what they target. However, it does not explain when to prefer this tool over get_user or mention any exclusions, so the routing guidance is only implicit.

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 reveals that this is a mutation ('Remove') but does not state failure semantics (e.g., what happens if a UID is not a member, or whether a partial failure aborts all removals), idempotency, or required permissions. For a destructive operation with zero annotation coverage, this is a notable 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?

A single sentence that leads with the action verb and scopes the operation cleanly. There is no filler, and every word contributes meaning.

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

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

For a two-parameter tool with 100% schema coverage, the description plus schema is minimally viable: an agent knows what to pass and the basic effect. However, with no output schema and no annotations, the missing failure behavior and return-value information leave a meaningful gap for a mutating operation on a domain-specific system like FreeIPA.

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

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

Schema description coverage is 100%, so the schema already documents both group_cn and uid, including the uid string-or-array union. The description's 'one or more' reinforces the array variant but adds no format, syntax, or constraint details beyond the schema; baseline 3 is appropriate.

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

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

The description states a specific verb (Remove), a clear resource (users from a FreeIPA group), and scope ('one or more'), so an agent understands the core operation. It implicitly contrasts with the sibling add_user_to_group via the 'Remove' verb, but never names the alternative explicitly.

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

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

The description provides no information about when to use this tool versus add_user_to_group, nor any conditions or prerequisites such as the group needing to exist or the users needing to be current members. An agent must infer usage entirely from the tool name and the inverse sibling.

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 provides the key caller-relevant behavior: it is a privileged operation with two distinct flows, self-service with current password vs. admin API flow. It stops short of disclosing side effects such as session invalidation or password-policy enforcement, but it does not contradict any annotation and adds meaningful authentication 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?

Two short sentences with no filler: the action is front-loaded and the only necessary invocation nuance follows immediately. Every word earns its place.

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

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

For a three-parameter mutation with no output schema, the description plus schema gives an agent enough to invoke it correctly: target user, new password, and the current-password/admin condition are all covered. It could add side-effect or failure-mode context, but nothing essential to a first correct call is missing.

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

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

Schema coverage is 100%, so the schema already documents uid, new_password, and current_password. The description reiterates the conditional current_password rule and adds the admin API flow context, but it does not materially expand on what the parameters mean beyond the structured definitions, so the baseline score of 3 is appropriate.

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

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

The description opens with an unambiguous verb and resource, 'Reset a FreeIPA user's password,' which clearly distinguishes this from sibling account-management tools like enable_user, disable_user, and delete_user. There is no ambiguity about what operation is exposed.

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

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

It gives a concrete invocation condition: a current password is required unless the call is made by an admin with sufficient privileges via the admin API flow. This helps an agent decide whether to supply current_password, although it does not explicitly discuss alternatives or when-not-to-use cases beyond that condition.

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