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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true. The description adds genuine precondition context (trusted owner, interactive Windows x64 desktop) that the agent needs before calling, but it does not explain what state the option change affects or that effects persist globally for 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?

Two short sentences with no padding, but the first sentence is pure name duplication and consumes the most prominent slot while conveying no information. Efficiently sized yet poorly front-loaded in terms of content.

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

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

For a destructive, non-idempotent mutation with no output schema, the description should explain what changing an option does and that it may alter subsequent AutoIt behavior. It only supplies environment prerequisites, leaving side effects and reversibility 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?

Schema description coverage is 100%, so both 'option' and 'value' are documented structurally; the description adds no extra meaning such as valid option names, ranges, or the semantics of the integer value. Baseline 3 applies when the schema does the work.

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 essentially restates the tool name, changing nothing about what an agent knows: 'Windows AutoIt autoItSetOption'. It never says what the tool actually does (change AutoIt runtime options controlling function behavior) nor how it differs from the sibling 'opt'.

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 or when-not-to-use guidance, and the highly similar sibling 'opt' is never mentioned. The agent is left to infer that this is the option-setting tool and cannot tell which of the two to choose.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: it requires a trusted owner and an interactive Windows x64 desktop, which tells the agent the call will fail in headless or untrusted contexts. It stops short of stating the return format or what happens if the clipboard is empty.

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

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

Two short sentences with no filler and the key constraint (environment requirements) placed up front. It is efficient, though the opening clause spends words restating the tool name instead of describing the action.

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

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

With no output schema, the description should say what the tool returns (the clipboard text as a string) and note relevant failure modes, but it does not. The environment prerequisites are covered and the single parameter is fully documented by the schema, so the definition is adequate but leaves the return value unspecified.

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 optional parameter (bufSize) and schema description coverage is 100%, so the schema already documents the buffer size semantics. The description adds nothing about bufSize, which is the expected baseline when the schema carries the load.

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 is essentially a restatement of the tool name ('Windows AutoIt clipGet') rather than an articulation of what it does, so an agent must infer from the name alone that it retrieves clipboard contents. It names no verb+resource pair and does not distinguish itself from the sibling clipPut, which also operates on the clipboard.

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 a set of environment preconditions ('trusted owner', 'interactive Windows x64 desktop'), which is useful but is a prerequisite, not a when-to-use rule. There is no mention of when to prefer clipGet over clipPut or any alternate tool, and no exclusions for non-Windows or headless contexts beyond the bare mention.

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?

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, and idempotentHint=false. The description adds a genuine precondition (trusted owner, interactive Windows x64 desktop) that the annotations do not convey, but it never discloses that the operation overwrites existing clipboard contents, which is the key destructive consequence.

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

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

Two short sentences with no filler and the environment constraint front-loaded. It is efficient, though the brevity 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 destructive, open-world clipboard mutation with no output schema, the definition omits what happens to pre-existing clipboard data, any permissions/trust model detail beyond the phrase 'trusted owner', and any failure behavior. It is not sufficient for an agent to call this 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?

There is a single parameter with 100% schema description coverage ('Text to put in the clipboard' with a maxLength of 65535), so the schema carries the semantic load. The description adds nothing about the parameter, which matches the baseline 3 for high 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 is essentially a restatement of the tool name ('Windows AutoIt clipPut') and never states in plain terms that it writes text into the clipboard. An agent must infer the verb+resource from the name, and the sibling clipGet is not contrasted. It falls between tautology and a vague purpose.

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 an environment precondition ('requires a trusted owner and an interactive Windows x64 desktop'). There is no when-to-use, no when-not-to-use, and no pointer to clipGet as the read counterpart, so the agent must guess at routing and applicability.

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?

Annotations already declare destructiveHint=true, openWorldHint=true, idempotentHint=false and readOnlyHint=false, so the safety profile is covered. The description does add one genuinely new fact not in the structured data — the trusted-owner and interactive-desktop requirement — which is real added value, but it says nothing about failure behavior when the target control is absent.

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 clauses with no filler, and the environmental constraint is placed up front. However, the first clause is essentially a restatement of the name, and the overall brevity 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 7-parameter, non-idempotent, destructive input-simulation tool with no output schema, the description leaves too much unsaid: which window/control gets targeted, what happens on failure, and why to prefer it over controlClickByHandle. The annotations carry safety but not targeting or failure 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?

Schema description coverage is 100%, so all 7 parameters (x, y, text, title, button, clicks, control) are documented in the schema itself. The description adds no coordinate, button, or click-count semantics beyond that, which is the expected baseline of 3 when the schema does all the work.

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?

"Windows AutoIt controlClick" largely restates the tool name plus a platform tag; it never says in plain terms that it clicks a specific control inside a window. It also fails to distinguish itself from the near-identical sibling controlClickByHandle, so an agent must guess which one 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?

The only guidance is an environment precondition (trusted owner, interactive Windows x64 desktop). There is no statement of when to use this versus controlClickByHandle, mouseClick, or controlSend, and no exclusion criteria for non-Windows or headless contexts.

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?

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds a genuine environmental prerequisite (trusted owner, interactive x64 desktop) not present in structured data, which is useful, but says nothing about what the click mutates or the UI side effects.

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

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

Two short sentences with no padding, so it is concise, but the first sentence is nearly pure name restatement that earns little. It is under-specified rather than optimally sized.

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

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

With a fully documented schema and annotations covering the safety profile, the description technically clears the bar, and the x64/trusted-owner note helps. However, for a destructive input-simulation tool it omits how handles are obtained and how it relates to controlClick, leaving meaningful gaps.

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

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

Schema description coverage is 100%, so the schema already documents x, y, button, clicks, and both handles. The description adds no parameter meaning beyond that, which is the correct baseline when the schema does the heavy lifting.

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

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

The description essentially restates the tool name ("controlClickByHandle") prefixed with the platform. It never states in plain terms that it simulates a mouse click on a specific control identified by handle, nor how it differs from the sibling controlClick. This is a tautology rather than a stated verb+resource.

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

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

There is no when-to-use guidance, no mention of when to prefer this over controlClick or the mouseClick family, and no prerequisites beyond the environmental note. The agent gets no signal about selection between the many closely named 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description does add a genuine environmental constraint not present in the schema or annotations — trusted owner and an interactive Windows x64 desktop — which is real value. However, it says nothing about what the destructive commands actually destroy or any per-command behavior.

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

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

Two short sentences with no padding and the constraints front-loaded, so it is not bloated. But the brevity comes at the cost of substance — the space saved is not used to explain the tool's actual behavior, making it under-specified rather than efficiently concise.

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

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

For a destructive, open-world tool that passes arbitrary command strings to a Windows control, with no output schema, the description should explain the command vocabulary domain and the destructive consequences. Neither is present, so an agent cannot confidently judge what this call will do beyond the annotation flags.

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

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

Schema description coverage is 100%, so all six parameters (text, extra, title, bufSize, command, control) are already documented by the schema. The description adds no semantics about the 'command' string vocabulary or how 'extra'/'bufSize' interact with specific commands, so baseline 3 applies.

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

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

The description largely restates the name ('controlCommand') plus a platform tag ('Windows AutoIt'), which is closer to a tautology than a verb+resource statement. It never says what the tool actually does to a control (e.g. sends an arbitrary command like IsVisible/GetText/ShowDropDown), and it does not distinguish itself from siblings such as controlClick, controlSend, or controlGetText.

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 an environment prerequisite ('Requires a trusted owner and an interactive Windows x64 desktop'), which is useful context but is not when-to-use advice. There is no indication of when this generic command tool should be chosen over the many specific control* siblings, nor any when-not-use or alternative 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?

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, so the mutation/state-change profile is covered. The description adds real value the annotations cannot express: the auth requirement ('trusted owner') and the environment constraint (interactive Windows x64 desktop). It stops short of describing failure behavior when the window/control is not found, which would be useful for a focus 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?

Two short sentences with no filler, and the environmental prerequisite is stated immediately after the identifier. It is tight, though the terseness borders on under-specification rather than optimal 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 a fully documented 3-parameter schema, annotations covering the safety profile, and no output schema to explain, the description only needs to convey purpose and environment. It delivers the environment but leaves the core action undefined, so it is minimally viable rather than complete.

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

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

Schema description coverage is 100% for all three parameters (title, control, text), so the schema already documents them. The description adds nothing about parameter meaning, which is acceptable at this coverage level but earns no credit above the baseline.

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

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

The description is essentially the tool name restated with an environment note: 'Windows AutoIt controlFocus.' It never states what focusing a control actually does (directing keyboard input focus to a control within a window) or how that differs from siblings like controlClick, controlSend, or winActivate. A reader unfamiliar with the AutoIt API gets no functional definition.

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

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

There is no guidance on when to choose this over controlClick, controlSend, or winActivate, all of which interact with window focus/input. The only qualifying statement is the prerequisite ('trusted owner', 'interactive Windows x64 desktop'), which is a condition, not a when-to-use rule.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds real value by disclosing the trust and interactive-desktop requirements, but says nothing about failure modes (e.g., invalid window handle) or when no handle is found.

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 short and front-loaded, and each sentence is terse, but the first sentence is pure name restatement and therefore does not earn its place. The prereq sentence is the only substantive content.

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

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

For a low-complexity two-parameter getter with full schema coverage, existing annotations and no output schema, a minimal description is tolerable. However, it omits the core fact that the return value is a handle usable with the *ByHandle siblings, leaving a meaningful gap.

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

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

Schema description coverage is 100% with only two required parameters, so the schema already documents windowHandle and control. The description adds no syntax, format, or relationship detail beyond the schema, making the baseline 3 appropriate.

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

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

The description leads with 'Windows AutoIt controlGetHandle', which simply restates the tool name rather than stating what it does. It never says the tool retrieves a handle for a control, nor distinguishes it from siblings like winGetHandle or controlGetText.

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 second sentence states environmental preconditions (trusted owner, interactive Windows x64 desktop), which is useful, but there is no when-to-use guidance and no pointer to alternatives such as controlClickByHandle, which consumes the handle this tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds environmental prerequisites (trusted owner, interactive x64 desktop) that the annotations do not, which is genuine added context, but it says nothing about the return shape.

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

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

Two short sentences, front-loaded and free of padding, but the brevity comes at the cost of substance rather than being earned by dense information. It is concise yet under-informative.

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

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

There is no output schema, so the description should convey the return value (e.g., x/y coordinates) of a position query, and it does not. Environment prerequisites are noted, but the definition is inadequate for a tool whose sole output is 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 100%, so the schema already documents title, control, and text. The description adds no syntax, format, or meaning beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description 'Windows AutoIt controlGetPos' essentially restates the tool name and adds no verb+resource explanation of what the tool actually does (retrieve a control's screen position). An agent must infer the function from the name and sibling set alone. This is close to a tautology.

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 controlGetHandle, controlGetText, or winGetPos. The 'Requires a trusted owner and an interactive Windows x64 desktop' line is a prerequisite, not a when-to-use rule, so it does not cover usage selection.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuinely useful runtime context — it requires a trusted owner and an interactive desktop session — but says nothing about how the text is returned, buffer behavior, or failure modes when the control is not found.

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

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

Two short sentences with no filler, but the terseness comes at the cost of substance — the environment note is front-loaded while the actual operation is never explained. It is concise without being informative.

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

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

There is no output schema, so the description should indicate what comes back (the retrieved control text, and what happens on failure or buffer overflow), but it does not. Combined with the absent purpose statement, the definition is insufficient for an agent to call this 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 100% and all four parameters (title, text, control, bufSize) are documented in the schema itself. The description adds no meaning beyond that, so the baseline 3 for high coverage applies.

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

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

The description essentially restates the tool name ('Windows AutoIt controlGetText') without saying in plain terms that it reads the text of a control within a window. Nothing distinguishes it from siblings like winGetText or controlCommand, so an agent must infer the operation from the AutoIt naming convention 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?

It states environment prerequisites (trusted owner, interactive Windows x64 desktop) but gives no when-to-use guidance or comparison to alternatives such as winGetText, controlGetHandle, or controlCommand for reading control data. No exclusions or selection criteria are provided.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true and non-idempotency, so the safety profile is covered. The description adds a genuine new constraint ('trusted owner' and interactive desktop requirement), but it doesn't explain what happens to the control's state or whether hiding is reversible, so it only moderately exceeds the annotations.

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 waste and the identity stated up front. Appropriately sized for a simple three-parameter tool, though the terse phrasing borders on under-specification rather than tight 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?

For a simple three-parameter tool with full schema coverage and no output schema, the environment preconditions are a helpful addition, but the description omits any guidance on return behavior or its relationship to sibling control tools, leaving clear gaps.

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

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

Schema description coverage is 100%, with title, control, and text each documented in the schema, so the baseline is 3. The description adds no syntax, format, or selector guidance beyond what the schema already provides.

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

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

The phrase 'Windows AutoIt controlHide' largely restates the tool name rather than independently describing the action of hiding a Window control. The platform context is useful, but it offers no explicit verb+resource statement and does not distinguish it from siblings such as controlShow or winSetState.

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 an environment prerequisite (trusted owner, interactive Windows x64 desktop) but gives no when-to-use guidance and never contrasts it with the obvious alternative controlShow. An agent must infer the use case entirely 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?

Annotations already declare destructiveHint=true, idempotentHint=false, openWorldHint=true, so the safety/mutation profile is covered. The description adds genuine context beyond annotations by stating the trusted-owner and interactive-desktop environment requirements, but says nothing about what effect the move has or reversibility.

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

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

Two short sentences with no filler, but the first sentence is a name restatement that adds no information. It is brief yet under-specified rather than efficiently informative.

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 7-parameter mutation tool with no output schema, the description omits what actually gets moved or resized, how x/y interact with width/height, and any failure behavior. The environment note is helpful but leaves the core operation underspecified.

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

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

Schema coverage is 100%, so all seven parameters including the required title, control, x, and y are self-documented. The description adds no meaning beyond the schema (no unit, coordinate-space, or width/height semantics), so the baseline 3 applies.

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

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

"Windows AutoIt controlMove" restates the tool name with a platform qualifier rather than stating what it does; an agent must infer the action (move/resize a control) from the name alone. It does not distinguish from siblings like winMove, controlSetText, or controlGetPos.

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 "Requires a trusted owner and an interactive Windows x64 desktop," which is a prerequisite rather than a when-to-use. It never says when to choose this over winMove or other control tools, nor what conditions make it fail.

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?

Annotations already declare destructiveHint=true, readOnlyHint=false, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description adds valuable prerequisite context—trusted owner and interactive Windows x64 desktop—which is not in the annotations. However, it does not describe what the tool actually does or what side effects may occur beyond the annotation hints.

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 short but under-specified rather than concise. The first sentence merely repeats the tool name and platform, failing to earn its place by establishing purpose. The second sentence provides a prerequisite but lacks front-loaded action information, leaving the overall structure unhelpful for an agent.

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

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

Given that this is a destructive AutoIt control-send tool with no output schema, the description should at minimum explain what the tool does and when to use it. It only provides platform and environment prerequisites, omitting purpose, usage context, and behavioral details. The rich annotations and complete schema partially compensate, but the description remains 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?

The schema provides 100% description coverage for all five parameters, so the baseline is 3 even without parameter details in the tool description. The description adds no additional meaning about parameters such as mode, text, title, control, or sendText. The schema already carries the full parameter documentation.

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

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

The description states 'Windows AutoIt controlSend', which essentially restates the tool name and platform without specifying the action (sending text/keystrokes to a window control). It does not distinguish the tool from siblings like send, controlSetText, or controlClick. This is a tautological restatement rather than a clear verb+resource statement.

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

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

No guidance is provided on when to use this tool versus alternatives such as send or controlSetText. The only contextual information is a prerequisite ('requires a trusted owner and an interactive Windows x64 desktop'), which does not tell an agent when to select this tool over others.

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?

Annotations already declare the safety profile (destructiveHint=true, readOnlyHint=false, idempotentHint=false, openWorldHint=true), so the bar is lower. The description adds genuinely useful context not in the annotations: it requires a trusted owner and an interactive x64 desktop, which explains execution preconditions. It still doesn't say whether existing control text is overwritten, but it meaningfully supplements the structured hints.

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 the requirements front-loaded and no filler. Slightly penalized because the first sentence only repeats the name/underlying function rather than adding content.

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

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

For a mutation tool there is no output schema, so the description should ideally explain return behavior or failure modes, which it does not. Annotations plus the stated environment prerequisites give an adequate but not complete picture.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (text, title, control, controlText). The description adds nothing about parameter meaning, syntax, or control-identifier formats beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

"Windows AutoIt controlSetText" essentially restates the tool name and the underlying AutoIt function; it never clarifies in plain terms that this writes/replaces the text content of a UI control. The name carries most of the meaning, and there is no differentiation from siblings like controlSend or controlCommand.

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 environmental prerequisites (trusted owner, interactive Windows x64 desktop) but gives no guidance on when to use this versus controlSend, controlCommand, or controlGetText. No alternatives or selection conditions are named.

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?

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false). The description adds one genuinely non-redundant fact: it requires a trusted owner and an interactive Windows x64 desktop. It does not disclose what state is changed, reversibility, or failure behavior, so it adds modest value over the annotations.

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, but the first clause merely echoes the tool name and the platform token, wasting part of its already minimal budget. The one useful clause (environment requirement) is present and not buried.

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 mutation tool with no output schema, the description should at least say what the call returns or how success/failure surfaces, and what 'showing' a control means for the target window. It covers only the environment precondition, leaving the operation's effect and result 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?

All three parameters (title, control, text) carry 100% schema description coverage, so the schema already defines them. The description adds no parameter meaning, syntax, or matching semantics beyond what the schema provides; baseline 3 applies when the schema does the heavy lifting.

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

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

The description is essentially a restatement of the tool name ('Windows AutoIt controlShow') plus a platform tag. It never states in plain terms what the operation does (e.g., makes a previously hidden control visible), so an agent must infer the verb's meaning from the AutoIt function name 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 conditions, and no comparison to the many sibling control tools (controlHide, controlClick, controlSetText, controlGetText). The environment note hints at preconditions but gives no routing logic between this and controlHide or the other control* 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?

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description usefully adds the environmental prerequisite (trusted owner, interactive Windows x64 desktop), which the agent cannot infer from annotations. It stops short of describing what actually gets clicked or any irreversible side effect on the target UI.

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 the prerequisite front-loaded after the identifier. It is efficient with no filler, though arguably too terse for a destructive input-injection tool.

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

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

For a destructive, non-idempotent desktop input tool with no output schema, the description omits critical context: whether coordinates are screen-absolute, that the click targets whatever window is under the cursor, and any permission/auth caveats. The environmental prerequisite is a start but leaves the agent under-informed for a side-effect-heavy operation.

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

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

Schema description coverage is 100%, so coordinates, speed, button enum, and click count are all documented in the schema. The description adds no parameter meaning beyond that, so the baseline 3 applies. Nothing is missing, but nothing extra is contributed either.

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 action and platform ("Windows AutoIt mouseClick"), so the agent knows it simulates a mouse click. However, it is largely a restatement of the tool name and does nothing to distinguish it from siblings like mouseDown/mouseUp/mouseClickDrag or controlClick. Purpose is implied but vague on scope.

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

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

The only guidance is the prerequisite "Requires a trusted owner and an interactive Windows x64 desktop," which is a precondition rather than when-to-use guidance. There is no indication of when to prefer this over mouseDown/mouseUp, mouseClickDrag, or controlClick. No exclusions or alternatives are given.

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?

Annotations already declare destructiveHint=true, openWorldHint=true, and non-idempotent, so the safety profile is covered. The description adds genuine extra context by naming the required trusted owner and interactive Windows x64 desktop, which is useful for a tool that drives real input. It does not, however, disclose what a drag can affect (selection/move operations) or any timing/rate behavior.

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

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

It is short and front-loaded in structure, but the first sentence is redundant with the tool name rather than informative, so the brevity 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 destructive, side-effecting input-simulation tool with no output schema, the description is thin: it omits drag mechanics, coordinate origin, and what the operation manipulates. The environment prerequisite is useful but insufficient to fully guide correct invocation.

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

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

Schema description coverage is 100%, so x1/y1/x2/y2, speed, and the button enum are all documented in the schema. The description adds nothing about coordinate space (screen vs window) or speed semantics, so the baseline 3 applies.

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

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

The description essentially restates the tool name ('mouseClickDrag') and prefixes it with the platform, without explaining what a click-drag actually does (press at x1,y1, move to x2,y2, release). An agent gains no verb+resource explanation beyond what the identifier already implies, and no differentiation from mouseMove/mouseClick/mouseDown/mouseUp.

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 is given. It never states that this should be preferred over composing mouseDown + mouseMove + mouseUp, nor any condition (e.g., drag-and-drop) that selects this tool over siblings. The only content is an environment precondition, which is not 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?

Annotations already disclose the important behavioral traits (destructiveHint=true, idempotentHint=false, openWorldHint=true), so the bar is lower. The description adds genuine value beyond them by stating the trust/ownership and interactive-desktop prerequisites, but it omits the defining behavior of a press-and-hold tool: the button remains down until mouseUp, which affects subsequent calls.

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

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

Two short sentences with no filler, and the identifying information is front-loaded. A slightly longer description could have earned the space by explaining the hold semantics, but nothing present 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?

For a one-parameter, no-output-schema action tool with rich annotations, this is close to adequate. The missing piece is the stateful press-and-hold contract and its pairing with mouseUp, which an agent must know to sequence calls correctly.

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

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

Schema description coverage is 100% with a single enum-constrained 'button' parameter, so the schema fully documents the input. The description adds nothing about the button parameter, so the baseline 3 applies.

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

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

The description names the tool ('mouseDown') and adds platform context (Windows AutoIt), so the agent knows it is a low-level mouse-press action rather than a generic click. However, it largely restates the tool name and never articulates what the action actually does (press and hold a mouse button), which is the distinction that separates it from mouseClick.

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 mouseDown instead of mouseClick, mouseUp, or mouseMove, all of which appear in the sibling list. The closest the description comes to usage context is the environment prerequisite, which is a precondition rather than a selection rule.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds the genuinely useful precondition that a trusted owner and an interactive desktop session are required, but says nothing about the returned value or failure behavior when the desktop is not interactive.

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 the environment constraint front-loaded and no filler. The only wasted token is the 'Windows AutoIt mouseGetCursor' prefix, which duplicates the name instead of describing behavior.

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 output schema, the description carries the burden of explaining the return value, and it does not — an agent cannot tell whether this yields a cursor ID, a shape enum, or coordinates. The prerequisite is disclosed, but the essential output contract 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 there is nothing for the description to clarify beyond what the empty schema shows; the baseline for a parameterless tool applies.

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

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

The description is essentially the tool name restated with a platform prefix ('Windows AutoIt mouseGetCursor') and never says what the tool actually retrieves — the current cursor shape/handle/ID. It also fails to distinguish it from the sibling mouseGetPos, which an agent could easily confuse it with.

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 statement of when to call this versus alternatives such as mouseGetPos or takeScreenshot. The only guidance is an environmental prerequisite (trusted owner, interactive Windows x64 desktop), which is context rather than usage direction.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description does add genuine non-annotation context by naming the host environment and trust requirement, but it omits anything about what is returned or rate/session constraints.

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

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

Two short sentences with no padding and the environment prerequisite front-loaded in its own clause. The opening sentence is largely redundant with the tool name, but the overall footprint is appropriately small for a trivial getter.

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

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

There is no output schema, so the description carries the burden of explaining the return value (cursor coordinates, and presumably a failure mode outside an interactive desktop) — yet it says nothing about what comes back. For a zero-param getter this is the one piece of information the agent actually needs, and it 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, and the empty object schema is fully described (100% coverage), so there is nothing for the description to clarify. Baseline 4 applies per the zero-parameter rule.

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?

"Windows AutoIt mouseGetPos" essentially restates the tool name with a platform qualifier; it never states the verb+resource outcome (e.g. "returns the current cursor position"). It also does nothing to distinguish this from the sibling mouseGetCursor, which an agent could easily confuse it with.

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 offered is a prerequisite ("Requires a trusted owner and an interactive Windows x64 desktop"), which is environment info rather than when-to-use guidance. There is no indication of when to pick this over mouseGetCursor or any other sibling, nor any exclusion cases.

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?

Annotations already cover the safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false), so the bar is lower, and the description adds real context beyond them: the call requires a trusted owner and an interactive Windows x64 desktop, which explains why it may fail. It does not describe failure behavior or coordinate frame, keeping it short of a 5.

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 identity and then the environment prerequisite front-loaded. Nothing in the text is redundant.

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

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

For a three-parameter, no-output-schema tool with annotations, the description covers the environment prerequisite but leaves out coordinate-frame semantics (absolute vs. window-relative) and any failure/timing notes. It is adequate but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents x, y, and speed (including defaults and ranges), establishing the baseline of 3. The description adds nothing about parameter semantics, such as whether x/y are absolute screen pixels or relative to a window.

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

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

The description names a specific verb+resource (mouseMove) and adds platform context (Windows AutoIt), making the action unambiguous. It does not explicitly differentiate from close siblings like mouseClickDrag or mouseDown/mouseUp, but the name plus platform identifies it clearly.

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

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

It states prerequisites for use ('trusted owner', 'interactive Windows x64 desktop'), which is genuine usage guidance, but never says when to choose this over mouseClickDrag, mouseDown/mouseUp, or how it relates to mouseGetPos. Usage is implied rather than routed.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, openWorldHint=true and non-idempotent, so the safety profile is covered. The description does add non-obvious environmental constraints (trusted owner, interactive Windows x64 desktop) that go beyond the annotations, but it omits whether the call fails silently or what happens if no button was pressed.

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, no padding, and the environment requirement is stated up front. The first sentence is largely redundant with the tool name, which keeps it from a 5.

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

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

For a one-parameter, no-output-schema tool whose safety profile is carried by annotations, the description is nearly adequate. However, an agent still lacks the key behavioral tie-in that this must pair with mouseDown and which button it releases, which is exactly the context this short description had room for.

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?

Only one optional parameter (button, with an enum and a default), and schema description coverage is 100%, so the schema fully documents it. The description adds nothing about the button semantics, which is acceptable at this baseline.

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

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

The description essentially restates the tool name ('Windows AutoIt mouseUp') rather than stating the action as a verb+resource (e.g., 'releases a previously pressed mouse button'). The name is reasonably self-describing and the sibling set (mouseDown, mouseClick) makes the family obvious, but no explicit differentiation is offered.

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 versus mouseDown, mouseClick, or mouseClickDrag, and no statement that it is meant to release a button held by mouseDown. Only environmental prerequisites are given, which is context but not 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?

Annotations already declare the safety profile (destructiveHint=true, openWorldHint=true, non-idempotent), so the description is not responsible for that. It adds two prerequisites not present in the structured data: a trusted owner and an interactive Windows x64 desktop, which is real context an agent needs before invoking. It stops short of saying which window receives the scroll (presumably the active one at the current cursor position), which is the remaining behavioral 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 the environment constraint front-loaded after the identifier, no filler or repetition. It is economical, though the first sentence is mostly a name restatement rather than an action statement.

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 full schema coverage, no output schema, and annotations covering safety, the definition is close to sufficient. However it omits where the scroll is delivered (active window vs. cursor position), which is the key operational fact for a coordinate-less input tool alongside mouseGetPos/mouseMove 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 100% with both parameters documented (clicks range 1-100, direction enum up/down), so the baseline is 3. The description adds nothing about how clicks map to scroll distance or about the target window, so it does not exceed 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?

"Windows AutoIt mouseWheel" largely restates the tool name and does not state in plain terms that it performs a scroll action. The only added information is platform/library attribution, and no sibling (mouseMove, mouseClick, mouseClickDrag) is distinguished.

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 prefer mouseWheel over mouseClick/mouseMove or over control-level alternatives such as controlSend. The environment prerequisite is stated, but no selection criteria or exclusions are offered.

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?

Annotations already declare destructiveHint=true, openWorldHint=true, and non-idempotent/non-read-only behavior. The description adds genuine context beyond them by stating the execution preconditions (trusted owner, interactive Windows x64 desktop), which matters for an AutoIt host-level call. It does not, however, say which option is mutated or what the effect/destruction is, so 3 rather than 4.

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

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

Two short sentences with no padding, which is appropriate, but the first sentence is pure tautology and earns none of its space. Structure is acceptable, content of the lead 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?

For a destructive, non-idempotent host-level mutation with no output schema, the agent needs to know what is being changed and what the response or failure mode looks like. The description supplies only environmental preconditions and leaves the core mutation semantics and return behavior 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?

Schema description coverage is 100%, so the baseline is 3. However, the schema's own text is generic ("Option name", "Option value") and the description adds nothing about which option names are valid or what range of values is meaningful, so the 3 is not exceeded.

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?

"Windows AutoIt opt" restates the tool name and resource without stating a verb or what the tool actually does to the option/value pair. It is not distinguishable from the sibling autoItSetOption, which appears to do the same conceptual job, and no agent could tell which one applies here.

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 names no when-to-use condition and never routes the agent between this tool and autoItSetOption. The only constraint given (trusted owner, interactive desktop) is an environment prerequisite, not guidance on choosing this tool.

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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered by structured data. The description adds useful environment requirements (trusted owner, interactive x64 desktop), but says nothing about what happens to the target process's data, failure when the process is absent, or confirmation behavior.

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

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

Two short, front-loaded sentences with no filler. It is efficient, though extremely terse rather than maximally informative.

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

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

For a one-parameter tool with annotations covering safety and no output schema, the description is minimally adequate. It omits error behavior when the process does not exist and does not reinforce that the operation is destructive and non-idempotent beyond what annotations already state.

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

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

Schema coverage is 100% for the single 'process' parameter, so the schema already defines it as 'Process name or executable path'. The description adds no semantics such as matching rules, case sensitivity, or path-vs-name behavior, so the baseline of 3 applies.

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

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

The description essentially restates the tool name ("Windows AutoIt processClose") without an explicit verb like "terminates" or "kills". The Windows-x64-desktop qualification adds platform scope, but no distinction from close cousins such as winClose, runWait, or shutdown is offered.

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

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

It states a prerequisite (trusted owner, interactive desktop) but gives no guidance on when to use processClose versus alternatives like winClose, shutdown, or processWaitClose. The agent must infer usage 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuine context beyond that — the trusted-owner and interactive Windows x64 desktop prerequisite — which is useful, but it omits what the tool returns (presumably a boolean) and any failure behavior.

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

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

Two tight sentences with no filler; the environment prerequisite is placed where it will be read. The opening sentence is somewhat redundant with the tool name, keeping it just below the top band.

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

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

For a one-parameter read-only check with full schema coverage and rich annotations, the essentials are covered. However, it never states the return value (existence boolean vs. handle) and gives no guidance relative to sibling process tools, leaving moderate gaps.

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

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

Schema description coverage is 100%, with the single 'process' parameter documented as 'Process name or executable path'. The description adds no meaning beyond the schema, so the baseline 3 applies.

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

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

The description largely restates the name: 'Windows AutoIt processExists'. The name itself conveys the verb+resource (check whether a process exists), so purpose is inferable, but the description adds only a platform qualifier and does not distinguish this from siblings like processWait, processWaitClose, or processClose.

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 versus the many related process siblings (processWait, processWaitClose, processClose). The stated precondition about a trusted owner and interactive desktop is an environmental requirement, not usage guidance or an alternative-selection rule.

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?

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the mutation risk is covered. The description does add non-annotation context — the trusted-owner requirement and the need for an interactive Windows x64 desktop — but says nothing about what happens to a process that does not exist, whether the change is reversible, or failure behavior.

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

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

Two short sentences with no filler, but the first sentence ('Windows AutoIt processSetPriority') duplicates the name instead of front-loading useful information. Structure is fine; content density is low.

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 destructive mutation tool with no output schema, the description covers the environmental prerequisite but omits the practical essentials an agent needs — valid priority semantics, behavior when the target process is absent, and what the call returns or throws. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so both parameters (process, priority) are already documented and the baseline is 3. The description adds no parameter meaning at all and notably does not reconcile the schema's 'Priority level (0-4)' hint with the much wider declared integer range.

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 leads with 'Windows AutoIt processSetPriority', which largely restates the tool name rather than articulating the action in plain terms (e.g., 'changes the scheduling priority of a running process'). The name is self-describing enough that an agent can infer the purpose, but the description itself adds only platform context, not a clearer verb+resource statement.

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

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

No guidance is given on when to use this tool versus siblings like processExists, processClose, or run. The statement about a 'trusted owner' and 'interactive Windows x64 desktop' is a precondition, not a when-to-use rule, and no alternatives or exclusions are named.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description usefully adds the environment requirement (trusted owner, interactive Windows x64 desktop), which is real context not in the annotations, but it omits blocking behavior and what happens when the timeout elapses.

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

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

Two short sentences, front-loaded with the operation and then the prerequisite, with no filler. Only minor fault is the compressed phrasing that assumes the reader knows the AutoIt function semantics.

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 output schema and only two fully documented parameters, the structured fields do most of the work, and annotations cover the safety profile. Still missing is the blocking/timeout outcome an agent needs to handle the call correctly, which matters for a wait-style tool capped at 25 seconds.

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

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

Schema coverage is 100% and both parameters carry their own descriptions including the 1-25 second bound and default of 10. The description adds nothing about parameter meaning or interaction between process name/path and timeout, so the baseline 3 applies.

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

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

The description names the library operation ('Windows AutoIt processWait') and the platform, so an agent can infer it waits for a process. However, 'processWait' is essentially a restatement of the tool name, and it never clarifies that it blocks until the named process starts, which is the key distinguishing behavior versus siblings like processExists and processWaitClose.

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

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

It states an environment prerequisite (trusted owner, interactive Windows x64 desktop) but gives no guidance on when to choose this over processExists, processWaitClose, or runWait, all of which sit in the same sibling cluster. No when-not-to-use or 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds environment/auth requirements (trusted owner, interactive Windows x64 desktop) beyond annotations, but omits blocking semantics, timeout behavior, and what happens on timeout.

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

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

Two short sentences with no filler, front-loading the identifier and the key prerequisite. It is efficient, though the terseness contributes to the specification gaps noted elsewhere.

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 no output schema, the description never explains that it blocks until the process exits or what the return behavior is on timeout. The prerequisite note alone is not enough to call this tool correctly.

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

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

Schema description coverage is 100%; both process and timeout are fully documented in the schema including range (1-25) and default (10). The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

The description is essentially the tool name plus platform ("Windows AutoIt processWaitClose"); it never states the action in plain terms (waits for a process to close) and does not distinguish from siblings like processWait or winWaitClose. This is a tautological restatement of the name, which the rubric scores as 2.

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

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

It gives only a prerequisite ("Requires a trusted owner and an interactive Windows x64 desktop") rather than when-to-use guidance. There is no indication of when this should be chosen over processWait, winWaitClose, runWait, or the other wait/close 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?

Annotations already declare destructive=true, openWorld=true, non-idempotent, and non-read-only, so the safety profile is covered. The description adds genuinely new context beyond that: the requirement for a trusted owner and an interactive Windows x64 desktop, which are real preconditions an agent must satisfy before calling.

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 platform/precondition framing comes first. It is appropriately sized, though the opening 'Windows AutoIt run' is clipped rather than a clean statement of purpose.

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

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

For a destructive, open-world execution tool with several near-identical siblings, the description is thin: it does not say whether the call blocks or returns a handle, what result (if any) comes back, or how it relates to runWait/runAs. It covers prerequisites but leaves the run-variant distinction and return behavior unaddressed.

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

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

Schema description coverage is 100%, so program, showFlag, and workingDir are already documented in the schema. The description adds no syntax, format, or interaction detail beyond that, so the baseline 3 for schema-driven parameters applies.

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

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

The phrase 'Windows AutoIt run' plus the required 'program' parameter implies the tool launches an executable or command on Windows, so the purpose is inferable. However, it never states the verb+object plainly (e.g. 'executes a program') and gives no indication of how it differs from sibling 'runWait', 'runAs', or 'runAsWait'.

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, even though the sibling set contains runWait, runAs, and runAsWait, which encode meaningful scheduling and identity choices. An agent gets no help deciding which 'run' variant to pick.

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?

Annotations already declare destructiveHint=true, openWorldHint=true, and non-idempotent, covering the safety profile. The description adds a genuinely useful runtime constraint (trusted owner + interactive x64 desktop) not present in annotations, but says nothing about credential handling or what happens to the spawned process.

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

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

Two short sentences with no filler, and the identifying phrase is front-loaded before the precondition. It is efficient, though its brevity borders on under-specification rather than tightness.

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 7-parameter mutation tool with no output schema, the description covers the environmental prerequisite but omits the core action, failure modes, and the semantics of logonFlag/showFlag. The schema carries parameter detail and annotations carry safety, so it is minimally adequate.

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

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

Schema description coverage is 100%, so all seven parameters (user, domain, password, program, logonFlag, showFlag, workingDir) are already documented in the schema. The description adds no parameter meaning, so the baseline of 3 applies.

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

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

'Windows AutoIt runAs' identifies the mechanism and implies executing as another user, but it never states an explicit verb+resource phrase (e.g. 'runs a program under a different user account'). It also fails to distinguish this tool from close siblings like run, runWait, and runAsWait.

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 supplies a precondition ('Requires a trusted owner and an interactive Windows x64 desktop') but gives no when-to-use guidance and never contrasts runAs with run, runWait, or runAsWait. An agent is left to infer when this is the right tool.

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?

Annotations already declare destructive=true, openWorld=true, readOnly=false, and idempotent=false. The description adds the platform and interactivity/owner prerequisites, which is context beyond annotations, but it does not clarify what gets destroyed, how credentials are used, or what waiting behavior to expect. With annotation coverage already carrying the safety profile, a 3 is appropriate.

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

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

The description is two terse sentences with no filler and is front-loaded with the tool name. It is efficient, though it is under-specified rather than being a model of informative 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?

This is a destructive, open-world credential-using tool with seven parameters, five required, and no output schema. The description covers only platform and environment prerequisites, omitting wait semantics, credential handling, and any indication of return behavior, which is insufficient for the tool's complexity.

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

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

Schema description coverage is 100%, so all seven parameters (including user, domain, password, logonFlag, program, showFlag, workingDir) are already documented in the schema. The description adds no parameter-level syntax, format, or value guidance, so the baseline of 3 applies.

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

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

The description restates the tool name and platform ("Windows AutoIt runAsWait") but does not state the actual operation, such as launching a program under alternate credentials and blocking until it exits. It leaves the agent to infer the verb from the name alone and does not differentiate from siblings run, runWait, or runAs.

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 explicit when-to-use guidance or named alternatives among run/runWait/runAs are given. The statement about a trusted owner and interactive desktop is a prerequisite/constraint, not routing guidance for choosing this tool over its siblings.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description adds a genuine precondition (trusted owner, interactive x64 desktop) not present in structured data, but says nothing about blocking behavior, exit codes, or what the launched process can affect.

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, no padding, with the platform scope front-loaded before the environment precondition. Efficient, though it is concise at the cost of substance rather than because it efficiently conveys a lot.

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 destructive, non-idempotent launch tool with no output schema, the description covers the environment requirement but omits the defining behavior (waiting for termination) and any return/exit-code expectations. Adequate as a minimum but leaves real gaps.

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

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

Schema description coverage is 100%, with program, showFlag, and workingDir all documented in the schema itself. The description adds no parameter meaning beyond that, which matches the baseline 3 when the schema does the work.

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?

"Windows AutoIt runWait" largely restates the tool name and gives platform context, but never states the actual behavior (runs a program and blocks until it exits). It does not differentiate from siblings run, runAs, or runAsWait, so an agent must infer the blocking semantics from the name 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?

There is no when-to-use guidance and no mention of alternatives like run (non-blocking) or runAsWait. The only stated condition, "requires a trusted owner and an interactive Windows x64 desktop," is an environmental prerequisite rather than routing guidance.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true and idempotentHint=false, so the risk profile is covered structurally. The description adds genuinely useful behavior beyond that: an ownership/trust prerequisite and the need for an interactive Windows x64 desktop session. It omits the most important behavioral fact for a destructive tool, namely that input is delivered to whatever currently has focus and can therefore land in the wrong window.

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 very short sentences, front-loaded with the operation and followed by the environment requirement; 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?

There is no output schema to explain and annotations cover the safety profile, so the bar is moderate. However, for a destructive input-injection tool the description leaves the target of the keystrokes (focused window) and the 'mode' flag semantics unaddressed, which is a meaningful gap for calling 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 100% with only two parameters ('mode' Send mode flag, 'text' text or keys to send), so the schema carries the parameter burden and baseline 3 applies. The description adds nothing about the meaning of the 'mode' flag or the AutoIt key/modifier syntax that 'text' accepts.

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 'Windows AutoIt send' mostly restates the tool name plus a platform qualifier; it never states that this injects keystrokes/text into the focused window, which is the actual operation. It does at least anchor the tool to the AutoIt Send primitive and to Windows, but it offers no differentiation from the sibling controlSend, which sends to a specific control instead.

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

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

The description gives a prerequisite ('Requires a trusted owner and an interactive Windows x64 desktop') but no when-to-use guidance, no when-not conditions, and no pointer to alternatives such as controlSend or controlSetText for targeting a specific control. An agent still has to guess whether this is the right tool versus its many send/window 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?

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the risk profile is covered. The description adds real value by naming the environment requirements (trusted owner, interactive desktop), but it says nothing about what the shutdown actually does, whether it can be cancelled, or how failures surface.

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

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

Two short sentences with no padding, and the effective constraints are front-loaded. It is efficient, though the terseness contributes to the missing detail noted elsewhere.

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 destructive, non-idempotent, open-world tool with no output schema, the description covers the environment gate but omits what happens on success/failure and what the flags integer means. Adequate as a minimum-viable definition, not sufficient for confident invocation.

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

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

Schema description coverage is 100%, so the single 'flags' parameter is nominally documented, but both the schema text ('Shutdown flags') and the description are tautological. The integer is effectively opaque (no enum, no EWX_* examples), so the description fails to compensate for a semantic gap it is well positioned to fill; the 100% coverage baseline keeps this at 3 rather than lower.

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 "Windows AutoIt shutdown" names the action and platform but reads as a restatement of the tool name rather than a specific verb+resource statement (e.g. 'initiates a system shutdown/restart on the local Windows host'). It is clear enough that the tool touches shutdown behavior, but an agent gets no scope detail such as whether it shuts down, restarts, or logs off.

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 supplies prerequisites ('trusted owner', 'interactive Windows x64 desktop'), which is genuine pre-call context, but it never says when to use this tool versus doing nothing or using processClose/run siblings. Usage is implied by the prerequisites rather than stated with exclusions.

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

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

The annotations already declare this a safe, idempotent, non-destructive read operation with openWorld behavior. The description adds genuine context beyond them — it requires a trusted owner and an interactive desktop session — which an agent needs to know before calling. It stops short of describing failure modes or what happens when no interactive desktop exists.

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, prerequisite front-loaded after the identifying clause, zero padding. Slightly redundant in restating the tool name, but appropriately sized for the content it chooses to convey.

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?

No output schema, six undocumented parameters, and no mention of return format (path? bytes? image handle?). For a tool with 0% schema description coverage, the description should carry far more burden than two sentences about the environment.

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?

Six parameters with 0% schema description coverage and no parameter information in the description at all. The names (x, y, width, height, target, windowTitle) are largely self-explanatory and the target enum is self-documenting, which prevents a 1, but the description does nothing to clarify how region coordinates interact with target or when windowTitle applies.

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

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

"takeScreenshot" is a specific verb+resource, and "Windows AutoIt" adds platform context. It is clearly distinguishable from all siblings, none of which capture screens. It does not, however, say what is captured (screen, window, region) — that is left entirely to the schema.

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

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

The description states an environment prerequisite (trusted owner, interactive Windows x64 desktop) but gives no when-to-use guidance, no exclusions, and no routing to alternatives. Since no sibling captures screenshots, the omission is less costly, but it is still 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?

The annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered structurally. The description contributes the trusted-owner and interactive-desktop prerequisites, which are real added context, but says nothing about duration, blocking, or cleanup of the tooltip. Nothing contradicts the annotations.

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 platform and prerequisites front-loaded and zero padding. It is efficient, though arguably under-specified rather than genuinely concise.

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

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

For a simple 3-parameter UI tool with full schema coverage and no output schema, the description is minimally adequate: it names the platform and prerequisites. It would benefit from noting whether the call blocks, the tooltip's lifetime, and any return/handle, which is a meaningful gap for a UI-mutating call.

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

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

Schema description coverage is 100%, so x, y, and text are already documented in the schema, making 3 the baseline. The description adds no coordinate format, default position behavior, or text handling detail beyond the schema's 'Tooltip text' and 'X/Y coordinate' notes.

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 'Windows AutoIt toolTip', which identifies the resource but mostly restates the tool name rather than giving a specific verb like 'display a tooltip at coordinates'. An agent can infer it shows a tooltip on a Windows desktop, but the phrasing is close to tautology. No sibling in the list offers tooltips, so no differentiation is required.

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?

'Requires a trusted owner and an interactive Windows x64 desktop' gives an environmental prerequisite for when this can run, which is useful context. However, it offers no guidance on when to prefer this over alternatives (none exist) or any exclusion conditions beyond the desktop requirement.

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?

Annotations already declare destructiveHint=true and openWorldHint=true the safety profile, so the bar is lower. The description still adds value by disclosing environmental prerequisites (trusted owner, interactive Windows x64 desktop), which annotations do not convey. It does not explain what activation does or what happens when the target window is not found, so it is adequate but not rich.

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, no padding, so nothing is wasted. However, the leading sentence merely repeats the tool name rather than front-loading actual behavior, so brevity here reflects under-specification as much as efficiency.

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?

No output schema exists, so the description must stand alone, and for a simple 2-param tool with annotations covering the safety profile the environmental prerequisite note is useful. It still omits what activation actually does and failure behavior, 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 description coverage is 100%, so 'title' (required) and 'text' are already documented in the schema. The description adds no parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description essentially restates the tool name ('Windows AutoIt winActivate') without stating that it brings a window to the foreground or otherwise activating it. It adds only a library/runtime hint ('Windows AutoIt'), and given the sibling winActivateByHandle exists, it fails to differentiate the two. This is close to tautology.

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

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

The description gives prerequisites ('requires a trusted owner and an interactive Windows x64 desktop') but no when-to-use guidance and no routing to the obvious alternative winActivateByHandle (title vs handle). An agent cannot infer from this text which activation tool to pick.

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?

Annotations already declare destructiveHint=true, openWorldHint=true, and non-idempotent, so the agent knows this can alter system state. The description adds the environment/target-window context ('trusted owner', interactive x64 desktop), which is genuinely useful beyond the annotations, but doesn't disclose what activation actually changes (focus, z-order, foreground 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?

Extremely short, but it front-loads a restatement of the name rather than the useful constraint. The valuable content ('trusted owner', 'interactive Windows x64 desktop') is buried in the second clause.

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 destructive, open-world mutation tool with no output schema, the description is too thin. It should explain what 'activate' does (focus/foreground), what happens on failure, and how it relates to winActivate, none of which are covered.

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

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

Schema description coverage is 100%, so the single 'handle' parameter is fully documented in the schema and the description adds no syntax or format detail. Baseline applies per the coverage rule.

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 restates the tool family ('Windows AutoIt winActivateByHandle') without explaining what activation means or doing distinct work. It relies on the name to convey purpose. The sibling winActivate exists, so the 'ByHandle' variant should be distinguished, but the description never contrasts them.

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

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

It names one environmental precondition ('trusted owner', 'interactive Windows x64 desktop') but never states when to use this over the sibling winActivate or winActive. No when/when-not guidance and no explicit alternative selection.

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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description does add genuine context beyond the structured fields by stating the tool needs a trusted owner and an interactive Windows x64 desktop, but it omits the return semantics (presumably a boolean active/not-active result).

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 short (two sentences) and front-loaded, so it is not bloated. However, the first "sentence" is pure restatement of the name and earns little, making the brevity a symptom of under-specification rather than efficiency.

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 query-style tool with no output schema, the description should convey the return value (whether the window is active) and matching behavior, but it does neither. It leaves the agent unable to predict the result format, which is a meaningful gap for such a 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 100% for both title and text parameters, so the schema fully documents the inputs. The description adds nothing about parameter meaning or matching semantics (e.g., substring vs exact title match), so the baseline 3 applies.

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

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

"Windows AutoIt winActive" effectively restates the tool name and library rather than stating what the tool does. It never says it checks whether a named window is currently active, so an agent cannot distinguish it from siblings like winActivate, winExists, or winWaitActive from the 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?

There is no when-to-use guidance and no alternatives named, despite a dense cluster of closely related window tools (winActivate, winExists, winWaitActive). The description gives only a prerequisite (environment) and leaves selection 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds a genuine environmental constraint (trusted owner, interactive desktop), which is useful context beyond the annotations, but says nothing about failure behavior when no matching window exists.

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 clauses with no wasted words, and the tool identity is front-loaded. The brevity is close to under-specification rather than excess, so it is efficient but not exemplary.

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 destructive, non-idempotent window-mutation tool with no output schema, the description omits return values, behavior when no window matches, and how title/text matching works. The prerequisite clause alone does not make it complete enough to call 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 100%, so both title and text parameters are already documented in the schema. The description adds no matching semantics (exact vs partial title, regex, case sensitivity) beyond what the schema provides, so the baseline of 3 applies.

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

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

"Windows AutoIt winClose" essentially restates the tool name and function identifier without explaining in plain terms what the tool does (close a window matching title/text). No differentiation from siblings like winWaitClose, winSetState, or winActivate, which also act on windows. The only added content is a prerequisite clause, not a purpose statement.

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

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

No when-to-use, when-not-to-use, or alternative guidance is given. The description states an environment precondition (trusted owner, interactive Windows x64 desktop) but never tells the agent when to reach for winClose versus winWaitClose or winSetState.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description does add genuine non-schema context — the trusted-owner requirement and the interactive Windows x64 desktop prerequisite — which is real behavioral value, though it says nothing about the return value or platform failure modes.

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

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

Two short sentences with no padding, and the environment prerequisite is front-loaded. However, the first sentence is a near-tautology that spends words without conveying information, so it is not maximally economical.

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

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

For a simple two-parameter boolean-style predicate this is close to adequate, and annotations cover the safety profile. But with no output schema, the description never states what the tool returns (a boolean existence result vs. a handle), which is the single most important thing an agent needs here.

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

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

Schema description coverage is 100%, with both 'title' (required) and 'text' documented in the schema, so the schema carries the semantic load. The description adds nothing about matching semantics (exact vs. substring/optional text) that would go beyond the schema, so the baseline 3 applies.

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

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

The description essentially restates the tool name — 'Windows AutoIt winExists' adds only platform context, not a verb+resource explanation of what the call accomplishes (presumably checking whether a matching window is currently open). It does nothing to separate this from siblings like winActive, winWait, winGetTitle, or winGetHandle that also take a title/text pair.

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 at all: nothing says to call winExists before winActivate/winClose, nor how it differs from winActive (which tests the foreground window) or winWait (which blocks). The agent must infer the selection criteria 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuine environmental context — a trusted owner and an interactive Windows x64 desktop session are needed — which is not derivable from the annotations. It stops there, though: no note on what happens if the window is absent or ambiguous.

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?

Very short and front-loaded, so it is not bloated, but the first sentence earns nothing — it repeats the name and namespace. Only the second sentence carries information, meaning roughly half the text is waste in an already tiny description.

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 output schema, the description should say that a window handle is returned (and what form it takes), since that is the entire point of the tool; instead it is silent. Annotations and full schema coverage carry the rest, so the definition is not inadequate, but it stops short of complete for a lookup whose return value matters.

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

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

Schema description coverage is 100% (both `text` and `title` are documented), so the schema carries the parameter burden and baseline 3 applies. The description adds no matching semantics, and notably does not explain the relationship or precedence between title and text when both are supplied.

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?

"Windows AutoIt winGetHandle" is essentially a restatement of the tool name and namespace, not a statement of what the tool does. An agent must infer from the name and the sibling set (winGetTitle, winGetPos, winGetText, controlGetHandle) that this retrieves a window handle. No verb, no output object, no scope is given.

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 a prerequisite ("Requires a trusted owner and an interactive Windows x64 desktop"), not when-to-use guidance. Nothing distinguishes it from winGetTitle/winGetPos or explains when a handle is preferable to a title string, which is the central selection question among these 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. The description adds useful runtime context (trusted owner, interactive desktop), but does not explain return values, error behavior, or other operational traits.

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

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

The definition is short, but its first sentence is a redundant restatement of the name and does not earn its place. The second sentence carries all the useful content, leaving the overall structure under-specified rather than concise.

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

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

For a read-only getter with no output schema, the description should clarify what is returned (e.g., window coordinates or handle) and how it relates to sibling position tools like mouseGetPos or controlGetPos. It provides only environment prerequisites and omits this essential context.

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

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

Schema description coverage is 100%, so both the required window title and optional window text parameters are already documented in the schema. The description adds no parameter-specific meaning beyond that, making the baseline 3 appropriate.

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

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

The description mostly restates the tool name ("Windows AutoIt winGetPos") without stating the action or resource explicitly. It does not say that it retrieves a window's position or how that differs from sibling getters like winGetTitle or winGetHandle.

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

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

It gives a prerequisite — a trusted owner and an interactive Windows x64 desktop — but no guidance on when to choose this tool over alternatives or when it should not be used. Conditions for selection versus siblings are entirely 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?

Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior, so the safety profile is covered. The description's added value is the environment prerequisite ("trusted owner and an interactive Windows x64 desktop"), which is genuine operational context, but it says nothing about return format or how text is sourced.

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?

Very short and front-loaded, with no wasted clauses. It is efficient, though the leading "Windows AutoIt winGetText" is somewhat redundant with the tool name 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?

For a simple read operation with rich annotations and full schema coverage, the environment note is helpful but the definition still omits what the call actually returns and how it relates to sibling getters, leaving meaningful gaps for an agent choosing among window/control text 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?

Schema description coverage is 100%, so text, title, and bufSize are each already documented in the schema. The description adds no syntax, format, or usage detail beyond that, making the baseline 3 appropriate.

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

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

"Windows AutoIt winGetText" largely restates the tool name rather than describing the action in plain terms. It never states that it retrieves the text of a window/control, and does not distinguish it from close siblings like winGetTitle or controlGetText.

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, when-not-to-use, or alternative selection guidance is given. The environment prerequisite (trusted owner, interactive x64 desktop) is a constraint, not usage routing, and nothing tells the agent when to pick this over controlGetText.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds the genuinely useful constraint that a trusted owner and interactive Windows x64 desktop are needed, which is not in the annotations — but it says nothing about failure modes, matching behavior, or return content.

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

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

Two short sentences with no padding, but the first spends its words echoing the tool name instead of front-loading actual purpose. It is brief yet under-specified rather than efficiently concise.

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

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

For a getter with no output schema, the description should at minimum say it returns the matching window's title string and how title/text combine in matching. It omits both, leaving the agent to infer return type and lookup semantics from the name alone.

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

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

Schema description coverage is 100%, with each of title, text, and bufSize documented inline, so the schema carries the parameter burden. The description adds no semantics beyond that (e.g., what happens when title matches multiple windows), so the baseline 3 applies.

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

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

The description opens by restating the tool name ("Windows AutoIt winGetTitle") without ever stating what the operation does — that it retrieves a window's title. An agent must infer the verb+resource entirely from the name, and nothing distinguishes it from sibling getters like winGetText, winGetHandle, or winGetPos.

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

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

It states a precondition ("Requires a trusted owner and an interactive Windows x64 desktop") but gives no guidance on when to pick this over winGetText, winGetHandle, or winGetPos, nor when-not to use it. There are no alternative routing cues despite a crowded window-access sibling set.

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?

Annotations already declare destructiveHint=true, openWorldHint=true, readOnlyHint=false and idempotentHint=false, so the mutation/open-world profile is covered. The description does add a genuine environmental constraint not present in structured data (trusted owner + interactive x64 desktop), but it says nothing about what state changes, what happens to an unmatched window title, or failure behavior.

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

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

Two short sentences with no filler, and the environmental prerequisite is front-loaded. It is efficient, though the brevity comes at the cost of stating the actual operation.

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 6-parameter, destructive, non-idempotent window-manipulation tool with no output schema and no annotations covering environment, the description is too thin. It omits the core action, the interaction of the optional width/height parameters, and any failure or permission semantics beyond the trusted-owner note.

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

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

Schema description coverage is 100%, so title, text, x, y, width and height are already documented in the schema. The description adds nothing about parameter meaning, such as whether width/height are optional resize values or how title/text matching works, so the baseline 3 applies.

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

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

"Windows AutoIt winMove" only restates the tool name; the description never explicitly says it moves (and optionally resizes) a window on the desktop. An agent can infer the action from the name, but there is no differentiation from siblings like controlMove, winSetState, or winActivate, which are all window/position related.

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

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

The description gives no when-to-use guidance and names no alternatives. It does not explain when to prefer winMove over controlMove, winSetState, or winActivate, nor does it mention that the target window must already exist.

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?

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false and openWorldHint=true, so the mutation profile is covered. The description adds genuine value by stating the auth requirement (trusted owner) and platform requirement (interactive Windows x64 desktop), which the annotations don't convey. It stops short of saying what state change is applied or whether it is reversible.

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

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

Two short sentences with no padding, so it is concise, but the first sentence is a wasted tautology and the second carries all the content. Efficient in size yet poorly front-loaded.

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

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

For a destructive, non-idempotent window mutation with no output schema, an agent needs to know what state flags do and what the effect is. The description supplies only environment preconditions and omits the core behavioral semantics, leaving a real gap.

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

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

Schema description coverage is 100% (title, text, flags all documented in the schema), so the baseline is 3. The description adds nothing about the flags bitmask — the most semantically important parameter — leaving its meaning entirely to the terse "State flags" schema text.

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?

"Windows AutoIt winSetState" restates the tool name and its library origin rather than describing what the tool does. It never says it changes a window's display state (show/hide/minimize/maximize/restore), so an agent gets no verb+resource explanation and cannot distinguish it from winMove, winActivate, or winClose.

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 a precondition ("Requires a trusted owner and an interactive Windows x64 desktop"), which is context, not when-to-use. There is no mention of when to prefer winSetState over siblings like winActivate or winShow, nor any exclusions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds real environmental prerequisites (trusted owner, interactive Windows x64 desktop) that the annotations don't convey. It does not disclose blocking/polling behavior, whether it throws or returns on timeout, or what a match yields.

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, appropriately sized and front-loaded. However the first sentence is a tautological restatement of the name and earns no place, so the economy comes partly from under-specification rather than tight writing.

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

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

For a blocking wait tool with no output schema, the description never says whether it blocks until the window appears, what happens on timeout, or what it returns (handle, boolean, or error). Given no output schema exists to carry that load, the description leaves a significant behavioral gap for an agent deciding how to sequence winWait in a script.

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

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

Schema description coverage is 100%, so title, text, and timeout are already documented including the 1-25 second range and default. The description adds nothing about parameter semantics; baseline 3 applies.

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

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

"Windows AutoIt winWait" restates the tool name rather than describing the operation; the agent must already know AutoIt semantics to infer that it waits for a window to appear. With siblings winWaitActive and winWaitClose present, no differentiation between the three wait variants is offered.

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 winWait versus winWaitActive, winWaitClose, or winExists; the agent is left to infer the distinction from AutoIt knowledge alone. The environment prerequisite (interactive desktop) is stated, which is context but not usage selection guidance.

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

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

Annotations already provide the safety profile (readOnly, idempotent, non-destructive, open-world), and the description usefully adds the runtime precondition of a trusted owner on an interactive x64 desktop. However, it omits the core behavioral trait of a wait tool: it blocks until the window is active or the timeout elapses, and it doesn't say what the call yields.

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?

Very short and front-loaded, which is good, but the "Windows AutoIt winWaitActive" fragment merely echoes the name and does not earn its place. It is concise to the point of under-specification rather than genuinely efficient.

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

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

With no output schema, the description must explain the return value and wait semantics, but it says nothing about what happens on success, on timeout, or what is returned. For a blocking wait tool with three parameters, the definition is materially 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 100% (title, text, timeout all documented with default and range), so the schema carries parameter meaning. The description adds nothing about how title/text matching works or how timeout interacts with the wait, leaving the baseline 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?

"Windows AutoIt winWaitActive" largely restates the tool name rather than explaining what it does. It never states the actual verb+resource (waits until a window becomes active) nor distinguishes it from siblings like winWait, winWaitClose, winActivate, or winActive.

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 the many adjacent window-wait tools (winWait, winWaitClose, winActive). The environment precondition (trusted owner, interactive Windows x64 desktop) is the only contextual hint and is a prerequisite, not usage direction.

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?

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered. The description does add non-obvious operational context — that a trusted owner and an interactive desktop session are required — but omits the key blocking semantics and what happens when the 1-25s timeout elapses.

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 sentences, the identifier first and the precondition second, with zero filler. It is terse rather than padded, though the brevity borders on under-specification.

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 output schema, the description should explain that this is a blocking wait and what a completed/failed wait returns, which it does not. The environment requirement is a useful addition, but the timeout outcome and blocking nature remain unexplained for a 3-parameter 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 100%, so title, text, and timeout are already documented with ranges and defaults in the schema. The description contributes no additional parameter meaning such as how title vs text matching is performed or how timeout failure surfaces.

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 largely restates the tool name ("Windows AutoIt winWaitClose") rather than stating in plain terms that it blocks until the named window disappears. The AutoIt context hints at the behavior, but the agent must infer the verb+resource, and nothing distinguishes it from siblings like winWait, winWaitActive, or processWaitClose.

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

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

It gives an environment precondition (trusted owner, interactive Windows x64 desktop) but no guidance on when to choose this over winWait or winWaitActive, nor when waiting on a window is preferable to polling winExists. No exclusions or alternative routing are offered.

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