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, yet it discloses nothing about what constitutes an anomaly, how z_warn vs z_crit are surfaced, whether the operation is read-only, or the shape of the result. Naming EWMA is the only behavioral hint, leaving the agent to guess at thresholds and output semantics.

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 single sentence is front-loaded and wastes no words, but it is terse to the point of under-specification for a four-parameter analytical tool, so conciseness here comes at the cost of completeness.

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 return-value explanation is not strictly required, but for a four-parameter tool with 0% schema coverage and no annotations the description is far too thin. It gives no indication of input format, threshold semantics, or safety profile.

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% across four parameters, and the description does not compensate. It hints at EWMA smoothing (relevant to 'alpha') but says nothing about 'values', 'z_crit', or 'z_warn' and their roles.

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 (detect anomalies) and even names the method (EWMA), which is more than a bare tautology. However, 'en serie' is vague about the expected input format, and there is no differentiation from any sibling tool (though the sibling list suggests this tool is functionally distinct from the Klipper/config tools).

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The agent must infer context entirely from the name and the word 'EWMA'.

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, and it discloses almost nothing: whether it writes a file to disk, requires a running Klipper instance, validates the inputs, or has side effects is entirely unspecified. "Generate" weakly implies output production rather than mutation, but nothing is confirmed.

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

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

A single short, front-loaded sentence with no filler. It is efficient, though the brevity reflects under-specification rather than deliberate economy.

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 and 0% parameter documentation, the description should explain inputs and behavior; an output schema exists so return values need no explanation, but the tool's invocation requirements remain opaque. For a four-parameter generator it is substantially 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% for four parameters (name, description, has_timer, gcode_commands), and the description adds no information about any of them. An agent cannot tell what format the name or description should take or how gcode_commands is used.

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 specific verb ("Genera") and resource ("plantilla canónica de extra Klipper"), so an agent knows it produces a canonical Klipper extra template. It does not differentiate itself from siblings like validate_config or lint_extra, but the core purpose is clear.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of what to do with the generated template. The single sentence states only what it produces.

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. "Lee" weakly implies a non-destructive read, but nothing is said about permissions, behavior when the file is missing, whether the printer argument changes resolution scope, or any limits. For a zero-annotation tool 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?

A single front-loaded sentence with zero waste, which is appropriately sized. But the brevity comes at the cost of under-specification rather than tight precision, so it is not a strong example of economical structure.

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 return values need not be described. Beyond that, the definition is inadequate for a two-parameter tool with 0% schema coverage: no parameter meaning, no usage context, and no behavioral detail are supplied anywhere.

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 and does not: neither the required "filename" nor the "printer" argument (with its non-obvious "default" value) is explained. The word "archivo" loosely maps to filename but adds no format, path, or resolution 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?

States a specific verb ("Lee") and resource ("archivo de configuración"), so the core operation is unambiguous. However, it offers no differentiation from closely related siblings like search_config, list_config_files, or validate_config, leaving the agent to infer which read variant applies.

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 tool versus alternatives such as search_config or list_config_files, nor any prerequisites or exclusions. The agent must infer usage purely from the 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?

With no annotations, the description carries the full burden. It implies a safe read, but says nothing about permissions, whether it runs on the printer host, latency, or what happens if the log is missing. A single clause is thin for a zero-annotation 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?

One short sentence, front-loaded with the verb and resource, with no filler. It is arguably under-specified rather than verbose, but for its length it wastes no 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?

An output schema exists so return values need not be explained, but the description leaves the printer selector undocumented and provides no behavioral context for a two-parameter tool with no annotations. Not sufficient to call it confidently across multiple printers.

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 hints at tail_lines via 'N líneas', but the 'printer' parameter (default 'default') is never mentioned, leaving half the parameters undocumented anywhere.

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 specific verb (lee/reads) and resource (últimas N líneas de klippy.log), making the operation immediately identifiable. It does not differentiate from any sibling, but no sibling overlaps this log-reading function, so the gap is minor.

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 tool, when not to, or what alternatives exist (e.g. get_printer_status for behavior vs. raw log text). The agent must infer the diagnostic use case entirely.

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 implies a read operation via 'Obtiene' but says nothing about permissions, side effects, rate limits, or the operational context (e.g., mcp_bridge) beyond a terse mention.

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

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

The description is a single front-loaded sentence with no wasted words. However, it is so minimal that it fails to carry its share of information for a tool with a parameter and no annotations, bordering on under-specification rather than efficient conciseness.

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 return values need not be explained. Still, the description omits parameter semantics, usage context, and behavioral details, making it incomplete for an agent trying to invoke the tool correctly under ambiguous 'telemetry' semantics.

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 single parameter 'printer' has 0% schema description coverage and is not mentioned or explained in the description. The description does nothing to compensate for the missing parameter semantics, leaving the agent without guidance on what values are valid or what 'default' 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 verb ('Obtiene') and a resource ('telemetría de extras MCP (mcp_bridge)'), so the general purpose is identifiable. However, 'telemetría' is vague and no sibling differentiation is provided, leaving the agent unsure how this differs from related tools like get_server_info or get_klippy_log.

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 tool, when not to use it, or which sibling tools are alternatives. The description only asserts what it retrieves, not the context in which retrieval 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it does almost none. It never says the operation is read-only, whether Klipper must be running or connected, what happens with an empty objects value, or how the query behaves for offline printers.

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?

It is a single short, front-loaded sentence with no padding, which is structurally fine. But brevity here comes at the cost of under-specification rather than efficiency, so it sits at the minimum-viable level.

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 return values need not be described, and that is the only gap the description is excused from. With zero annotation coverage and zero parameter documentation, the definition is not complete enough for an agent to call this query tool confidently.

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% for both parameters, and neither 'objects' (a string defaulting to empty) nor 'printer' is explained. The description's word 'objetos' loosely gestures at the objects parameter but gives no format (comma-separated? single name?), no valid object names, and no indication of what the printer identifier expects.

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 verb (consulta) and resource (estado de objetos de Klipper), so the general purpose is inferable. However, the name promises 'printer status' while the description talks about arbitrary 'Klipper objects', and nothing distinguishes it from siblings like list_objects, get_server_info or get_print_progress. An agent cannot tell which of those to pick from this text alone.

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 when-to-use guidance, no prerequisites, and no mention of any alternative among the many closely related siblings (list_objects, get_print_progress, get_server_info). The agent is left to guess when this tool is the right choice.

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, yet it says nothing about read-only semantics, permissions, polling expectations, or how the 'default' printer is resolved. The verb 'Obtiene' weakly implies a read, but nothing else about behavior is conveyed.

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?

One short sentence with no wasted words and nothing buried, but the brevity here reflects under-specification rather than disciplined conciseness. Structure is fine for the size, yet the size is inadequate 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?

An output schema exists, so return values need not be explained. However, with zero annotation coverage and zero parameter documentation, the definition leaves the read-only nature, the printer parameter, and any sibling distinction entirely to inference.

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 mentions no parameter at all. The single 'printer' parameter with default 'default' gets no explanation of what value it accepts, whether it is a name/index, or what happens when omitted.

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 "Obtiene progreso de impresión" is a direct restatement of the tool name get_print_progress in another language, adding no distinguishing detail. It does not differentiate this tool from close siblings such as get_printer_status or get_klippy_log, so an agent gets essentially nothing beyond the name 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 when-to-use guidance, no prerequisite, and no mention of when to prefer get_printer_status or any other sibling. The agent must infer the entire usage context from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing. It does not say whether this is a read-only operation, whether it hits the network, what subset of server state it reports, or how it behaves for multiple printers.

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?

It is a single short sentence with no filler, so it is structurally clean and front-loaded. However, the brevity reflects under-specification rather than efficient communication.

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?

Although an output schema exists (so return values need not be described), the definition lacks annotations, parameter documentation, and any usage context. For a tool exposed alongside 16 siblings, this is not enough for reliable selection or 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 single 'printer' parameter has 0% schema description coverage and is never mentioned in the description. With no explanation of what 'printer' selects (and it being optional with a 'default' value), the agent is left guessing about multi-instance targeting.

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 'Información del servidor Moonraker' essentially restates the tool name get_server_info, adding only the vendor qualifier 'Moonraker'. It states no verb or action and does nothing to distinguish the tool from siblings like get_printer_status or get_mcp_telemetry, which also return status-style information.

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 indication of when to call this tool, when not to, or how it relates to alternatives such as get_printer_status or get_mcp_telemetry. An agent has no basis for choosing between these information-returning 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 carries the full behavioral burden. It does not disclose read-only nature, side effects, or the specific checks performed, though 'linter' weakly implies read-only.

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

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

A single short sentence fragment. While brief, it is under-specified rather than efficiently concise, and it does not front-load actionable details.

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

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

The output schema covers return values, but the description still lacks usage guidance, rule specifics, and parameter explanation. It is insufficient for an agent to 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% for the single source_code parameter. The description only hints the input is a Klipper extra, adding no format, constraints, or meaningful parameter detail.

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 it is an AST linter applying golden rules to Klipper extras, naming a function and a resource. However, the 'golden rules' are vague and the description does not differentiate this from sibling validate_config.

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 no when-to-use guidance, no prerequisites, and no alternatives. An agent cannot tell when to choose this over validate_config or other validation 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the listing is recursive, read-only (implied but unstated), scoped to a printer, or what the response contains, despite an output schema existing.

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

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

A single short sentence with no waste. It is appropriately brief, though brevity here reflects under-specification rather than disciplined 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 tool with an undocumented parameter and no annotations, the description is inadequate. It omits the printer-scoping behavior and gives no indication of what the listing returns, leaving the agent dependent on guesswork.

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

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

Schema coverage is 0% and the single parameter 'printer' (default 'default') is completely undocumented in either the schema or description. The description does not mention that listing is printer-scoped, which is critical for correct invocation.

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

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

The description states a clear verb and resource ('Lista archivos de configuración' = List configuration files), which distinguishes it from siblings like get_config_file (singular read) and validate_config. However, it is a bare restatement with no scope details (all files? filtered? per printer?).

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

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

No guidance on when to use this versus siblings like search_config or get_config_file. The description gives no conditions, exclusions, or alternatives, leaving the agent to infer usage from the name alone.

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

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

No annotations provided, so the description must carry the full behavioral burden. It says nothing about what 'objects' are, whether this reads current runtime state or config, or any limits. An output schema exists but the description adds no behavioral context beyond the terse statement.

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

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

A single short sentence that is front-loaded and wastes no words. It is concise, though it could stand to be more informative without becoming verbose.

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

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

Given one parameter, no annotations, an output schema, and many siblings, this description is inadequate. It doesn't explain what objects are listed, whether they relate to config or runtime, or how results differ from related tools.

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?

One optional parameter (printer) with no schema description (0% coverage). The description doesn't clarify its meaning or default beyond what's in the schema. With a single parameter and no schema docs, the description should compensate but does not; baseline for 1 param with low coverage is 3.

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 verb (list) and resource (objects registered in Klipper), which is clear enough for the action. However, it doesn't distinguish this from sibling tools like get_config_file or get_printer_status, and 'objects' is vague compared to other tools' specific domains.

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

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

No guidance on when to use this versus alternatives such as get_config_file or validate_config. The agent is left to infer usage context entirely.

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

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

With no annotations, the description carries the full behavioral burden, and it only discloses the confirm gate. It does not say whether the restart aborts an active print, whether it is disruptive or reversible, how long the service is unavailable, or what the printer param controls. For a service-restart mutation this is a significant disclosure 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?

Two short sentences with zero filler, and the core action is front-loaded ahead of the precondition. It is efficient, though arguably so terse that brevity comes at the cost of substance rather than being a virtue in itself.

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 return values need not be explained. However, for a no-annotation restart operation with 0% parameter coverage and a second unexplained parameter, the description leaves too much unstated about side effects and scope to let an agent call it safely and 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% and there are two parameters (confirm, printer). The description explains only that confirm must be True; the printer parameter (which presumably selects which printer/instance to restart) is completely undocumented in both the schema and the description. Only half the parameter surface is addressed, and even that adds little beyond the name.

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

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

The description states a specific verb and resource ('Reinicia Klipper'), which is unambiguous and distinct from any sibling (none of the other tools restart the service). It does not explicitly differentiate from neighbours like run_gcode, but the action itself is unique enough that an agent can select it confidently.

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 only guidance is the precondition 'Requiere confirm=True'. There is no statement of when to use this tool versus alternatives (e.g. run_gcode with a RESTART command) or under what circumstances a restart is warranted. The prerequisite is useful but does not constitute usage routing.

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

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

With no annotations, the description must fully disclose behavioral traits. It mentions a safety gate for dangerous commands but omits critical details such as permissions required, consequences of executing arbitrary G-code, and what happens if confirm is omitted for a dangerous command.

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

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

The description is front-loaded and contains no wasted words. However, its extreme brevity is arguably under-specification for a tool with no annotation or schema support, making it too terse to be fully effective.

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 hardware execution tool with no annotations, 0% schema coverage, and an output schema that only covers return values, the description should explain parameter meanings, execution context, and safety implications. It only addresses one narrow safety condition, leaving the agent without enough context to invoke it safely.

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

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

Schema description coverage is 0% for three parameters. The description only clarifies the role of confirm for dangerous commands, leaving the expected format of gcode and the purpose of the printer parameter completely 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 phrase 'Ejecuta G-code' gives a specific verb and resource, clearly identifying the tool's action. It does not explicitly differentiate from siblings, but no sibling performs G-code execution, making the purpose unambiguous.

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

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

The description states a condition: dangerous commands require confirm=True. However, it does not explain when to use this tool versus alternatives like restart_klipper or validate_config, nor does it define what counts as 'dangerous'. Usage is implied but not fully specified.

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, yet it says nothing about whether matching is case-sensitive, regex or literal, how results are scoped, or that the operation is read-only. Only the bare action 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?

A single short sentence with the action front-loaded and no filler. It is efficient, though brevity here shades into under-specification rather than pure conciseness.

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 return values need not be explained, but with zero annotations, zero schema descriptions, and an undocumented printer parameter, the definition leaves too much unresolved for an agent to invoke it confidently against the config-file siblings.

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 nothing defines either parameter. The description's word 'patrón' hints that query is a pattern rather than a literal string, but it never clarifies pattern syntax, and the printer parameter (default 'default') is left 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?

States a clear verb+resource: search a pattern across all configs. An agent can distinguish a global search from get_config_file or list_config_files, though those siblings are never named. No sibling differentiation is offered explicitly.

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

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

Usage is only implied: find where a value appears across configs. There is no explicit when-to-use, when-not-to-use, or pointer to alternatives such as get_config_file for a single file.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a non-mutating validation but says nothing about error reporting, what invalid input triggers, or whether any state is affected. With zero annotation coverage this is a notable gap.

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

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

It is a single front-loaded sentence with no wasted words, but its brevity stems from under-specification rather than economy. The sentence earns its place but covers only the bare minimum.

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 return values needn't be explained, but with no annotations, no parameter documentation, and no usage guidance, the definition is not complete enough to reliably select and invoke the tool. The 0% schema description coverage leaves the parameters fully undocumented.

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 parameter meaning whatsoever. It never explains config_content (the required field) or the optional filename with its default of printer.cfg, so it does not compensate for the low coverage.

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

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

The description gives a specific verb (valida) and resource (contenido de configuración Klipper), so an agent knows it validates Klipper config. It does not, however, differentiate from close siblings such as lint_extra or search_config, which also operate on config data.

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 when-to-use, no when-not-to-use, and no mention of alternatives like lint_extra or get_config_file. The agent receives no routing guidance at all.

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, yet it says nothing beyond restating the operation. It does not disclose failure behavior (what happens if the component is absent), whether this connects to the printer, or any side effects, though the existence of an output schema does relieve it of explaining return values.

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

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

A single short sentence that is front-loaded and free of waste. It is appropriately concise, though its brevity reflects under-specification rather than tight editing.

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 0% schema description coverage, no annotations, and two parameters, the description leaves too much unsaid: valid component names, the role of the printer parameter, and any behavioral expectations. The output schema covers return values, but the invocation-side gaps remain.

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

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

Schema description coverage is 0% for both parameters. The description only implies a component name via the tool's purpose; it never explains acceptable component_name values (e.g. 'klippy', 'virtual_sdcard') or the purpose of the 'printer' parameter, which defaults to 'default'.

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+resource: verifying whether a Moonraker component is loaded. It is clear on its own, but it does not differentiate from the visible sibling verify_extra_loaded, which follows the same verification pattern for a different target.

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 when-to-use guidance, prerequisites, or alternatives are given. With verify_extra_loaded in the sibling list, an agent would benefit from knowing whether to call this for components vs. extras in a given situation, and that distinction is 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 must carry the full behavioral burden. It states that a verification occurs but says nothing about read-only nature, permissions, or side effects; while 'Verifica' implies a read, this is not explicit.

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

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

A single short sentence that is front-loaded and free of fluff. However, for a tool with two parameters and an output schema, it is under-specified rather than appropriately detailed.

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 and 0% schema coverage, the description is incomplete: it does not explain parameters, read-only behavior, or how the result should be interpreted. The existence of an output schema covers return values only.

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 only indirectly implies the extra_name parameter ('un extra Klipper') and completely omits the printer parameter and its default.

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 specific verb ('Verifica') and resource ('extra Klipper'), so the agent knows it checks whether a Klipper extra is loaded. However, it does not differentiate from the near-identical sibling verify_component_loaded, so an agent cannot easily choose between them. Clear but no 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?

No when-to-use guidance and no mention of the sibling verify_component_loaded as an alternative. The only implied usage is the generic 'verify something' context.

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