computer-use-plus

by Ethanout

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation3/5
Some tools have overlapping purposes: computer.state and computer.inspect both query UI elements, and computer.invoke, shortcut.run, and computer.act all execute actions. Descriptions help differentiate them, but the boundaries are not always clear.
Naming Consistency2/5
Most tools follow a computer.<verb> pattern, but several use nouns or adjectives (computer.state, computer.execution, computer.fast, computer.browser), and shortcut.run breaks the prefix pattern entirely. This mixing of conventions makes naming less predictable.
Tool Count5/5
13 tools is a well-scoped number for a computer-use automation server. Each tool covers a distinct aspect of observation, action, management, and verification without feeling bloated.
Completeness5/5
The tool surface covers the full lifecycle of UI automation: observing state, waiting for elements, taking screenshots, executing actions, verifying results, managing shortcuts, and canceling pending operations. No critical gaps are apparent for the stated purpose.
Average 3.2/5 across 13 of 13 tools scored. Lowest: 2.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 80 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only mentions 'execute and verify' without detailing behaviors such as whether it simulates user input, whether it is reversible, what happens on failure, or whether it requires the window to be active. For a mutating tool, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise, but it lacks necessary details, making it under-specified. It is not as effective as a concise yet informative description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has complex action semantics with multiple action types and timing rules, yet neither the description nor annotations provide all necessary context about execution order, verification behavior, error handling, or return values. The schema covers some action details, but the overall description is incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not add meaning to the parameters; the actions parameter already has a detailed schema description, but the window parameter's semantics are not clarified beyond its name. With only 50% schema coverage, the description fails to compensate for the undocumented window parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '在指定窗口中执行并验证一组声明式动作' clearly states the tool executes and verifies declarative actions in a specified window. It uses a specific verb and resource, which distinguishes it from passive observation tools like computer.inspect or computer.screenshot, though it does not explicitly contrast with computer.verify or computer.invoke.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to choose this tool over siblings such as computer.verify or computer.invoke. There is no mention of alternatives, exclusions, or prerequisites, leaving the agent without decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for disclosing behavioral traits. It only says 'cancel' without explaining side effects, whether cancellation is reversible, what happens to ongoing operations, or how the confirm_token parameter influences behavior (one vs all). This is a significant gap for a potentially destructive action.
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?
The description is a single declarative sentence, front-loaded with the action and resource, and contains no extraneous words. However, it is slightly under-specified, which reduces the effectiveness of the conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool appears to be part of a computer control system with sibling tools like computer.wait and computer.invoke. The description is too vague about what operations are cancellable, how confirm_token selects between one/all, and what the outcome looks like. No output schema exists, so the description needed to explain more but did not.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one param (confirm_token) with 0% description coverage, and the description does not mention it. The phrase 'one or all' implies a token selects a specific operation, but the mapping is never stated. The description adds minimal meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (cancel) and resource (unconfirmed high-risk operations), and specifies the scope (one or all). It is concise and distinct from sibling tools which are mostly about waiting, inspecting, or invoking, not canceling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives, or what constitutes 'unconfirmed high-risk operations'. There is no mention of prerequisites, exclusions, or comparison to sibling tools like computer.execution or computer.act.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavior. It offers one meaningful caveat ('does not return full action array'), but fails to describe execution side effects, required permissions, or the actual return format. This is insufficient for a run-type tool that likely triggers actions in the environment.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no fluff. Every word contributes to the core functionality and a key limitation. It is appropriately concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 4 parameters, no annotations, and no output schema, the description is drastically incomplete. It lacks parameter explanations, return value details, error conditions, and usage context. The single sentence does not adequately cover the tool's complexity or pitfalls.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 gives partial meaning to shortcut_id by mentioning 'stable ID/name', but leaves params, window, and confirm_token unexplained. Since there are 4 parameters and only one is hinted at, the description adds minimal value for parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool runs a verified shortcut by stable ID/name, using the verb 'run' and resource 'shortcut'. It also adds a distinguishing behavioral note about not returning the full action array, which helps separate it from sibling tools like computer.invoke or computer.act. However, it does not explicitly name alternatives or compare with siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is provided on when to use this tool versus alternatives. The phrase '已验证 shortcut' (verified shortcut) implies a condition, but there is no mention of when not to use it or which sibling tool to choose instead. The agent is left without clear decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden of behavioral disclosure. It only reveals that the tool does not affect the user's foreground desktop, but it fails to disclose that 'destroy' is destructive, what 'diagnose' entails, or any side effects of actions. The isolation trait is useful but insufficient for a tool with create/destroy operations.
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?
The description is a single, front-loaded sentence with no wasted words. It clearly states the core purpose and key benefit in a compact form. However, it is slightly under-specified for the number of actions, but the structure itself is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has five distinct actions including a destructive 'destroy', no output schema, and no annotations, a one-line description is far from complete. It leaves unclear what each action does, return values, and operation-specific contexts. The presence of many sibling tools increases the need for further clarification.
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?
The input schema already covers parameter semantics well: 'action' has an enum of five values, and 'commandLine' is described as only required for 'launch'. The description adds no extra meaning to the parameters, so it stays at the baseline level of relying on schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies a specific resource (Windows dedicated execution desktop) and a verb (manage), also noting a key differentiator (does not affect the foreground desktop). While it is not exhaustive about operations, the schema clarifies the action list, and the description distinguishes from siblings like computer.invoke or shortcut.run by focusing on an isolated desktop.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives such as computer.invoke, shortcut.run, or computer.act. The description simply states what it does without prerequisites, exclutions, or hints about the intended use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses behavioral details about local scripts handling scope isolation/clustering/cleanup and the conditional invocation of organizing AI (useAi=true). However, with no annotations, it fails to mention side effects, mutability, or return behavior, leaving significant gaps.
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?
The description is brief and front-loaded with the core purpose, consisting of two sentences with no extraneous content. However, it may be too terse for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 19 parameters, no output schema, and no annotations, this minimal description is inadequate. It does not explain return values, preconditions, or the significance of different actions, leaving substantial gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 42%, and the description adds no parameter semantics. It does not explain the roles of key parameters like 'action', 'scope', or 'confirm_token', so it fails to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool saves, runs, and organizes action chains, with a specific verb and resource. It distinguishes the tool's general function but does not explicitly differentiate it from the sibling shortcut.run, so it misses full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. There is no mention of scenarios, exclusions, or comparisons to sibling tools like shortcut.run or computer.invoke.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral disclosure burden. It discloses one useful trait (default not returning the full UI tree) but omits critical details such as read-only status, mode semantics (auto/uia/ocr/vision), query behavior, and return format. This leaves significant gaps for a query tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly written sentence that front-loads the main action and adds a useful default-behavior note. Every word earns its place with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, no annotations, and a nested query object with many undocumented fields, the description is too sparse. It omits essential details like mode meanings, query semantics, and expected return structure, leaving the agent under-informed for correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 67% for top-level parameters, with descriptions for mode and window, but the nested query object's fields are entirely undocumented. The description adds minimal parameter meaning, failing to explain the enum values or the purpose of query sub-properties like role, text, or automationId.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool queries windows or semantic UI elements on demand, using a specific verb and resource. The phrase 'default does not return the full UI tree' implies a distinction from a full-dump tool, but it does not explicitly name sibling tools for differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context: on-demand querying and a default that avoids full UI tree output, suggesting it is for targeted inspection. However, it lacks explicit when-to-use guidance or comparisons with alternatives like computer.screenshot or computer.state.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden. It adds a meaningful behavioral detail: 'high-risk operations return a one-time confirmation token' and notes that actions are 'restricted'. However, it does not clarify side effects, permissions, reversibility, or how the token should be used, leaving significant gaps for a tool that executes actions.
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?
The description is a single, front-loaded sentence with no filler. It immediately establishes the preferred-entry role and the core behavior. It is concise but perhaps too sparse given the tool's complexity, so it earns a 4 rather than a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a complex tool with 5 unannotated parameters, nested objects, no output schema, and several sibling execution tools. The description only covers high-level purpose and one safety behavior. It omits the format of actions, the meaning of window/params, return behavior, risk conditions, and how it relates to shortcut.run, computer.act, or computer.execution.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 indirectly maps 'saved shortcut' to shortcut_id, 'restricted actions' to actions, and 'confirmation token' to confirm_token, but it does not explain the 'window' or 'params' fields, nor the structure of action objects. This partial compensation is insufficient for 5 unannotated parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'execute a saved shortcut or a set of restricted actions' and frames it as the 'preferred entry' point. It names a specific verb and resource, but it does not explicitly differentiate it from sibling tools like shortcut.run or computer.act, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'preferred entry' implies this tool should be used first, and 'restricted actions' hints at a limited scope, but it provides no explicit alternatives, exclusions, or conditions for when to choose another sibling tool. This is implied usage guidance rather than explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the use of an independent profile and the CDP/DOM Accessibility backend, and clarifies that the user's browser profile is not reused. However, with no annotations, this is insufficient for a multi-action tool that can click and set values; it doesn't mention side effects, requirements, or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, highly concise, no filler. All content is relevant to the tool's core behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 10 parameters, an action enum, and no output schema or annotations. The one-sentence description leaves substantial gaps about how to use each action, expected inputs, and result formats.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 20%, and the description only indirectly adds context for profileDir and port. It does not explain the required `action` parameter or other fields like `keys`, `query`, `value`, `window`, or `readyTimeoutMs`.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: operating on Chromium pages via an independent profile and CDP/DOM Accessibility backend. It distinguishes itself from sibling tools by specifying 'browser' and 'Chromium', though it does not enumerate specific actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies usage for browser automation with an isolated profile, and explicitly notes that it does not reuse the user's browser profile. However, it does not provide explicit when-to-use vs alternatives or conditions under which other tools should be preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 discloses that setting includeUi=true returns an executable UI node snapshot and short-term ref, which is useful. However, it does not mention any side effects, permissions, rate limits, or what '运行能力' (running capabilities) entails. It is partially transparent but lacks completeness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that front-loads the main purpose and adds a conditional detail. Every word contributes value, and there is no redundancy or fluff. It is an example of efficient, well-structured writing.
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?
The tool has 7 parameters, no output schema, and no annotations, so the description needs to provide adequate context. It does mention the return type (UI snapshot and ref) under includeUi, which is helpful. However, it does not explain what '运行能力' means, how predictions work, or what the output looks like for other parameter combinations. It is adequate but leaves clear gaps for a complex state tool.
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?
The input schema has 100% parameter description coverage, so the schema already documents each parameter. The description adds a small layer of meaning by explaining the effect of includeUi (returning UI snapshot and ref). This justifies the baseline 3, as the description provides marginal value beyond the schema but does not comprehensively enrich parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '获取窗口、焦点和运行能力' (get window, focus, and running capabilities), which is specific and actionable. It also mentions conditional behavior for includeUi. However, it does not explicitly differentiate itself from sibling tools like computer.inspect or computer.screenshot, so it lacks explicit sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives such as computer.inspect or computer.screenshot. There is no explicit context, exclusions, or comparison to siblings. The only usage hint is implicit via the 'includeUi' parameter mention, but no when-to-use advice is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full transparency burden, but it only says polling is supported. It does not disclose behavior on timeout, polling mechanics, read-only nature, or side effects. The description is too sparse to provide meaningful behavioral transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that communicates the core purpose without redundancy. It is concise and well-structured, earning full marks for efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with six parameters, nested objects, and no output schema, a one-sentence description is insufficient. It fails to explain return values, timeout behavior, or how the wait condition is specified, making it incomplete for reliable tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 mentions title, process, role, text, and automationId as query attributes, but does not explain other parameters such as until, pollMs, timeoutMs, window, or windowQuery. The description only partially clarifies the query structure, leaving most parameters without semantic context.
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?
The description clearly states the tool waits for windows or UI elements to appear/disappear, with a specific verb and resource. It lists supported query attributes (title, process, role, text, automationId), distinguishing it from sibling tools like computer.state or computer.inspect which are not polling operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for polling until a UI element appears or disappears, but it does not explicitly state when to use it versus alternatives like computer.inspect or computer.verify. There are no exclusions or alternative tool references, so the agent must infer usage context from the tool name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description takes on the full disclosure burden. It explicitly states that the tool reads one snapshot and does not write to long-term memory, and mentions the optional API key, giving an agent useful behavioral expectations. However, it does not discuss side effects or whether the executed actions are reversible.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is just two sentences, front-loading the key identity ('optional fast-action AI') and then explaining the one-snapshot/batch behavior and memory characteristics. Every sentence contributes meaning without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has six parameters and no output schema, but the description does not explain any parameter semantics, expected return format, or error/handling behavior. While the purpose is clear, the lack of operational detail makes it incomplete for reliable invocation, especially given that the schema already leaves many parameters undocumented.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description contains no information about the six parameters, and the schema itself only describes 33% of them. With such low schema coverage, the description should compensate but does not, leaving the meaning of 'window', 'goal', 'maxNodes', and 'maxActions' to the agent. This significantly hampers correct usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the tool as a fast-action AI that reads a compact UI snapshot once and batch-executes actions, clearly conveying its core function. It distinguishes itself from broader action tools by emphasizing the 'fast' nature and lack of long-term memory, though it does not explicitly reference sibling tool names.
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?
The description implies usage context by characterizing the tool as an optional fast-action method that performs a single snapshot read and batch actions. It also notes that it does not write to long-term memory, suggesting scenarios where memory persistence is not needed. However, it does not explicitly name alternatives or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the behavioral transparency burden. It discloses key behaviors: the breadth of verifiable items, structured output per assertion, and the restriction to files in allowed directories. It does not mention read-only status or error handling, but the core behavior is adequately outlined.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the verb and resource, then concisely states the output format. It contains no unnecessary information and is easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool's schema is complex (many assertion properties, multiple parameters) and there is no output schema, yet the description remains minimal. It does not explain how to construct assertions, what CDP URL or expectedFingerprint refer to, or any prerequisites or side effects. Significant gaps remain for effective tool usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description must compensate for detailed parameter understanding. It only mentions high-level object types (windows, elements, CDP URLs, files) but does not explain the assertion structure, maxNodes, or expectedFingerprint parameters. This is insufficient given the schema's complexity.
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?
The description clearly states the tool's function: verifying windows, elements, CDP URLs, or files in allowed directories, and returning expected/actual/passed for each assertion. It uses a specific verb with a defined scope, distinguishing it from sibling tools like 'inspect' or 'state'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool's usage for verification tasks but does not explicitly contrast it with alternatives like 'computer.inspect' or 'computer.state'. There is no 'use this instead' guidance or exclusion conditions, offering only implicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. It clearly explains that default mode returns only coordinate metadata to save tokens, and that 'image' mode returns a short-term base64 screenshot. It also explains the window parameter's behavior when omitted.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys all essential information without fluff. Every clause adds value regarding mode, default behavior, and token efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool with no output schema, the description covers the key behavioral aspects: default metadata return, image mode for base64, and window optionality. The token-saving rationale adds helpful context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, providing baseline expectations. The description adds value by explaining the mode enum's behavior (only 'image' returns base64) and the window parameter's semantics when omitted (returns up to 20 windows), which the schema does not detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool captures screenshots of a dedicated desktop window on demand, with a specific verb and resource. It does not explicitly differentiate from sibling tools like computer.inspect or computer.state, but the name and description make the primary purpose clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for on-demand screenshots but does not provide explicit guidance on when to use this tool versus alternatives. Sibling tools are not mentioned, so the agent must infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![computer-use-plus MCP server](https://glama.ai/mcp/servers/Ethanout/computer-use-plus/badges/card.svg)](https://glama.ai/mcp/servers/Ethanout/computer-use-plus)

Score Badge

Copy to your README.md:

[![computer-use-plus MCP server](https://glama.ai/mcp/servers/Ethanout/computer-use-plus/badges/score.svg)](https://glama.ai/mcp/servers/Ethanout/computer-use-plus)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Ethanout/computer-use-plus'

If you have feedback or need assistance with the MCP directory API, please join our Discord server