Skip to main content
Glama

act_and_verify

Run a desktop GUI action, then verify it by checking whether the expected accessibility element appears, vanishes, or matches a label; report success only when that state is observed.

Instructions

Act, then prove the act worked. Runs an action and reports ok=true ONLY when the expected state was observed - never merely because the action was delivered. The expectation is read from the live accessibility tree (an element that must appear or vanish, or a control whose label must match), so a click that changed nothing is a miss, not a success.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "hwnd": "<hwnd>",
      "expect": "<expect>"
    },
    "name": "act_and_verify"
  }
}

Input Schema

NameRequiredDescriptionDefault
hwndYes
budgetNohow many times a retry may drive the user's pointer (0 = never, the default). Retries stay on the semantic rungs unless this allows more
expectYesthe state to observe after the action
methodNoauto
dry_runNo
retriesNo
timeoutNo
intervalNo
name_regexNofallback selector when the automation_id is absent
control_typeNo
automation_idNothe element to act on

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.2.0

TDQS

A3.8/5.0
Behavior3/5

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

No annotations exist, so the description carries the full load; it does disclose the central behavioral trait that ok=true reflects observed state, not delivery, and that expectations come from the live accessibility tree. However, it is silent on the most consequential default — dry_run=true, which by schema means no real pointer action occurs — and says nothing about pointer-driving budget, side effects, or what happens on timeout/retry exhaustion.

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

Conciseness4/5

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

Three tight sentences, front-loaded with the core contract before the mechanics of expectation reading and the failure example. Minimal waste, though the 'never merely because the action was delivered' clause partly restates the preceding sentence's guarantee.

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

Completeness3/5

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

With 11 parameters, a nested expect object, 36% schema coverage, and no annotations or output schema, the description does enough to convey the verification concept and roughly what ok=true means. It is not complete: the dry_run default, the method enum options, and retry/timeout behavior — all agent-critical for a tool that defaults to not touching the pointer — are left entirely undocumented.

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

Parameters3/5

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

Schema description coverage is only 36% across 11 parameters, so the description must compensate; it does add real meaning for the expect object (element appears, vanishes, label matches against the live tree). But method (auto/invoke/pixel), dry_run's default-true semantics, budget, retries, timeout, interval, and the name_regex/automation_id selector pair get no explanation beyond the schema.

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

Purpose5/5

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

States a concrete verb plus outcome ('runs an action and reports ok=true ONLY when the expected state was observed') and explicitly contrasts itself with fire-and-forget delivery: 'a click that changed nothing is a miss, not a success.' An agent can distinguish this verification-oriented tool from plain click/action siblings without opening any schema.

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

Usage Guidelines4/5

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

Makes the usage contract clear: use it when success must be proven by observed state rather than by action delivery, and success is read from the live accessibility tree. It gives no explicit exclusions, though — it never says when to prefer a plain click plus anchor_wait, and it omits that dry_run defaults to true so the action is not actually performed unless changed.

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