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

With no annotations, the description carries the full burden. It does convey that the operation is read-only ('obtiene'), which is the key behavioral trait. However, it does not disclose details like Docker daemon access requirements, possible error conditions, or the fact that only historical (not streaming) logs are retrieved.

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 with no redundant words. It fronts the core action and object, making it easy to parse quickly. It would benefit from more detail elsewhere, but as written it is efficient.

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

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

For a simple read-only log retrieval tool with only two parameters and an output schema present, the description is nearly sufficient. The required 'name' and optional 'tail' default are visible in the schema, and the output schema covers return behavior. The main gap is explicit parameter guidance, but the tool is simple enough that an agent can likely invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the parameters. It does not explicitly explain that 'name' identifies the container or that 'tail' controls the number of lines to return. The phrase 'últimas líneas' loosely hints at tail behavior, but the parameter meanings are largely left to inference from 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 specific action: 'Obtiene las últimas líneas de logs de un contenedor' (gets the last log lines of a container). This is a specific verb + resource and naturally distinguishes it from sibling tools like docker_list_containers or docker_restart_container.

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 container logs, but it does not explicitly state when to prefer it over alternatives or provide exclusions. There is no guidance about scenarios like large log volumes, tail usage, or why one might use this instead of docker_list_containers.

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 behavioral burden. It conveys read-only enumeration and promises status information in the output, but it does not clarify whether stopped containers are included by default or describe any further behavioral traits. This is adequate but minimal.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for a one-parameter list tool, though the brevity leaves room for the parameter semantics that would have made it more useful.

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

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

An output schema exists, so the return shape is covered elsewhere. However, the description omits parameter semantics and any usage guidance, and with no annotations the overall context is incomplete enough that an agent may not know how to use the all_containers flag effectively.

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

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

Schema description coverage is 0% and the description does not mention the all_containers parameter. The parameter name and default value of true hint at broad listing, but the agent cannot learn what false means or how it changes the result set.

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, 'Lista contenedores Docker y su estado,' identifies a clear verb and resource: it lists Docker containers and provides their status. It is distinguishable from related Docker sibling tools like docker_container_logs or docker_restart_container by being a listing operation, though it does not explicitly name an alternative.

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

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

There is no guidance about when to use this tool versus its siblings. The description does not mention that docker_container_logs is for logs or that start/stop/restart operate on the containers listed here, so usage context must be inferred entirely from the tool name.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states 'Reinicia' (restart), which implies a state-changing action, but does not describe side effects (e.g., downtime), permission requirements, or what 'permitido' means. An agent cannot predict the impact or constraints beyond the basic action.

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

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

The description is a single sentence with no filler or redundancy. It is efficiently front-loaded with the core action. However, it is so short that it sacrifices informative content; still, for conciseness alone, it earns a high score, though not a 5 because of the loss of necessary 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?

Despite having an output schema, the description is incomplete for a tool with no annotations and three undocumented parameters. It lacks any explanation of the 'confirm' mechanism and does not clarify the scope of 'contenedor permitido'. An agent would need external knowledge or experimentation to call this correctly, making it incomplete.

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

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

Schema description coverage is 0%, and the description adds no meaning to any of the three parameters: name, confirm, or timeout. It does not explain the required 'confirm' parameter (likely a confirmation flag) or the optional timeout. The agent is left to guess what values to provide, making correct invocation unreliable.

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 (restart) and resource (container), and the qualifier 'permitido' adds a small nuance. While it doesn't explicitly differentiate from siblings like docker_start_container or docker_stop_container, the verb itself is distinct enough. It is specific but slightly terse.

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 on when to use this tool versus alternatives. There is no mention of scenarios that favor restart over start/stop, no prerequisites, and no exclusion criteria. The agent is left to infer that restart is for running containers, which is 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 must disclose behavioral traits, but it only says 'starts' without detailing side effects, permission requirements, whether the container must exist, or what happens if it is already running. The 'allowed' qualifier also raises unanswered questions about access control.

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

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

The description is extremely brief, which is concise, but it is under-specified rather than efficiently informative. It lacks essential details, making the conciseness a weakness rather than a strength.

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 two required parameters and no annotation support, the description is grossly insufficient. It does not explain the confirm field, describe the return output, or provide any context on when this tool is appropriate, leaving the agent with almost no actionable information.

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

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

Schema description coverage is 0% and the description provides no explanation for the 'name' or 'confirm' parameters. The agent gets no added meaning beyond the raw types, and the required 'confirm' field is particularly opaque—its purpose is entirely unexplained.

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 action ('Starts') and resource ('a container'), which distinguishes it from stop and restart siblings. However, the qualifier 'allowed' is ambiguous and does not clarify what makes a container allowed, slightly weakening the purpose statement.

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 on when to use this tool versus docker_restart_container or docker_stop_container. The description does not mention prerequisites, typical scenarios, or any exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the container is stopped, implying a mutation, but does not mention side effects (e.g., losing unsaved state), required permissions, or what happens to dependent containers. The word 'permitido' hints at restrictions but lacks details. This is a marginal improvement over no description but insufficient for a mutation tool.

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

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

The description is extremely short, which could be seen as concise, but it is under-specification rather than efficient writing. It front-loads the action but omits essential context that an agent needs to correctly invoke the tool. Every word must earn its place, but here the few words don't provide enough substance.

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 an output schema (though not described), and no annotations, the description fails to explain prerequisites, confirmation requirements, or post-condition behavior. The complexity is moderate (3 parameters, mutation), but the description only provides a minimal verb-noun phrase. Essential information like what the 'confirm' parameter does or what the response looks like is entirely absent.

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

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

Schema description coverage is 0% and the description gives no information about the three parameters (name, confirm, timeout). The description doesn't clarify what 'name' refers to, what 'confirm' expects, or how 'timeout' behaves. The agent must infer everything from the schema alone, which only provides types and defaults. No added value from 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 identifies a specific action ('Detiene' = stops) and resource ('contenedor' = container), which makes the basic purpose clear. However, the qualifier 'permitido' (allowed) is ambiguous—it could imply permission restrictions but doesn't explain what 'allowed' means. It doesn't clearly distinguish from sibling tools like docker_start_container or docker_restart_container beyond the obvious 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?

No guidance is given on when to use this tool versus alternatives. There is no mention of conditions, prerequisites, or contexts where stopping a container is appropriate, nor any exclusion of cases where restart or stop via other tools would be better. The description is purely a statement of action without any usage context.

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

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

With no annotations present, the description is the sole behavioral signal. 'Checks health and version' correctly implies a read-only diagnostic operation rather than a mutation, but it does not disclose what happens on failure, whether any external service is contacted, or what 'health' encompasses.

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 words. It conveys the action and object immediately and earns its place.

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

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

For a zero-parameter health check with an output schema present, the description covers the essential purpose without needing to document return values. A short note distinguishing it from frigate_stats would improve completeness, but the current text is not inadequate.

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

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

The tool has zero parameters and the schema already provides 100% coverage, so there is no parameter detail for the description to add. The baseline of 4 applies because no parameter explanation is needed.

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 action ('Comprueba' = checks) and a specific scope: Frigate's health and version. This is clear enough to separate it from sibling tools like frigate_events or frigate_review, though it does not explicitly name an alternative as the top-calibration examples do.

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 use case is implied: an agent should call this when it needs to verify that Frigate is healthy and know its version. However, the description gives no explicit guidance about when not to use it or when a sibling like frigate_stats would be more appropriate.

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

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

With no annotations, the description carries the full burden, but 'Consulta eventos recientes' only implies a read operation. It does not disclose return format, pagination behavior, default limits, time-range semantics, or whether it returns metadata versus full event 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 efficient, front-loaded sentence with no filler, which is good for conciseness. However, given five optional parameters and no annotations, it is undersized for the tool's complexity.

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

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

A one-line purpose statement is not enough for a tool with five undocumented parameters, no annotations, and no output schema. An agent lacks the information needed to call it correctly or interpret the response.

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

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

Schema description coverage is 0%, so the description must compensate, but it adds no meaning to after, before, limit, labels, or cameras. It fails to explain timestamp formats, label syntax, or camera filtering, leaving all five parameters effectively undocumented.

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 ('Consulta' = query) and a resource ('eventos recientes de Frigate' = recent Frigate events), so an agent can infer the basic function. However, it does not explicitly differentiate this from sibling tools like frigate_review or frigate_stats, so it misses the top score.

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

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

There is no guidance on when to choose this tool over frigate_review or frigate_stats, nor any mention of filters such as cameras or labels. The description only states what the tool does, not when it should be used.

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. 'Consulta' implies a read-only query, but the description does not explain how filters like reviewed, severity, cameras, or time bounds behave, whether results are paginated, or what the response contains.

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

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

The description is extremely short and front-loaded, but it is under-specified rather than appropriately concise. One vague sentence is not enough for a tool with six parameters and several sibling tools.

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?

There is no output schema, no annotations, and no parameter documentation. The description does not explain return values, filtering semantics, supported severity values, camera selection format, or how this relates to frigate_events, making it insufficient for reliable tool selection and invocation.

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

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

Schema description coverage is 0% and the description does not mention any of the six parameters. The agent must guess the meaning of after, before, limit, cameras, reviewed, and severity from names and defaults alone, with no help from 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 that the tool queries Frigate review elements, which identifies the general action and resource, but 'elementos de Review' is vague and does not define what a review element is. It also does not differentiate this tool from close siblings like frigate_events, frigate_stats, or frigate_check.

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

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

There is no guidance about when to use this tool instead of alternatives such as frigate_events or frigate_stats. No conditions, prerequisites, or exclusion criteria are mentioned, so the agent cannot determine the appropriate context for invoking it.

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

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

With no annotations and no output schema, the description does not disclose behavioral aspects such as whether it is read-only, response format, or side effects. It only mentions that it 'gets metrics' without specifying the nature of the metrics or the response.

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 directly conveys the tool's function without unnecessary words. It is well-structured and easy to understand.

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

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

The description lacks critical context such as the output structure, any required permissions, or how the metrics are formatted. Without an output schema or additional explanation, an agent would not know what to expect from the call.

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

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

There are no parameters in the schema, so the description does not need to clarify parameter usage. However, it also does not provide any additional context about inputs or outputs, but since none exist, it is neutral.

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: retrieving metrics for cameras, detectors, and processes. It is specific and distinguishes it from sibling tools like frigate_events or frigate_review.

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

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

The description does not provide any guidance on when to use this tool versus alternatives, nor any prerequisites or context. It simply states what it does without usage conditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says a service is executed, without mentioning side effects, state changes, the required confirmation, entity impacts, or any safety-related 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 sentence and front-loaded, but it is under-specified rather than appropriately concise. It is short but provides almost no operational information, so the brevity is a weakness rather than a strength.

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 generic execution tool with four required parameters, no output schema, and no annotations, the description is severely incomplete. It lacks examples, the meaning of 'confirm', side-effect warnings, and any relationship to sibling tools, making it inadequate for correct selection and invocation.

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

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

Schema description coverage is 0%, and the description adds no explanation of 'domain', 'service', 'service_data', or 'confirm'. With four required parameters including a confirmation field, the agent gets no help beyond the bare parameter names.

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

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

The description names a specific verb ('Ejecuta') and a resource ('servicio de Home Assistant'), so it states at a high level what the tool does. However, it does not distinguish this generic service caller from sibling tools like ha_turn_on or ha_trigger_automation, which are also Home Assistant service actions.

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

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

There is no guidance on when to use this generic service caller versus the more specific sibling tools, nor any mention of prerequisites, confirmation, or intended context. The agent is left to infer all usage cases from the generic one-liner.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention whether this is a read-only operation, any potential side effects, network dependencies, or failure modes. It simply lists the checks without explaining behavior or safety implications.

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, front-loaded with the resource (Home Assistant) and the three specific checks. There is no redundant wording 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?

With zero parameters and an output schema present, the description is adequate for a simple check operation. However, it lacks any context on when to use it (e.g., before other HA operations) or prerequisites, and does not mention typical use cases beyond the literal checks.

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

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

The tool has zero parameters, so there is nothing for the description to clarify beyond the schema. The baseline score of 4 applies because the absence of parameters means the description does not need to compensate for missing parameter documentation.

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

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

The description clearly states the tool checks three specific aspects of Home Assistant: connection, version, and time zone. This is a specific verb+resource combination that distinguishes it from sibling tools like ha_search_entities or ha_error_log, though it does not explicitly name those alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives such as ha_error_log or frigate_check. The description only states what it checks, not when it should be invoked or what conditions favor it over other health-related tools.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It only states that the tool obtains the current session's error log, but does not describe output characteristics, filtering behavior, size limitations, or whether this is a read-only diagnostic 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 a single concise sentence with no fluff or redundant wording. It front-loads the core purpose, though it is so brief that it does not provide additional structural 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?

The tool is simple, has only one optional parameter, and has an output schema, so minimal description may be acceptable. However, given the lack of annotations and the absence of parameter semantics, the description does not fully enable an agent to understand the tool's behavior or make informed decisions about the max_characters argument.

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 describes one parameter, max_characters, with 0% description coverage. The description does not mention or explain this parameter, its purpose, or how it affects the returned error log. The default value is visible in the schema, but the description adds no semantic value.

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

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

The description states a specific verb ('Obtiene') and a specific resource ('el error_log de la sesión actual'), clearly identifying what the tool does. It is distinct from sibling tools, which focus on guests, entities, services, containers, and other resources rather than session error logs.

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. It does not mention related tools, exclusions, or conditions that would make this the appropriate choice over logs from docker_container_logs or health checks like ha_check.

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

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

No annotations are present, so the description carries the burden. It does convey a read-only get operation and names what is returned, but it does not mention error behavior, potential side effects, or any constraints around entity availability. Adequate but minimal.

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

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

The description is one short, front-loaded sentence with no filler. It efficiently communicates the action and the object without unnecessary detail.

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

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

For a single-parameter getter with an output schema, this is mostly sufficient, but it lacks usage guidance relative to sibling HA tools and gives no parameter format hints. These are real, though minor, gaps.

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

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

Schema description coverage is 0% and the description adds no detail about the expected format of entity_id, such as 'domain.object_id' or examples. The description does not compensate for the missing parameter documentation.

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

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

The description uses a clear verb ('obtiene') and resource ('entidad'), and explicitly states that both state and attributes are returned. This differentiates it from sibling lookup tools like ha_search_entities and ha_unavailable_entities.

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

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

The description gives no guidance about when to use this tool versus alternatives such as ha_search_entities or ha_call_service. There are no conditions, exclusions, or alternative recommendations.

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 explaining behavioral implications. 'Ejecuta' implies an action but does not disclose whether it changes state, requires confirmation, has side effects, or what happens on failure. This is a significant gap for a tool that executes scripts.

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 waste-free, but it is under-specified for a tool with three required parameters. Being short is positive, but the single sentence lacks any structural guidance or useful detail beyond the tool name's 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?

With no annotations, no output schema, and three required parameters at 0% schema description coverage, the description is severely incomplete. It does not explain how to invoke the script, what confirm means, what variables are for, or what the agent should expect afterward.

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

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

Schema description coverage is 0%, and the description provides no explanation of the required parameters: entity_id, variables, and confirm. An agent cannot tell what format entity_id expects, what variables should contain, or why confirm is required. The description entirely fails to compensate for the schema gap.

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 ('ejecuta') and resource ('script de Home Assistant'), making the core operation clear. It implicitly differentiates from sibling tools like ha_trigger_automation or ha_call_service by targeting the script domain, though it does not explicitly contrast them.

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 ha_call_service, ha_trigger_automation, or ha_turn_on. The description does not mention prerequisites, side effects, or whether a confirmation is expected, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It only says 'searches' and does not disclose matching behavior, case sensitivity, partial-match semantics, limit behavior, domain filtering semantics, or whether this is a safe read-only 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 a single short sentence with no filler, making it easy to parse quickly. It is concise but arguably too terse to be fully self-sufficient; however, the missing detail is penalized more appropriately in other dimensions.

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 3 parameters and no annotation context, this description is incomplete. It explains what can be searched but omits how limit and domain affect results, what matching rules apply, and what the output contains. The presence of an output schema reduces some burden, but the description still lacks essential operational 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 description coverage is 0%, so the description must compensate for the schema's lack of parameter information. It does explain that the query can target entity_id or friendly_name, but it says nothing about the meaning of the 'limit' or 'domain' parameters.

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

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

The description clearly states a specific action ('Busca' = search) and resource ('entidades'), and specifies the two key search fields: entity_id and friendly_name. This is clear enough to understand what the tool does, though it does not explicitly differentiate it from sibling tools like ha_get_entity.

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

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

The description gives no guidance on when to use this tool versus alternatives. It implies searching for entities by ID or friendly name, but doesn't mention when to prefer ha_get_entity for exact retrieval or ha_unavailable_entities for listing unavailable entities.

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 provided, so the description must carry the full burden of behavioral disclosure. It does not explain that this is a mutating operation requiring user confirmation (implied by the 'confirm' parameter), nor does it mention any side effects, auth requirements, reversibility, or error behavior. This is a significant gap for a mutation tool.

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

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

The description is a single, short sentence, which is concise, but it is under-specified rather than appropriately sized. It front-loads the purpose but omits essential operational details. This is not conciseness that earns its place; it is truncation that undermines usability.

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 3 required parameters, zero schema coverage, no annotations, and no output schema, the description is severely incomplete. It fails to address the 'confirm' parameter, usage context, or expected outcomes. An agent has no way to correctly invoke this tool based solely on the provided information.

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

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

Schema description coverage is 0%, so the description must explain parameter meanings, but it does not. It only mentions the overall action without clarifying 'entity_id', 'temperature' (e.g., units, range), or 'confirm' (what value to pass, why it exists). The description adds no value beyond what the parameter names alone imply.

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 ('Establece' = sets) and resource ('temperatura objetivo de una entidad climate' = target temperature of a climate entity). This clearly differentiates it from sibling tools like ha_turn_on, ha_turn_off, and ha_get_entity, which handle different aspects of entity control.

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 on when to use this tool versus alternatives. It does not mention prerequisites, conditions, or mention any other tool (e.g., ha_call_service) that could be an alternative. The description is solely a purpose statement with no usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Dispara una automatización' only restates the tool's name and gives no information about side effects, required confirmation, failure behavior, or whether triggering is reversible.

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 short sentence, which is concise, but it is largely tautological and underspecified. It does not front-load actionable details such as what automation is triggered or what confirmation is required.

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 an action tool with two required parameters, no annotations, no output schema, and no parameter documentation, this description is far too incomplete for an agent to invoke the tool correctly. Critical context about the confirm string and entity_id semantics is missing.

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

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

Schema description coverage is 0% and the description does not compensate by explaining either parameter. 'entity_id' and 'confirm' remain entirely opaque, so an agent cannot know what values to supply or what confirm means.

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 ('Dispara') and resource ('automatización'), so an agent can infer the tool triggers an automation. However, it does not distinguish this tool from siblings like ha_call_service or ha_run_script, which could also be used to trigger something.

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

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

The description gives no guidance on when to use this tool versus alternatives such as ha_call_service or ha_run_script. It also lacks prerequisites, exclusion conditions, or context about when triggering an automation is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without revealing side effects, reversibility, confirmation requirements, or what the confirm parameter does. The behavior beyond the action is entirely opaque.

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 overly terse—a single line. While concise, it under-specifies essential information. Conciseness should not sacrifice clarity, and the short length here is more a symptom of under-specification than efficient writing.

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 two required parameters and no output schema or annotations, the description is grossly incomplete. An agent cannot determine how to populate confirm, what the expected outcome is, or any error conditions. The coverage is inadequate 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 0%, so the description must explain the parameters. It does not mention entity_id or confirm at all, leaving the agent to infer meaning solely from names. This is a significant gap given the required confirm parameter.

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

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

The description 'Turns off an entity' clearly states the verb (turn off) and the resource (entity), which is distinct from the sibling tools like ha_turn_on. However, it does not specify what type of entity or differentiate from generic actions like ha_call_service. The purpose is clear at a high level but lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as ha_call_service or ha_turn_on. There is no mention of context, exclusions, or prerequisites. An agent receives no help in selecting this tool over its 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action of turning something on. It does not explain side effects, idempotency, confirmation requirements, or what happens if the entity is already on.

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 with no filler, and the main action is front-loaded. It is structurally efficient, even though other dimensions suffer from the lack of detail.

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

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

Given no annotations, no output schema, and two required parameters, the description is too incomplete for reliable invocation. The required 'confirm' parameter and usage context are missing entirely.

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

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

Schema description coverage is 0%, and the description does not compensate. 'entity_id' is inferable from the word 'entidad', but the required 'confirm' parameter is completely unexplained, leaving its format, allowed values, and purpose unknown.

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 'Enciende una entidad' clearly states the action (turn on) and the resource (entity), which is enough to distinguish it from ha_turn_off. However, it is very terse and does not add scope or any differentiating context beyond the verb itself.

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

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

There is no guidance about when to use this tool versus alternatives like ha_turn_off, ha_call_service, or ha_run_script. The description implies usage only through the verb, but offers no conditions, exclusions, or prerequisites.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden, but it only says 'List' and does not mention side effects, permissions, pagination, or return behavior. The verb implies a read operation, but little else 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 concise, front-loaded sentence with no filler or redundancy. Every word contributes to stating the tool's action and target entities.

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 definition is minimally viable for a simple two-parameter listing tool with an output schema, but it lacks usage differentiation and does not explain limit's role. An agent can likely invoke it from schema defaults, but selection confidence is weakened by missing 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 description coverage is 0%, so the description must compensate for parameter documentation. It partially clarifies include_unknown through 'opcionalmente unknown', but limit is never mentioned, leaving one of the two parameters semantically undocumented.

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 verb 'Lista' and a specific resource: unavailable entities, with optional inclusion of unknown entities. This is clear enough to understand the tool's core purpose, though it does not explicitly contrast with siblings like ha_search_entities or ha_get_entity.

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

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

There is no guidance about when to prefer this tool over ha_search_entities, ha_get_entity, or other entity-related tools, and no exclusions or prerequisites are mentioned. The only usage signal is implied from the tool's purpose rather than explicitly stated.

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

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

No annotations are provided, so the description carries the behavioral burden. The verb 'Lista' indicates a non-mutating read operation, and 'de un nodo Proxmox' scopes the call, but no additional behavior is disclosed such as authentication needs, pagination, or failure behavior. This is adequate for a simple list operation but not a detailed behavioral disclosure.

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

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

The description is a single, front-loaded sentence with no filler words. It conveys the action, the resource, and the scope in its entirety.

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 low complexity of the tool (one required parameter, no nested objects, and an output schema present), the description is almost complete. It covers what the tool does and which node it targets, while the output schema can describe return values. The only notable omission is explicit guidance about when to prefer this tool over siblings, but that is already reflected in the usage-guidelines 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 schema has zero description coverage for the single 'node' parameter, so the description must compensate. It does clarify that 'node' refers to a Proxmox node, and that the output is a list of guests, which adds meaning beyond the bare parameter name. It does not specify the node identifier format or valid values, but the required string parameter is simple enough that this is a minor gap.

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 ('Lista') and names the exact resource and scope: QEMU and LXC guests of a Proxmox node. This clearly distinguishes it from sibling tools like pve_nodes (lists nodes) and pve_guest_status (reads a single guest's 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 intended usage is implied: call this tool when you need to list QEMU and LXC guests on a given Proxmox node. However, it does not explicitly state when to use this tool over alternatives or mention any excluded contexts, so usage 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?

The core behavior is clear: the tool retrieves the status of a guest and implies a read-only operation with no side effects. However, with no annotations and no output schema, the description does not disclose what status fields are returned, whether the guest must be running, or how errors are surfaced.

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 short sentence that front-loads the action and object with no filler. It is compact and scannable, though it sacrifices useful detail for brevity.

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 no output schema and no annotations, so the description should explain return values and parameter constraints; it does neither. The missing guest_type enumeration and unclear node/vmid semantics make the definition incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate, but it only hints at guest_type via 'QEMU o LXC'. Node and vmid are left to their property names, and the accepted values for guest_type are not enumerated.

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 ('Obtiene') and resource ('estado de una VM QEMU o un LXC'), clearly signaling a read-only status check. It distinguishes itself from lifecycle siblings like pve_start_guest and pve_shutdown_guest, though it does not explicitly differentiate from pve_guests, which may also report guest 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 provides no usage context or guidance on when to choose this tool over alternatives such as pve_guests. It does not mention prerequisites, exclusions, or typical scenarios like checking status before starting or shutting down a guest.

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. It accurately describes a non-mutating list operation and indicates that status is included, but it does not detail status format, potential errors, or other runtime 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 front-loaded sentence in Spanish with no filler, repetition, or irrelevant detail. Every word contributes to understanding the tool's purpose.

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

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

For a zero-argument read-only listing tool, this description is nearly sufficient: an agent knows what the tool acts on and generally what to expect. It leaves the exact status fields and output shape unspecified, and there is no output schema to fill that gap, so it is not fully 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 tool accepts zero parameters and the input schema is empty, so the schema fully covers parameter usage (100% coverage). With no parameters to document, the baseline of 4 applies and no additional explanation is needed.

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 ('Lista') and a specific resource ('nodos Proxmox'), and adds the output dimension ('su estado'). It clearly distinguishes this node-level tool from guest-focused siblings like pve_guests and pve_guest_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 intended use case is implied: call this when you need Proxmox nodes and their status. However, there is no explicit guidance about when to choose this tool over related tools, nor any mention of alternatives 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?

With no annotations, the description carries the full burden of behavioral disclosure. 'Permitido' hints at authorization constraints, but the description does not mention whether the operation is disruptive, what happens to running workloads, whether confirmation is required beyond the confirm parameter, or what errors may occur.

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 short sentence with no filler or repetition. It is front-loaded with the main action, though its brevity borders on under-specification rather than deliberate concision.

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 mutating operation with four required parameters, no annotations, no output schema, and no parameter descriptions, this description is incomplete. It omits the confirmation semantics, accepted values, preconditions, and side effects, so an agent lacks critical context for a correct call.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that guest_type can refer to a VM or LXC, but node, vmid, and especially confirm are left semantically unexplained; the description does not say what values confirm accepts or how it gates the reboot.

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, 'Reinicia', and a clear resource, 'una VM o LXC', so an agent can tell this reboots a guest. It is not a tautology, though it relies on the tool name for the reboot/guest framing and does not explicitly differentiate itself from start/shutdown.

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

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

There is no guidance about when to use this tool instead of siblings like pve_start_guest or pve_shutdown_guest. No conditions, exclusions, or decision rules are 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. It mentions a 'clean shutdown', which implies graceful behavior, but it does not explain that this is a state-changing operation, whether confirmation is required for safety, whether it is reversible, or what consequences may occur.

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 with no filler, which is efficient. It loses a point because the awkward 'permitido' phrasing and lack of any structured parameter hints reduce clarity despite the brevity.

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 four required parameters, no annotations, no output schema, and 0% schema description coverage, the description is severely incomplete. It provides no information about parameter formats, required confirm values, return behavior, or safety implications, so the agent cannot reliably invoke the tool.

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

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

Schema description coverage is 0%, and the description does not explain any of the four required parameters: node, vmid, guest_type, or confirm. The phrase 'VM o LXC' hints at guest_type, but no information is given about valid values, especially for the required confirm parameter, leaving the agent unable to construct a correct call.

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

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

The description states a specific action, 'Solicita apagado limpio' (request clean shutdown), applied to a VM or LXC, which clearly distinguishes it from sibling tools like pve_start_guest and pve_reboot_guest. However, the word 'permitido' is awkward and likely a mistranslation of 'guest', slightly muddying the sentence.

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

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

There is no guidance about when to use this tool versus alternatives such as pve_reboot_guest or pve_start_guest. The agent must infer usage entirely from the tool name and sibling list, with no explicit context or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but does not disclose side effects, such as whether the guest must be stopped first, whether the operation is asynchronous, or what happens if the guest is already running. For a state-changing operation, this is a significant gap.

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

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

The description is a single short sentence with no wasted words. It is front-loaded with the action and resource. However, it is so brief that it sacrifices useful context, but for what it contains, it is 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?

Given that this is a state-changing tool with no annotations, no output schema, and 0% parameter coverage, the description is incomplete. An agent would not know what 'confirm' means, what the expected behavior is for an already-running guest, or what the return value indicates. The description is minimally viable but leaves critical gaps.

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

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

Schema description coverage is 0%, and the description does not explain any of the four parameters. The parameter names (node, guest_type, vmid, confirm) are self-explanatory to some degree, but the 'confirm' parameter is ambiguous—it is unclear what value it expects or why confirmation is needed. The description adds no meaning beyond the schema.

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

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

The description 'Arranca una VM o LXC permitido' clearly states the action (start) and the resource (a VM or LXC container), which distinguishes it from sibling tools like pve_shutdown_guest and pve_reboot_guest. However, it is in Spanish and does not explicitly name the sibling alternatives, so it is clear but not fully differentiated.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as checking guest status first, or when to prefer pve_start_guest over pve_shutdown_guest or pve_reboot_guest. The context is implied by the verb 'start' but no explicit usage conditions are provided.

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