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

With no annotations provided, the description carries the burden. It explicitly states the action is irreversible and all entries will be deleted, which is a critical behavioral disclosure. It does not mention any permissions or authentication requirements, but for a clear/delete operation, the irreversibility is the key risk.

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

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

Two short sentences, front-loaded with the action and target, followed by a critical warning. No wasted words, perfectly 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 simple 3-parameter destructive action with no output schema, the description covers the core purpose, irreversibility, and parameter semantics via the schema. It does not mention the response format (e.g., success or failure), but that is a minor omission given the tool's simplicity and the lack of an output schema.

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

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

Schema description coverage is 100%, with each parameter well-explained (log_id with auto-discovery, resource_id with examples and references to list tools, resource_type with enum meanings). The description itself adds no extra parameter information beyond what the schema already provides, 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?

The description clearly states the action ('Clear the event log') and the target resource ('system or BMC manager'), with an explicit note on the irreversible deletion. This distinguishes it from sibling tools like list_event_log, which only reads.

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 specifies the two resource types ('Systems' and 'Managers') and what they correspond to, giving clear context for when to use each. It does not mention alternatives or when not to use it, but the irreversibility warning implies a cautionary use case.

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 convey behavior. It indicates a read operation ('Get') and states it 'Returns all BIOS configuration parameters,' which is transparent about the action. However, it lacks details on permissions, potential failures, or output structure, leaving some 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 concise and front-loaded with the main action. The second sentence adds a slight redundancy ('Returns all BIOS configuration parameters') but is not wasteful. Overall, it is appropriately sized.

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 (one parameter, no output schema). The description covers its core purpose and return value sufficiently. It does not mention any prerequisites or edge cases, but these are less critical for a straightforward get operation.

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

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

The schema has 100% coverage for the single parameter (system_id), including an example and guidance to use list_systems. The description does not add any parameter-specific meaning, 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?

The description clearly states the action ('Get') and the resource ('current BIOS attributes and settings for a system'). This is specific and distinguishes it from sibling tools, none of which target BIOS settings.

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 usage is implied: if you need BIOS configuration, use this tool. However, it does not explicitly mention alternatives or when not to use it. The schema provides a hint to use list_systems for IDs, but that is not in the description.

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. It discloses that the tool returns full details including hardware, network adapters, and links, which gives some sense of the response content. However, it does not explicitly mention read-only behavior, permission requirements, potential errors, or other 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 brief and to the point, with no unnecessary words. The primary purpose is front-loaded in the first sentence, and the second sentence lists included content without fluff.

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

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

For a simple getter with one parameter and no output schema, the description adequately lists the content of the response. It could mention response format or error behavior, but given the simplicity and good schema coverage, it is sufficiently complete.

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

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

The schema already fully documents the single parameter with examples and cross-reference to list_chassis. The description only adds 'by its ID,' which reinforces the schema but provides no additional semantic value beyond what the schema already states.

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 function: retrieving full chassis details by ID, and distinguishes it from list_chassis by specifying a single chassis retrieval. The mention of included content (hardware details, network adapters, links) adds specificity.

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 need for an existing chassis ID, and the schema parameter description mentions using list_chassis to find IDs, but the tool description itself does not explicitly state when to use this tool over alternatives. No explicit exclusions or alternative guidance 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 burden of behavioral disclosure. It uses the read-only verb 'List' and states the return fields (Name, Version, Updateable flag), which is useful. It does not mention pagination or potential large result sets, but for a simple inventory tool this is adequate.

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 sentences, front-loaded with the action and scope, and includes only relevant return information. No wasted words.

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

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

Given the tool has no parameters and no output schema, the description sufficiently covers what the tool does and what it returns. It states the scope (all components) and the result fields, making it complete for an agent to understand and invoke 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?

The tool has zero parameters and the input schema is empty, so there is nothing to explain. The description correctly omits parameter details, and with 100% schema coverage, the baseline of 4 applies.

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

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

The description clearly states the tool's purpose: 'List all firmware versions across all components' with a specific verb and resource, and enumerates component types (BIOS, BMC, NICs, etc.). This distinguishes it from sibling tools like get_bios_settings or list_drives by focusing on firmware inventory.

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 that this tool is for listing firmware versions across components, which implies its use case versus siblings. However, it does not explicitly mention when not to use it or name alternative tools, so it lacks explicit exclusions.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It conveys a read-only operation through the verb 'Get' and clarifies the return contents. It does not explicitly state that there are no side effects or permission requirements, but for a simple getter, the behavior is sufficiently 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, focused sentence that clearly states the tool's purpose and includes the key detail scope. It is front-loaded and contains no filler, making it optimally concise and well-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 simple single-parameter getter with no output schema, the description adequately summarizes what the operation returns. It could mention potential error behavior, but given the low complexity, the description is sufficiently complete for an agent to 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?

The schema description for manager_id covers 100% of the parameter, providing examples and a pointer to list_managers. The tool description itself adds no parameter-specific meaning beyond what the schema already provides, 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 clearly states a specific action ('Get full details') and resource ('BMC manager'), and specifies the lookup key ('by its ID'). It also lists the content scope ('network interfaces, firmware version, and all manager details'), which distinguishes it from sibling tools like list_managers (which lists) and reset_manager (which mutates).

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 implicitly conveys when to use it (when you need full details for a specific manager ID), and the parameter description adds the prerequisite to use list_managers to find IDs. However, it does not explicitly mention when not to use it or alternatives beyond list_managers.

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 relies on the verb 'Get' to signal a read-only operation, which is clear. However, it doesn't add extra behavioral context such as requiring specific permissions, potential errors, or that it doesn't modify settings. The description focuses on output content rather than behavioral traits.

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

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

The description is a single, concise sentence that front-loads the primary action and follows with a precise list of what it returns. Every word earns its place, and it avoids unnecessary 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 simple getter with one parameter and no output schema, the description is sufficiently complete. It specifies the exact information returned (protocols and port numbers) and implies the input via the schema. It doesn't detail output format or error conditions, but these are not critical for such a straightforward 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 the parameter (manager_id) with a clear description and example, so the description doesn't need to add parameter-specific semantics. The description adds no extra parameter information beyond what the schema already provides, which is acceptable per 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 clearly states 'Get BMC network protocol settings' with a specific verb and resource, and lists the exact protocols covered (IPMI, SSH, HTTPS, SNMP, Telnet) plus port numbers. This distinguishes it from sibling tools like get_manager or get_system, which have broader or different scopes.

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 retrieving network protocol configuration, but does not explicitly state when to use it versus alternatives or any exclusions. There is no mention of when this tool is preferred over get_manager or other system tools, so the guidance remains implicit 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?

With no annotations provided, the description carries the burden of behavioral disclosure. The verb 'Get' implies a read-only operation, and the return values are listed. However, it does not explicitly state such traits as 'does not modify the chassis' or mention any prerequisites, errors, or side effects beyond what is implied.

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

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

The description is two concise sentences that immediately state the purpose and return values. There is no redundant information, and it is well-structured with front-loaded content.

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

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

For a simple read tool with one parameter and no output schema, the description sufficiently explains the returned data. It covers the essentials but could be enhanced with a brief note on when to use it relative to set_power_state, though the low complexity keeps this from being a major 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?

The schema covers 100% of parameters, with a clear description for 'chassis_id' (e.g., 'System.Embedded.1') and a pointer to list_chassis. The tool description adds minimal semantic value beyond the schema, 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 clearly states the verb 'Get' and the resource 'power data for a chassis', and specifies exactly what is returned (power supply status, current consumption in watts, power capacity). This distinguishes it from sibling tools like get_thermal (temperature) and set_power_state (changing power state).

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 power data for a chassis, but it does not explicitly mention when not to use it or point to alternatives like set_power_state for changing power. The context is clear but exclusions or alternative references are absent.

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

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

No annotations are provided, so the description carries the full burden. It clearly discloses the kind of data returned (e.g., BiosVersion, HostName, IndicatorLED, Boot settings) and indicates it returns 'all hardware details,' making the read-only nature evident. It does not mention potential errors or auth requirements, but for a simple read operation this is sufficient.

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

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

The description is concise: two sentences, front-loaded with the core action, and includes a brief example plus a list of key response fields. 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 tool with one parameter and no output schema, the description covers the essential context: what the tool does, how to specify the target, and what fields are included. It could be slightly more explicit about the return shape, but the listed fields and 'all hardware details' give adequate completeness.

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

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

The input schema already provides a complete description of the single parameter (system_id) with examples and guidance. The tool description adds no new meaning beyond what the schema already states, so it meets the baseline for high schema coverage but does not exceed it.

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

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

The description uses a specific verb ('Get full details') and identifies the exact resource ('computer system by its ID'), with examples. It clearly distinguishes from sibling tools like list_systems, which lists systems rather than retrieving a single system's details.

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 tool is for retrieving detailed information about a specific system, and the parameter schema adds 'Use list_systems to find IDs.' However, the description itself does not explicitly mention when to use this instead of alternatives or name sibling tools, though the context is 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 provided, the description carries the full burden. It discloses the return fields (sensor name, Celsius reading, upper thresholds, health status), which is useful. However, it does not explicitly state that the operation is read-only or safe, nor does it mention permissions, rate limits, or error behavior. This leaves some transparency gaps but is 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?

The description is two sentences: the first states the purpose, the second lists the returned data. There is no filler or redundant information, and it is front-loaded with the primary action.

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 getter, the description and schema together are largely complete. It explains what the tool does and what it returns. While there is no output schema or annotations, the described return fields help the agent understand the expected data. Minor gaps, such as not explaining the exact format of thresholds or health status, prevent a perfect score.

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

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

The tool description adds no parameter information beyond the input schema. The schema already provides a detailed description for chassis_id, including an example and a pointer to list_chassis. Since schema coverage is 100%, 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 clearly states the tool retrieves thermal data (temperatures and fans) for a chassis, naming the specific resource and action. It distinguishes itself from sibling tools like get_power by specifying thermal metrics, and includes return content (sensor name, Celsius, thresholds, health status).

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

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

The context is clear: use this when thermal data for a chassis is needed. While it doesn't explicitly name alternatives or exclusions, the schema description for the only parameter instructs to use list_chassis for IDs, providing practical guidance. The implied usage is straightforward given the tool's specific purpose.

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

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

With no annotations, the description carries the full burden. It discloses the return fields: 'Returns ChassisType, Manufacturer, Model, SerialNumber, and Status for each chassis.' This goes beyond a bare statement and reveals expected output content. It does not mention side effects, but as a read-only list operation, this is sufficient for a simple 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 a single, effective sentence that is front-loaded with the action and resource. It is concise with no unnecessary words, and clearly states the output.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is complete. It states what the tool lists and what it returns. There is no missing information that would hinder 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?

The input schema has zero parameters, so the baseline is 4. The description adds no parameter details because there are none. It does not need to explain anything beyond the schema.

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

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

The description clearly states the tool's function: 'List all chassis managed by this BMC.' It uses a specific verb ('List') and resource ('chassis'), and distinguishes from siblings like list_systems and get_chassis by specifying the chassis 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 implies usage for enumerating all chassis on the BMC, but does not explicitly mention when to prefer this over alternatives like get_chassis (for a specific chassis) or list_systems (for systems). No when/when-not guidance is provided, so the usage context is only implied.

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

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

There are no annotations, so the description carries the full burden. It discloses the return contents (capacity, protocol, MediaType, health, serial number), which is useful behavioral context for a read-only list operation. It does not mention auth, rate limits, or pagination, but these are less critical for a simple list.

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 two-sentence structure that is front-loaded with the action and immediately lists the return fields. No wasted words.

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

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

The tool has only two well-documented parameters and no output schema, so the description compensates by enumerating the returned fields. It covers the core information needed to invoke and interpret the results.

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

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

Schema description coverage is 100%, with clear descriptions for both system_id and storage_id, including an example and reference to list_storage. The tool description adds no additional parameter context, 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?

The description uses a specific verb 'List' with a specific resource 'physical drives for a storage controller', and clarifies the output fields. This clearly distinguishes it from sibling list_storage, which lists controllers rather than physical drives.

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 vs alternatives, nor does it mention any exclusions. The context is implied by the resource 'physical drives', but there is no direct guidance such as 'use when you need to inspect drive health' or comparison to list_storage.

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 the tool returns entries with specific fields and automatically tries common log paths (SEL, System, Log1), which is valuable for understanding its behavior. It does not explicitly state read-only semantics, but 'Get' strongly implies it. The disclosure is reasonable for a list operation.

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

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

The description is three concise sentences. It front-loads the purpose, then adds return fields and auto-discovery behavior. There is no redundant information or fluff; every sentence contributes useful context.

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 5 parameters and no output schema, the description covers the key aspects: what it does, the resource types, automatic path handling, and the fields returned. It does not mention how to obtain resource IDs (though sibling tools list_systems/list_managers imply this), but the schema fills those gaps. Overall, it is sufficiently complete for the complexity level.

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

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

Schema description coverage is 100%, so each parameter is already well-documented. The description adds minimal semantic value for parameters, mainly reinforcing the auto-discovery behavior for log_id with examples. Since the schema covers parameters thoroughly, a baseline score of 3 is appropriate; the description provides marginal extra meaning.

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 function: retrieving system event log entries from a system or BMC manager. It specifies the resource type and the data returned (Severity, Message, Created timestamp), and distinguishes itself from sibling tools like clear_event_log by focusing on reading logs. The verb 'Get' is specific and the scope is well-defined.

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

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

The description makes the primary use case clear: to obtain event log entries. It also notes automatic log path discovery, which is a helpful usage hint. However, it does not explicitly mention alternatives or exclusions (e.g., when to use clear_event_log instead), though the sibling list implies such distinctions. The context is strong enough without explicit 'when-not' 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 full burden. It does disclose the output fields, which is useful, but does not explicitly state that it is a read-only operation or mention any prerequisites or side effects. 'List' implies safety, but an explicit statement would improve 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 a single, front-loaded sentence that states the action and the key return fields. Every word earns its place, with no redundancy 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 parameterless list tool with no output schema, the description provides sufficient context: what it lists and what fields are returned. It is a simple tool, and the description fully covers its purpose and expected output, making it complete for an agent to invoke 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?

There are zero parameters, and the schema has no properties. The baseline for 0 params is 4, and since there is nothing to explain, the description adequately covers the parameter semantics by omission.

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 the specific verb 'List' with a clear resource 'BMC managers' and scope 'all', distinct from sibling get_manager which presumably retrieves a single manager. It also states the returned fields, removing 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 phrase 'List all BMC managers' provides clear context for when to use this tool—when you need an enumeration. It does not explicitly mention alternatives or exclusions, but the presence of get_manager implies differentiation. This matches 'clear context, no exclusions'.

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

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

No annotations are provided, so the description carries the full burden. It lists the return fields and implies a read-only operation with the verb 'List.' However, it does not mention side effects, error behavior, or authentication requirements. The description adds the specific return fields but lacks deeper behavioral context beyond that.

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, front-loaded with the main purpose and followed by a concise list of return fields. No filler or redundant information; every word contributes value.

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

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

For a single-parameter list tool with no output schema, the description covers purpose, scope (for a system), and return content. It lacks explicit error conditions or pagination behavior, but the tool's simplicity and the presence of sibling context make it sufficiently complete.

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

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

Schema coverage is 100% with a detailed description for system_id, including examples and a pointer to list_systems. The tool description itself adds no additional parameter information, so the baseline of 3 applies because the schema already handles 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 uses a specific verb and resource: 'List storage controllers for a system.' It clearly distinguishes itself from siblings like list_drives (drives vs. controllers) and list_systems (system enumeration). The returned fields (controller name, model, firmware, RAID types, health) further clarify the scope.

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 storage controller details are needed, but it does not explicitly state when to use this tool over alternatives like list_drives. There's no mention of exclusions or alternative tools, so guidance 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 burden of disclosing behavior. The verb 'List' implies a read-only operation, and the description specifies returned data. However, it does not mention side effects, permissions, or any potential limitations, which would be more 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 sentence, immediately front-loading the action and resource, with a list of return fields. Every word contributes value with no 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 simple list operation with no parameters and no output schema, the description fully captures the purpose, scope, and return data. It lacks only explicit read-only confirmation and any note on potential output size, but these are minor for this tool type.

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 zero parameters, the schema provides no information, so the description's mention of 'all' systems adds meaningful scope. The baseline for 0 parameters is 4, and the description reinforces that no filtering is applied.

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 lists all computer systems managed by the BMC, with a specific verb ('List') and resource ('computer systems'). It also enumerates the exact return fields, making its purpose distinct from siblings like get_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 implies use for enumerating all systems, and the sibling get_system suggests a one-system alternative, but there is no explicit when-to-use or when-not-to-use guidance. The word 'all' hints at scope but does not directly contrast with get_system.

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. It discloses the default reset type (GracefulRestart) and the key side effect (temporary disconnect). This goes beyond the basic operation and gives the agent a warning about the impact.

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 compact: three short sentences, each adding value. It front-loads the action and includes necessary caveats without any 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?

Given the tool has only two parameters and no output schema, the description covers the operation, default behavior, and the critical consequence. It is sufficient for an agent to 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 baseline is 3. The description only repeats the default 'GracefulRestart' which is already in the schema's default field, and adds no extra meaning for manager_id or reset_type.

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 'Reset (restart) the BMC manager.' This is a specific verb-resource pair. It is clearly distinct from sibling read/list tools, and the parenthetical 'restart' clarifies the action.

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

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

The description provides clear context: it's the reset operation for the BMC manager, and warns that it will temporarily disconnect. However, it does not explicitly mention alternatives or when-not-to-use scenarios, though no alternatives exist among siblings.

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 must disclose behavioral traits. It lists supported reset types but does not warn about destructive effects (ForceOff, ForceRestart), potential data loss, or prerequisites for graceful operations. This is a safety-relevant tool, so the omission is significant.

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 sentences, front-loaded with the action and resource. The list of reset types is concise, though duplicated in schema, but its placement in the description enables quick agent scanning without parameter lookup.

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 power-control tool with no output schema, the description is too thin. It lacks safety warnings, expected outcomes, and any mention of when to use which reset type (beyond the schema's one-line meanings). It is not complete enough for an agent to safely invoke this tool without additional context.

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

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

Schema coverage is 100% and both parameters have detailed descriptions in the schema, including enum value explanations. The description adds no extra parameter meaning beyond the schema; it only repeats the enum list, which is redundant but not harmful.

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

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

States a clear verb ('Change') and resource ('power state of a computer system'), with a specific list of supported reset types. This distinguishes it from sibling tools like reset_manager, which targets manager 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?

Provides clear context: it is for computer systems and enumerates valid reset types. However, it does not explicitly mention exclusions (e.g., 'use reset_manager for manager power') or alternative tools, so it stops short of full when/when-not guidance.

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