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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool clears recorded actions, implying a destructive operation, but does not mention whether this action is irreversible, whether it also stops recording, or whether any confirmation is required. This is a significant gap for a potentially destructive tool.

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

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

The description is a single, compact sentence with no wasted words. The verb and object are front-loaded, and every word contributes to meaning.

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

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

The tool is simple (no parameters, no output schema), so a short description can be adequate. However, the absence of any behavioral caveats (e.g., irreversibility, effect on current recording session) leaves the agent without context that is typically important for a clearing/reset operation. A slightly expanded description would be more complete.

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

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

The tool has zero parameters and the input schema covers 100% of the parameter space, so the baseline is 4. The description correctly adds no parameter details because there are none to explain.

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

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

The description states a specific verb ('Clear') and a specific resource ('all recorded test actions'), making the tool's purpose immediately obvious. It is distinct from sibling tools like Start-Recording-Tool, Stop-Recording-Tool, and Export-Test-Script, which perform different operations on the same recording context.

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 about when to use this tool versus its siblings. The description does not mention prerequisites, whether clearing affects an ongoing recording, or any scenario where an alternative tool such as Stop-Recording-Tool or Get-Recording-Stats-Tool would be more appropriate.

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

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

Since no annotations are provided, the description carries the burden of behavioral disclosure. It does reveal that coordinates are resolved internally and that this is safer than Click-Tool. But it does not mention the reliance on fresh State-Tool output, the mutating nature of the tap, or possible 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?

The description is two sentences with no filler. It front-loads the core action and source of the label, then provides the safety comparison to the alternative without redundancy.

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

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

For a simple one-parameter tool, the description covers the source of the label, the alternative tool, and the safety benefit. It is mostly complete, though it could mention the need to call State-Tool first more explicitly and clarify what happens if the label is stale or invalid.

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

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

Schema coverage is 0%, and the schema only shows that 'label' is an integer. The description adds crucial meaning by explaining that label is an index from the most recent State-Tool output. It still leaves minor details unspecified, such as whether the index is zero-based.

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

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

The description clearly states a specific action ('Tap'), a resource ('an element'), and the distinguishing mechanism ('label index from the most recent State-Tool output'). It also explicitly contrasts itself with Click-Tool, so an agent can differentiate it from sibling tools.

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

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

The description gives a clear prerequisite: use a label from the most recent State-Tool output. It also names Click-Tool as the alternative and explains why this tool may be safer. However, it does not explicitly state when to prefer Click-Tool instead, such as when coordinates are the only available reference.

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

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

No annotations are provided, so the description carries the disclosure burden. It clearly communicates a tap action at exact coordinates, but does not describe side effects, prerequisites, or what happens after the tap. For a simple input tool this is adequate, though more behavioral context could be added.

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. The core action is front-loaded, and the routing guidance is placed second. Every phrase earns its place.

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

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

For a two-parameter, no-output-schema tool, the description covers the essential information: what it does, how parameters relate to coordinates, and when to use a sibling instead. Minor omissions like coordinate origin or missing coordinate behavior prevent a perfect score.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaningful semantics by identifying x and y as pixel coordinates, clarifying that these are screen-space positions rather than logical labels. It does not detail origin or bounds, but the core meaning is clear.

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

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

The description states a specific verb ('Tap') and resource ('exact (x,y) pixel coordinates'), and immediately distinguishes the tool from Click-By-Label by mentioning the alternative. This makes its function unambiguous relative to siblings.

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 explicitly states when to prefer an alternative: 'Prefer Click-By-Label when you have a label index from State-Tool.' This provides a clear when-not condition and names the alternative 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It is transparent about the gesture shape ('Drag from (x1,y1) to (x2,y2)') and the fixed duration (500ms), which are the key behavioral traits for this tool. It does not specify coordinate-space assumptions, but for a straightforward UI gesture this is a minor omission rather than a serious gap.

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

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

The description is exactly two short sentences with no redundancy. The first sentence front-loads the action and duration, and the second lists the practical use cases. Every word earns its place.

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

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

The core action, duration, and use cases are present, and the parameter roles are derivable from the 'from/to' phrasing. However, it lacks coordinate-space or unit information, does not mention any preconditions or side effects, and does not explicitly distinguish this tool from the sibling Swipe-Tool. These gaps leave the description slightly incomplete, though not unusable.

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

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

Schema description coverage is 0%, so the description must add meaning to the four integer parameters, and it does: 'from (x1,y1) to (x2,y2)' maps x1/y1 to the start point and x2/y2 to the end point. This relational meaning is valuable beyond the bare schema titles. It does not state units or coordinate space, but all four parameter roles are clarified.

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 with a specific verb ('Drag') and a precise resource/coordinate range ('from (x1,y1) to (x2,y2)'), making the core action immediately clear. It also provides concrete use cases such as reordering, moving items, and adjusting sliders. However, it does not explicitly contrast with sibling tools like Swipe-Tool, so it stops short of full sibling differentiation.

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

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

The description explicitly states the intended use cases: reordering, moving items, or adjusting sliders. This gives the agent clear context for when to select this tool. It does not name alternatives or provide exclusion criteria, but the context is clear enough to avoid confusion with click or typing tools.

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

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

With no annotations, the description carries the full burden, and it does add useful output-behavior details such as the python default being a simple replay script and pytest including assertions. However, it does not disclose whether a file is written, whether files can be overwritten, or what the invocation returns.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the core purpose and format variants compactly.

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, and the description does not describe return values, file output behavior, or the effect of the optional filename and test_name parameters. An agent would need to make unsafe assumptions 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 0%, so the description must compensate. It explains the format parameter and its default, but filename and test_name are left entirely unexplained, both in the schema and in the description.

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

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

The description uses a specific verb+resource construction: 'Export recorded test actions as executable test script.' It names the output type and supported formats, which clearly distinguishes it from sibling recording and interaction tools.

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

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

It establishes the context: this is for recorded test actions, so the agent can infer it should be used after recording rather than during capture. It does not explicitly name alternatives, but no sibling tool fulfills this export role.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a read-only intent via 'Get,' but it does not explain what statistics are included, whether the tool is a snapshot or aggregated summary, or whether it has any side effects on the recording 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?

The description is a single short sentence with no filler or redundant phrasing. Every word contributes to conveying the tool's core function.

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

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

With zero parameters, invocation is trivial, but the description is vague about what statistics are returned and there is no output schema to clarify. An agent could select the tool, but it would not know whether the result is counts, durations, statuses, or another metric.

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

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

The tool has zero parameters, so there is nothing for the description to add beyond the empty input schema. The baseline of 4 applies because parameter semantics are trivially complete.

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

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

The description states a specific verb and resource: 'Get statistics about recorded test actions.' It clearly indicates a read/query operation and is distinguishable from sibling recording-control tools like Start-Recording-Tool or Clear-Recording-Tool, though it does not explicitly call out any alternative.

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

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

There is no guidance on when to use this tool versus its siblings, such as Export-Test-Script or Clear-Recording-Tool. The agent must rely on the tool name and general context to decide, which is insufficient.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the core behavior: a long press lasting roughly one second. However, it does not mention coordinate origin, screen bounds, whether it waits for UI feedback, or any failure behavior, leaving some behavioral gaps for an agent.

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

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

The description is one tightly written sentence with no filler. The action is front-loaded, and the use case is appended in a second short sentence, making it easy to scan and understand.

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

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

For a simple two-parameter input tool with no output schema, the description covers the essential information: what to do, where to do it, how long to hold, and when it is useful. It lacks only minor context such as coordinate-system definition or explicit sibling differentiation, which would make it fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that 'x' and 'y' represent the coordinates at which to long-press, which is meaningful. Still, it does not specify coordinate system, units, or screen-relative semantics, so the compensation is only partial.

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

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

The description clearly states a specific action ('Long-press') with a resource ('at (x,y)') and a duration ('for ~1 second'). It also gives a use case ('context menus or elements requiring sustained touch'), which helps distinguish it from ordinary taps. However, it does not explicitly compare itself to siblings like Click-Tool or Press-Tool, so differentiation is implied rather than direct.

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

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

The phrase 'Use for context menus or elements requiring sustained touch' gives clear context for when the tool is appropriate. It does not explicitly state when not to use it or name alternatives, but the guidance is sufficient for an agent to infer the main use case.

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

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

No annotations are provided, so the description carries the full burden of explaining side effects and behavior. 'Access' suggests a read-only operation, but the description does not clarify whether this modifies device state, clears notifications, requires permissions, or what the returned data looks like. For a tool with no structured safety annotations, this is a meaningful transparency gap.

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

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

The description is a single sentence with no filler or repetition. It is front-loaded with the action ('Access') and the resource ('notifications'), making it appropriately concise for a parameterless 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?

Given the tool's simplicity and lack of parameters, the description is minimally adequate for an agent to understand what the tool does. However, there is no output schema and no annotations, and the description does not specify what the tool returns or whether accessing notifications has any side effects, leaving some contextual 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?

The tool has zero parameters, so the description has no parameter semantics to explain. The baseline for a parameterless tool is 4, and the description appropriately does not attempt to document nonexistent arguments.

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

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

The description uses a clear verb ('Access') and a specific resource ('notifications seen on the device'), making the tool's primary function understandable. It is not confused with any sibling tool, as no other tool mentions notifications. However, 'Access' is slightly less precise than 'get' or 'list,' and the description does not explicitly contrast itself with siblings.

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

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

The description implies that this tool should be used when an agent needs to retrieve or view notifications currently visible on the device. It does not state when not to use it or mention any alternatives, but there is no closely related sibling tool for notifications, so the implied usage is reasonable.

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

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

No annotations are provided, so the description carries the full burden. It reveals that raw Android KEYCODE strings are accepted, which is valuable behavioral detail, but it does not mention side effects, whether the press is a simple tap, or any device/OS prerequisites.

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

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

The description is a single, efficient sentence with a clear front-loaded action and a concise enumeration of valid inputs. Every part adds useful information with no filler.

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

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

For a single-parameter tool with no annotations and no output schema, the description is mostly complete: it identifies the action, the target resource, and the full set of accepted input forms. A minor gap is the lack of an example raw KEYCODE string, but the description is sufficient for correct invocation.

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

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

The input schema provides only a bare string parameter with 0% coverage and no enum. The description compensates by listing the concrete valid values (home, back, menu, power, volume_up, volume_down, enter, delete) and noting raw KEYCODE strings are also accepted, adding substantial meaning beyond the schema.

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

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

The description uses a specific verb ('press') and resource ('device button'), and enumerates the exact accepted values. It also distinguishes itself from sibling UI-interaction tools by targeting hardware device buttons rather than on-screen elements.

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

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

The description implies usage for hardware device button presses, but it does not explicitly contrast Press-Tool with sibling tools like Click-Tool or Long-Click-Tool. There is no when-to-use versus when-not-to-use guidance beyond the stated button domains.

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

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

With no annotations, the description carries the full burden, and it does disclose the key non-obvious behavior: it 'generates command to run' rather than directly submitting the bug. However, it omits other useful behavioral details such as the output format, whether the command is returned as a string or written to a file, and any dependency on Azure CLI being installed.

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

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

The description is a single efficient sentence that front-loads the action and resource, with the output behavior appended in a parenthetical. The phrase 'with proper bug report structure' is somewhat vague filler, but the overall length and order are appropriate.

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 10-parameter tool with no annotations and no output schema, this description is too minimal. It does not explain the returned command's format, how the fields map to Azure DevOps work item fields, or how this tool should be selected over the direct sibling, leaving gaps that an agent must resolve elsewhere.

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

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

The input schema has 0% parameter descriptions, and the tool description adds no parameter-specific guidance. Ambiguous fields like priority (integer scale), severity ('3 - Medium' string format), project, and parent_user_story are left entirely to the agent's inference from their names.

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

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

The description states a specific action ('Report'), a specific resource ('a bug to Azure DevOps'), a concrete method ('using Azure CLI'), and the output form ('generates command to run'). The 'generates command to run' clause also distinguishes it from the sibling Report-Bug-To-Azure-Direct, which implies direct submission.

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

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

The description implies use when an Azure CLI command artifact is desired, but it never explicitly says when to choose this tool over Report-Bug-To-Azure-Direct or any other alternative. No exclusions, prerequisites, or when-not-to-use conditions 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?

With no annotations, the description carries the burden of behavioral disclosure. It does disclose two meaningful risks: the tool is experimental and it may hang. However, it does not mention authentication requirements, whether a work item is actually created, failure behavior, or side effects beyond reporting a bug. It adds some value but still leaves significant behavioral unknowns.

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 and front-loads the experimental warning and hang risk, which are useful. However, for a tool with 10 parameters and no schema coverage, the single-sentence description is more under-specified than appropriately concise. It contains no redundant text, but it does not earn its place as a complete guide.

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

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

The tool is moderately complex with 10 parameters, no output schema, and no annotations, yet the description only provides a basic purpose and a hang warning. It omits when to use the direct variant, expected return behavior, error outcomes, and any setup requirements. The description is not complete enough for an agent to invoke 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 0%, and the description provides no parameter-level guidance. It does not explain required fields, defaults, how project selection works, or how the parameters map to Azure DevOps concepts. With 10 parameters, this is a major gap and the description completely fails to compensate.

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

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

The description clearly states the verb and resource: 'Report a bug to Azure DevOps'. The 'direct execution' phrase hints at a distinction from the sibling Report-Bug-To-Azure, but it does not fully explain what 'direct' means or how it changes behavior. It is specific enough for an agent to know the primary action, but sibling differentiation is weak.

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 guidance is given about when to use this tool versus Report-Bug-To-Azure. The '[EXPERIMENTAL]' tag and '(may hang)' warning imply caution but do not tell the agent when this direct variant should be preferred or avoided. The agent is left to infer the intended use case from the tool name alone.

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

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

No annotations are present, so the description carries the full burden. It discloses the mutating nature (install, enable) and the target, but gives no detail on side effects, prerequisites, idempotency, or failure behavior. Core behavior is clear, but deeper operational traits are missing.

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. The functional action comes first, and the usage condition second, making the description easy to scan and 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?

While the tool is simple, the description omits any explanation of the `force` parameter, which is a significant gap for correct invocation. It also lacks details about side effects or prerequisites, leaving the description incomplete for an agent that must decide when and how to call it.

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's only parameter is `force` (boolean, default false), and the description says nothing about it. With 0% schema description coverage, the agent is left to guess what `force` does; the description adds zero value for parameter understanding.

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

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

The description names a specific action (install the Portal helper app and enable its accessibility service) on a clear resource, and contrasts it with a sibling (State-Tool) to distinguish its use case. The verb and object are explicit, leaving no ambiguity about what the tool does.

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

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

The description provides an explicit trigger condition ('Use this when State-Tool is slow or the fast MCP Helper backend is unavailable') and references the alternative tool. However, it does not explicitly state when not to use it, so it stops short of full exclusion 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the basic action. It does not disclose side effects such as whether the previous recording is cleared, whether a new session is created, or whether this must be paired with Stop-Recording-Tool.

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

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

The description is extremely concise and front-loaded: 'Start recording test actions' contains only necessary information for a zero-parameter tool. No word is wasted, and nothing extraneous is included.

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

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

Given the tool's simplicity, the description is minimally viable, but it lacks workflow context around the recording lifecycle. It does not mention that this tool should typically be followed by Stop-Recording-Tool, nor does it clarify whether the tool is stateful or affects existing recordings.

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?

This tool has zero parameters, so there is no parameter documentation burden. As a baseline for zero parameters, the score is 4; the description does not need to add parameter details.

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 'Start recording test actions' clearly states a specific verb ('start') and a distinct resource ('recording test actions'). This distinguishes it from sibling tools like Stop-Recording-Tool and Clear-Recording-Tool.

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

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

No guidance is provided about when to use this tool versus the many recording-related siblings. There is no mention of prerequisites, workflow order, or alternatives such as Clear-Recording-Tool, making the usage context entirely implicit.

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

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

With no annotations provided, the description carries the burden of explaining behavior. It discloses the tool's read-style behavior by describing what it returns, including device context and interactive element details, and explains the effect of enabling use_vision. It does not explicitly state that it has no side effects, but 'Get current screen state' strongly implies a non-mutating read operation.

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

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

The description is three sentences with no filler. It front-loads the core purpose, then provides return-value context, parameter guidance, and usage sequencing. Every sentence adds necessary information.

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

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

For a simple one-parameter tool with no annotations and no output schema, the description covers the essential bases: what the tool does, what it returns, how to use the parameter, and when to invoke it. Nothing critical is missing for an agent 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?

The input schema provides no description for use_vision, only a boolean type and default. The description compensates by explaining that setting use_vision=True produces an annotated screenshot, which gives the agent actionable meaning for the sole parameter. This is sufficient for a single boolean parameter.

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

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

The description clearly specifies the verb 'Get' and the resource 'current screen state', listing concrete outputs such as interactive UI elements, label indices, types, names, and tap coordinates. It also distinguishes itself from interaction-focused sibling tools by explicitly stating it should be called first before any interaction.

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 explicit usage guidance: 'Always call this first before interacting' and explains when to set use_vision=True for an annotated screenshot. It does not name alternatives or describe explicit when-not scenarios, but the sequencing instruction makes the intended context clear.

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

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

With no annotations, the description carries the behavioral burden. It clearly states the side effect (stopping recording) and implies that the recorded actions remain usable by saying Export-Test-Script can be used afterward. This gives useful behavioral context beyond the bare tool name.

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 core action, followed by the actionable next step. Every phrase earns its place and there is no redundant wording or restating of the tool name.

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

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

For a zero-parameter, no-output-schema lifecycle tool, the description is complete enough. It explains the action and the natural follow-up. It does not explicitly state whether stopping is reversible or whether the recording is preserved, but the export instruction implies the recording remains available.

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

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

The tool has zero parameters, so there is nothing to document. The description adds no parameter information, but none is needed; the baseline of 4 applies because there is no schema gap to compensate for.

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

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

The description states a clear verb and resource: 'Stop recording test actions.' It is immediately distinguishable from sibling tools like Start-Recording-Tool and Clear-Recording-Tool, and it reinforces its role by pointing to the next step in the workflow.

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 clear context for when this tool fits: it should be used after recording is finished, and the follow-up step (Export-Test-Script with format="pytest") is explicitly named. It does not explicitly exclude alternatives, but the workflow context is strong enough for an agent to know when to call it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the fixed duration ('over 300ms') and describes the effect on scrolling direction. It does not mention coordinate system, edge cases, or potential side effects, but for a simple gesture tool this is reasonably transparent.

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

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

The description is only two sentences, with no wasted words. The primary action and coordinates are stated first, followed by practical scroll-direction tips. This is exceptionally concise and well-structured for agent consumption.

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 tool with four required parameters and no output schema, the description covers the core action, duration, and scroll semantics. The main omission is the coordinate system context (e.g., screen pixels, relative vs absolute), which could affect correct invocation. Overall it is nearly complete but not fully self-contained.

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

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

Schema description coverage is 0%, so the description must compensate for the bare integer fields. It does give meaning to x1,y1,x2,y2 as start and end points, and explains the relationship between y-coordinates and scroll direction. However, it omits essential semantics like coordinate units, origin, and valid ranges, leaving the agent with incomplete information for constructing correct values.

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

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

The description clearly states a specific action ('Swipe from (x1,y1) to (x2,y2)') on a resource identified by coordinates. It conveys that this is a gesture tool and provides direction semantics for scrolling. However, it does not explicitly distinguish itself from the sibling Drag-Tool, so there is some ambiguity about when to prefer Swipe over Drag.

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

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

The description provides practical usage guidance for scrolling: 'To scroll DOWN, swipe from bottom to top. To scroll UP, swipe from top to bottom.' This clearly instructs the agent on how to achieve a specific scroll direction. It does not, however, discuss exclusions or alternatives such as Drag-Tool, leaving some when-to-use context implicit.

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

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

With no annotations, the description carries the full burden. It discloses the tap-to-focus-then-type behavior, which is helpful. However, it does not explain the behavior of the optional 'clear' parameter or what happens when the field already contains text. These are meaningful gaps for a typing tool.

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

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

The description is two sentences with no wasted words. The core action is front-loaded, and the usage constraint is stated directly. Every word adds value.

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

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

The description covers the essential flow and targeting constraint, making the tool usable. However, it omits behavior for the optional clear flag, lacks any note about return values (no output schema exists), and doesn't address edge cases like non-editable elements. These gaps matter given the absence of annotations.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly explains x and y as tap coordinates and text as the text to type. The optional 'clear' parameter is entirely undocumented, leaving its semantics and effect unknown to the agent.

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

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

The description clearly states the action sequence: tap at coordinates to focus, then type text. It names the resource type (input/editable elements), which distinguishes it from generic click tools. However, it does not explicitly differentiate from siblings like Click-By-Label or Press-Tool beyond that constraint.

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 sentence 'Only use on input/editable elements' provides an explicit usage condition and implicitly excludes non-editable targets. It gives clear context for when the tool is appropriate, though it does not name alternative tools for other 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It states the core action but omits critical behavioral details such as the time unit (seconds, milliseconds), whether the wait is blocking, or any limits/error behavior. This is insufficient for safe invocation.

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

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

The description is brief and front-loaded, but it is under-specified rather than elegantly concise. The single sentence provides no structural benefit beyond a minimal 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 single-parameter tool with no annotations and no output schema, the description is incomplete. The missing unit specification and lack of usage context are material gaps that prevent an agent from correctly selecting and invoking the tool.

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

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

Schema description coverage is 0%, and the tool description does not compensate. The only parameter, 'duration', is left entirely unexplained in terms of units, allowed range, or meaning beyond the word itself. The phrase 'amount of time' adds no concrete information.

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

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

The description clearly states the tool's action (wait) and its target (a specific amount of time). It is distinct from the sibling interaction tools like Click-Tool or Type-Tool, though it does not explicitly differentiate itself by name.

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

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

The description provides no guidance on when to use this tool or when to prefer an alternative. It does not mention typical use cases (e.g., pacing between actions) or any exclusions.

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