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

No annotations are provided, so the description carries the full burden. It discloses simultaneity and the 2-4 key range as behavioral traits beyond the schema, but omits prerequisites such as window focus, OS support, error behavior, and whether keys are held or released.

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 telegraphic sentence with examples; there is no wasted text and the key constraint is front-loaded. It is slightly fragmentary but appropriately sized for the tool.

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

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

An output schema exists, so return values need not be explained. For a one-parameter UI shortcut tool the input format is covered, but missing usage context and behavioral prerequisites leave gaps given that no annotations are present.

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 single parameter has no schema description. The text compensates by defining teclas as 2-4 simultaneous key names and giving examples like ["ctrl","t"] and ["alt","tab"], adding meaning beyond a raw array-of-strings 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?

States a specific resource (keyboard shortcut) and scope (2-4 simultaneous keys) with examples. It implicitly distinguishes itself from the single-key sibling astrax_tecla by requiring simultaneous keys, but does not name the alternative explicitly.

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

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

The examples show invocation format but there is no explicit when-to-use or when-not-to-use guidance. The 2-4 simultaneous constraint implies usage for key combinations, but no alternative routing is provided.

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

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

With no annotations, the description carries the burden, and it discloses the key traits: output is PNG, it returns a path, and it does not open/display the result. Remaining gaps (save location, overwrite behavior) are minor for a simple screenshot tool, but no annotation coverage means it could say slightly more.

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 sentence, front-loaded with the primary action, with a tight parenthetical that handles the sibling disambiguation. No wasted words.

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

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

An output schema exists so return-value detail is redundant, and the description still notes the path return. The critical sibling routing is covered; only the parameter semantics and save-location details are thin.

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 nombre_archivo parameter. The description implies a file is written as PNG but never explains the filename argument or its default. It adds marginal meaning but does not fully compensate for the coverage 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?

States a specific verb and resource (guarda la pantalla como PNG) plus the return value (devuelve su ruta). It explicitly distinguishes itself from the sibling astrax_ver_pantalla, so the agent can route correctly without opening either schema.

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

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

The parenthetical names the alternative and the exact condition that selects it: 'para VER usa astrax_ver_pantalla'. This is an explicit when-to-use-this-vs-that instruction, not an inference.

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 discloses that the click targets the element center, which is useful, but says nothing about side effects, whether a single or repeated action occurs, required focus/visibility, or blocking/wait behavior for a tool that mutates UI state.

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, front-loaded sentences with no filler; the action and its target come first, the parameter vocabulary second. It is efficient, though it could be marginally tighter in the coordinate framing.

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 annotation coverage, 0% schema description coverage, and a UI-mutating action, the description is too thin. It omits coordinate reference frame, element-center semantics for x/y, and any precondition or failure behavior an agent would need to call 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% and the schema lists no enum for boton, so the description adds real value by enumerating valid values (left|right|middle) and confirming the default. However, x and y are only named, with no explanation of coordinate origin or reference frame, leaving the two required parameters underspecified.

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 (click) and the coordinate target, and clarifies it points to the CENTER of the element. The purpose is unmistakable, but it does not differentiate itself from the close sibling astrax_doble_clic or explain the relationship to astrax_tecla/astrax_atajo for input 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 when-to-use guidance and no mention of alternatives. An agent cannot tell from the description whether to reach for this versus astrax_doble_clic, astrax_tecla, or astrax_atajo, nor whether any precondition (focus, element visibility) applies.

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 discloses button (left) and action type, but says nothing about the coordinate system, whether the cursor is moved first, focus/OS requirements, or failure behavior when no element is at (x, y).

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 the use-cases in a compact parenthetical. No wasted words.

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

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

An output schema exists, so return values need not be explained, and this is a relatively simple pointer action. Still, with zero annotation coverage and no parameter documentation, the missing coordinate semantics leave a real gap 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% for both required parameters; they appear only as bare 'X'/'Y' integer titles. The description repeats '(x, y)' but adds no coordinate origin, unit, or range, so it fails to compensate for the coverage 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+resource ('Doble clic izquierdo en (x, y)') and clarifies the intent with concrete examples (open files/icons, select word). It is clearly distinguishable from the sibling astrax_clic by the 'doble' qualifier, though it never explicitly names the single-click sibling.

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 parenthetical examples ('abrir archivos/iconos, seleccionar palabra') imply the contexts where a double-click is appropriate, which is genuine usage guidance. However, there is no explicit when-to-use-this-vs-astrax_clic statement and no 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 full burden. It discloses the non-interactive constraint and the return shape, but for arbitrary shell execution it says nothing about permissions/privilege requirements, sandboxing, destructive potential, or what happens to the timeout default of 30s when exceeded.

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 tight sentences with the core action front-loaded and no filler. It earns its brevity, though the brevity is partly the problem given how much is left unstated.

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 re-explained (the description repeats them anyway). But for a high-risk execution tool with zero annotations and 0% parameter coverage, the definition omits privileges, timeout behavior, working-directory semantics, and non-interactive failure modes.

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 all 3 parameters, so the description must compensate and it does not. It never explains 'comando' syntax, what 'directorio' controls (working directory vs. sandbox root), or what 'timeout_seg' does on expiry; only the required/optional split is inferable 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?

States a specific verb+resource: executes a shell command. The parenthetical 'sin entrada interactiva' implicitly distinguishes it from the interactive-input siblings (astrax_tecla, astrax_escribir), but no sibling is named explicitly. Purpose is clear without needing to open the schema.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives despite seventeen sibling tools. The 'sin entrada interactiva' note hints at a boundary with the input-emulation tools but never states when to prefer this tool over them.

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. It usefully discloses a non-obvious side effect: non-ASCII input (ñ, accents, emojis) is routed through the clipboard, implying clipboard state may be clobbered. It does not cover error behavior, whether existing field content is replaced or appended, or timing/focus-loss risks.

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, zero filler, with the focus prerequisite and the non-ASCII caveat front-loaded. Every clause carries information an agent needs.

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 unnecessary. For a one-parameter typing tool, the description covers the key operational caveats (focus requirement, clipboard fallback), leaving only edge cases like replacement semantics or failure modes unstated.

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 is a single parameter (texto) with 0% schema description coverage, so the description is the only source of meaning. "Teclea texto" plus the non-ASCII note implies the parameter is the literal string to type, which is adequate for a self-evident single argument but adds no format, length, or escaping 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 a specific verb+resource: typing text into the currently focused element. It is distinguishable from astrax_tecla (single key) and astrax_portapapeles (clipboard manipulation), but it never names those siblings explicitly, so differentiation must be inferred from their names.

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?

Gives a concrete prerequisite ("clic antes en el campo"), which is useful operational guidance. However, it never says when to prefer this over astrax_tecla, astrax_atajo or astrax_portapapeles, so alternative-selection is left to inference.

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 exist, so the description carries the full burden. It usefully discloses a behavioral constraint absent from the schema — the 0.1-15 s range — which tells the agent the wait is bounded and will not accept arbitrarily long durations. It does not say whether the call blocks, whether it is re-runnable, or what it returns, but for a low-risk sleep primitive those gaps are minor.

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 tight sentence with the verb and range front-loaded and the rationale in parentheses. Every clause earns its place; nothing is padded.

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 no explanation, and for a one-parameter sleep tool the description covers duration, purpose, and sequencing. Slightly incomplete in not indicating whether the wait is blocking or how it pairs with the verification step that follows.

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 'segundos' parameter has no description, default of 2. The description compensates partially by stating the unit and the valid 0.1-15 s window, which is not present in the schema (no min/max). It still does not explain what happens at the boundary values or how it interacts with the caller's timing.

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 (esperar/wait) plus the resource context (carga de apps o páginas) and the sequence ('antes de verificar'). It is clearly distinguishable from siblings like astrax_clic or astrax_escribir, though it does not name any sibling explicitly.

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

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

The phrase 'antes de verificar' implies when to use it (after triggering a load, before checking state), and the parenthetical scopes it to app/page loading. However there is no explicit when-not guidance or named alternative for cases where a fixed wait is the wrong approach.

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

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

With no annotations, the description carries the full burden. It discloses the return content (pixel dimensions, top-left origin) and that the value is effectively constant (call once), which is helpful. It does not state that the call is side-effect free or mention any auth, but for a trivial info tool the gap is minor.

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 compact clauses with the return value front-loaded and no filler. Appropriately sized for a one-liner info tool.

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

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

An output schema exists, so the description need not detail return values. For a zero-param, read-only info tool with no annotations, purpose plus the call-once hint covers what an agent needs; only an explicit read-only/no-side-effects statement 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?

The tool takes zero parameters, so the baseline of 4 applies. There is no parameter syntax the description needs to explain beyond what an empty schema already communicates.

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 resource and what it returns: the screen size in pixels, with the coordinate origin specified (top-left). This is clearly distinct from screenshot/view siblings, though it does not name them 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?

"Llámala una vez" gives a useful caching hint (fetch once and reuse), which is genuine guidance. However there is no statement of when to use this versus siblings like astrax_capturar_pantalla or astrax_ver_pantalla; usage context is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that the write operation *replaces* (overwrites) existing clipboard content, which is a destructive trait, but says nothing about permissions, error behavior, or invalid `operacion` 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 front-loaded sentence that names the resource first and then the two modes, with zero redundant or filler text.

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

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

For a two-parameter tool with an output schema already covering the return value, the description covers the essential mode semantics and the schema's missing enum. Only error/invalid-operation behavior is unaddressed, a minor gap given the tool's simplicity.

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 schema has no enum for `operacion`, so the description does real work by enumerating the valid values ("leer"/"escribir") and clarifying that `texto` is the replacement payload. It still omits the default-empty behavior of `texto` and read-mode handling.

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 the resource (clipboard) and the two distinct operations it supports, disclosing exactly what read and write do. It is clear and specific, though it does not explicitly differentiate itself from siblings like astrax_escribir or astrax_tecla.

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 implied by the two modes: read to retrieve content, write to replace it with `texto`. However, there is no explicit when-to-use guidance or any statement about when to prefer this over related sibling tools.

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

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

With no annotations, the description carries the full burden. It usefully discloses the sign convention (positive=up, negative=down), the valid range (-30..30), and that x,y must be supplied together, but says nothing about what x,y actually do or how out-of-range values are handled.

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 terse sentence with the most important constraint (sign convention) front-loaded. Efficient, though the terseness is partly a byproduct of under-specification given the 0% schema coverage.

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 no annotations and 0% parameter description coverage, the description should say more about x,y and error behavior to fully enable 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 coverage is 0%, so the description must compensate. It documents the semantics of 'cantidad' (sign and -30..30 range) and the coupling of x,y, but never explains what x and y represent (presumably coordinates), leaving two of three parameters partially opaque.

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 and axis ('Scroll vertical') with a clear sign convention. It is easily distinguishable from siblings like astrax_clic or astrax_escribir, though it does not explicitly name or contrast with any 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?

No guidance on when to use this versus alternatives, and no prerequisites or context. It only conveys parameter behavior, leaving the agent to infer when a scroll 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, the description carries the full burden and does disclose the critical behavioral gate: user confirmation must precede the call. However, it never explains what permissions are actually granted, their scope, or whether the grant is reversible/persistent beyond the session.

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?

Three short sentences, front-loaded with purpose followed immediately by the safety-critical constraint. Every sentence earns its place with no padding.

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, and the crucial confirmation behavior is covered. But with zero annotation coverage and 0% parameter documentation, an agent still lacks guidance on what 'permisos_extra' does and what granting entails.

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 neither parameter is addressed in the description. 'permisos_extra' is entirely undocumented, and 'confirmacion_usuario' is only obliquely implied by the confirmation instruction rather than explained as a required boolean gate.

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 and resource ('Concede los permisos de la tarea durante la sesión'), so an agent can tell it apart from siblings like astrax_tarea_crear or astrax_tarea_estado. The scope of 'permisos' remains somewhat abstract, but the action 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?

Explicitly states when to call (only after showing the plan and receiving an explicit 'sí') and adds a hard prohibition ('Nunca sin preguntarle'). This is a textbook when/when-not instruction with no ambiguity.

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 usefully discloses the permission-revocation side effect on the last step and the dual success/failure modes, but says nothing about auth requirements, reversibility, or what happens to step data after closure. Meaningful but incomplete 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?

A single dense sentence plus two short clauses, front-loaded with the primary action and its branches. Every clause adds information; nothing is padded.

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, and the side-effect disclosure is valuable. But for a state-mutating tool with no annotations and a required parameter left undocumented, the description should say more about `resumen` and the effect of closure.

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%, so the description must compensate and partly does: it defines `exito` true/false semantics and explains `datos` as outputs passed to subsequent steps. However, `resumen`, the only required parameter, is never described, leaving a notable 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?

States a specific verb+resource: closing the current task step, with the branch outcome (success/failure) made explicit. It doesn't explicitly contrast with siblings like astrax_tarea_estado or astrax_tarea_crear, but the operation is 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 explains the two branches (exito=true closes and advances, exito=false logs a failure), which implies usage, but never states when to call this versus alternatives such as astrax_tarea_estado or astrax_tarea_guardar. Guidance is implied rather than explicit.

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

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

No annotations exist, so the description carries the full burden and does meaningfully disclose side effects: it writes the plan into a state file, surfaces the plan and permissions to the user, and requests exactly ONE confirmation. It omits residual behavior such as what happens if a plan already exists in the state file or whether it overwrites/locks subsequent steps.

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

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

Compact and front-loaded: the sequencing role ("PASO 1") leads, followed by the write behavior and then the per-parameter note. The line breaks and mixed indentation are slightly awkward but no sentence is wasted.

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 the description covers the workflow position, the file side effect, the confirmation flow, and the permissions domain. Missing only edge-case behavior (existing state, failure handling) that an agent working alongside astrax_tarea_limpiar or astrax_tarea_estado might need.

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%, so the description must compensate, and it largely does: it enumerates the valid permisos_requeridos values (pantalla, raton_teclado, portapapeles, terminal) and constrains pasos to be short, concrete, ordered items. Only "objetivo" is left undocumented, though its meaning is self-evident from its 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?

States a concrete verb and resource ("Guarda el plan ... en el archivo de estado") and positions itself as "PASO 1 de toda petición multi-paso", so the agent knows this is the plan-initialization step of a task workflow. It does not, however, explicitly differentiate itself from the adjacent sibling astrax_tarea_guardar, which sounds like it could also persist task 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?

"PASO 1 de toda petición multi-paso" gives an explicit triggering condition: use this first whenever a request spans multiple steps. It stops short of stating when NOT to use it (e.g. single-action requests should route straight to astrax_clic / astrax_tecla), so the exclusion side is left to inference.

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 supplied, so the description carries the full burden. It does disclose that this is a read of a compact state ("Lee", "estado compacto") and names its contents, which is useful, but it says nothing about permissions, whether state can be missing/empty, or how fresh the data is. Adequate but not rich for a tool with zero annotation coverage.

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

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

Two short sentences, zero filler, and the core behavior (what it reads) is front-loaded ahead of the usage directive. Every clause 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?

Output schema exists, so return values need not be described, and complexity is low. However the one input parameter is left unexplained in both schema and description, which is the main completeness gap for an otherwise self-contained tool.

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

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

The single parameter "completo" has 0% schema description coverage, so the description must compensate and largely does not. The phrase "estado compacto" hints that "completo" toggles between compact and full output, but the parameter is never explicitly explained, leaving an agent to guess its effect.

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 ("el estado compacto") and enumerates what it returns: current step, next step, and saved data. This is enough to distinguish it from sibling mutation tools like astrax_tarea_guardar or astrax_tarea_crear, though it never names a specific sibling as the contrast.

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?

"Úsalo al empezar cada paso EN LUGAR de releer el historial o capturas viejas" gives an explicit trigger (start of each step) and an explicit alternative to avoid (history re-reads, old screenshots). The when-to-use condition and the replacement behavior are both stated, leaving nothing to inference.

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

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

With no annotations provided, the description carries the behavioral burden. It usefully discloses the value-type constraint (routes or short values, not long content), which is genuine behavioral context beyond the schema. However, for a mutation tool it omits overwrite/replace semantics, error behavior, and whether existing keys are preserved.

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 tight sentences, purpose front-loaded, followed immediately by the one operative constraint. No filler or redundancy.

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

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

An output schema exists, so return values needn't be explained, and the simple two-parameter store is largely covered by the purpose plus value-type guidance. What's missing is mutation semantics (overwrite behavior) for a state-writing tool, leaving a modest gap.

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

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

Schema coverage is 0%, so the description must compensate. The example 'pdf_generado=/ruta/carta.pdf' concretely maps to clave (the key name) and valor (the stored value), and the length constraint on valor adds meaning the bare schema lacks. It falls short only because it doesn't address value types beyond strings.

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 (Guarda) and resource (un dato clave de la tarea) with a concrete example, so an agent can tell it stores task key/value state rather than creating a task or checking status. It doesn't explicitly differentiate itself from siblings like astrax_tarea_crear or astrax_tarea_estado, so it stops short of a 5.

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 example and the constraint (save paths or short values, not long contents) imply when this tool is appropriate, but there is no explicit when-to-use versus alternatives guidance and no prerequisites or sequencing relative to astrax_tarea_crear/estado. Usage is inferable rather than 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, the description carries the full behavioral burden. It discloses what is destroyed (state file and temporary screenshots), which is valuable, but it omits whether the deletion is irreversible, whether confirmation is required, or any permission or rate-limit constraints. Adequate but incomplete for a destructive operation.

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

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

The description is a single, front-loaded sentence with a parenthetical clarification. Every word earns its place, and there is no filler or redundancy. Slightly less than perfect because the parenthetical could be integrated more smoothly.

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

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

Given the tool's simplicity (no parameters, output schema present), the description provides sufficient context: what it deletes and when to use it. It does not need to explain return values, but it could mention potential side effects on task state. Overall adequate 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?

The tool takes zero parameters, so the schema description coverage is irrelevant. Per the rubric, zero parameters sets a baseline of 4, and the description does not need to add parameter semantics beyond what the empty schema provides.

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

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

States a specific verb ('Borra') and resources ('archivo de estado y las capturas temporales'), and clarifies the intent with 'descartar o cerrar una tarea'. This distinguishes it from siblings like astrax_tarea_guardar or astrax_tarea_completar_paso, though the differentiation is not explicit in the text.

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

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

The parenthetical '(descartar o cerrar una tarea)' implies usage context—cleanup when discarding or closing a task. However, it does not explicitly state when to use this versus alternatives like completing steps or saving, nor does it provide 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 burden of behavioral disclosure. It never states which application receives the keystroke (active/focused window assumption), whether the call blocks, or what happens if the key string is invalid — all critical for a GUI automation 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?

A single front-loaded sentence with the core action first, followed by the key examples and repetition range. Efficient, though the parenthetical key list is somewhat long and could be trimmed.

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 no explanation. But for a key-injection tool with no annotations and no usage guidance, the description omits the targeting context (which window/app receives the key) and error behavior, leaving meaningful gaps 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 compensate. It usefully lists example values for 'tecla' (enter, esc, tab, win, backspace, f5, down...) since the schema provides no enum, and it bounds 'repeticiones' to 1-20. However, it omits the accepted string format/casing and the default of 1 for repeticiones.

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 ('Pulsa una tecla') and even enumerates valid key names, so an agent immediately knows this presses a single keyboard key. It is clear, but it never distinguishes itself from siblings like astrax_atajo (key combinations) or astrax_escribir (text entry), which is exactly where confusion is likely.

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 explicit guidance on when to use this versus astrax_atajo or astrax_escribir, nor any mention of prerequisites such as a focused window. Usage is only implied by the verb 'pulsa'.

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 carries the full burden and largely meets it: it discloses the return format (JPEG), the 1:1 coordinate correspondence with astrax_clic, and the red-circle cursor overlay. It omits cost/latency or screen-state caveats, but the core behavioral facts an agent needs are present.

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 tight lines with the output format and usefulness constraint front-loaded; every clause earns its place with no filler.

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

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

For a no-argument tool with no output schema, the description supplies the essentials: what comes back (a JPEG), how its coordinates align with other tools, and when to invoke it. Only the relationship to astrax_capturar_pantalla is left unexplained.

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 takes zero parameters, so the schema baseline of 4 applies. The mention of 1:1 coordinates with astrax_clic is useful operational context but is not parameter semantics.

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

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

States a specific verb and resource — it views the screen and returns a JPEG image — and notes the coordinate mapping to astrax_clic. It does not, however, distinguish itself from the sibling astrax_capturar_pantalla, which an agent could reasonably confuse with this tool.

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?

Gives clear positive guidance (use it to verify the result of an action) and an explicit exclusion (don't fire it blindly after every trivial step). It stops short of naming which alternative to prefer for other screenshot needs.

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