pov

by empezarcero

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
Most tools have clearly distinct purposes (mouse vs keyboard vs window vs display), but move_window and resize_window overlap since move_window can also resize with -1 parameters, and focus_window vs set_window_state could potentially confuse. Descriptions are clear enough to disambiguate.
Naming Consistency3/5
Naming follows mixed conventions: list_monitors, close_window, and focus_window use verb-first, while mouse_move, mouse_click, and keyboard_type are noun-first, and screenshot is a single word. The pattern is readable but not consistent across the set.
Tool Count4/5
With 16 tools, the set is on the heavier side of typical scopes, but it covers four distinct domains (display, input, window, process) with no redundant tools. Each tool earns its place, though it feels slightly larger than necessary.
Completeness4/5
Core desktop automation workflows are covered: capture screen, move/click/scroll, type, and manage windows. Missing capabilities like per-window screenshots and drag-and-drop are minor gaps that agents can often work around with existing tools.
Average 4.1/5 across 16 of 16 tools scored. Lowest: 3.5/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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, so the description carries the full burden of behavioral disclosure. It lists the allowed states but does not mention potential side effects (e.g., what happens when hiding a window), whether the operation is reversible, error conditions, or any required permissions. For a mutation tool, this lack of behavioral context 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a one-sentence summary followed by a compact parameter list. Every sentence adds value, and the format is easy to parse. No fluff or redundancy.
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 is simple with only two parameters and an output schema, so the description covers the essential inputs adequately. However, it omits behavioral details such as error handling, idempotency, or whether the state change is persistent, which are not covered by annotations or the output schema. This makes it merely adequate, not comprehensive.
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?
Even though the schema provides no descriptions (0% coverage), the tool description explains both parameters: hwnd is 'The window handle (from list_windows)' and state is an enum listing all valid values. This fully compensates for the missing schema descriptions and adds practical guidance on how to obtain the hwnd.
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: 'Change a window's display state' with examples (minimize, maximize, restore). This distinguishes it from sibling tools like move_window, resize_window, focus_window, and close_window, which handle different aspects of window management.
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 explicit guidance on when to use this tool versus alternatives. It implies the hwnd should come from list_windows, but there is no mention of when to choose this over focus_window, move_window, or close_window. The task's context signals list siblings, but the description itself does not address selection 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 behavioral disclosure. It only restates the obvious action and adds the detail that coordinates are screen-based, but it does not mention side effects, limitations, special behaviors (e.g., no click, instant movement), or potential errors. This is minimal and lacks context beyond the primary action.
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 very concise, front-loaded with the main purpose, and structured clearly with a parameter list. Every sentence adds value, and there is no unnecessary text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, and the combination of a clear purpose plus parameter explanations is sufficient for basic usage. An output schema exists, so return values are covered. However, it could mention coordinate system origin (e.g., top-left) or error behavior for out-of-bounds values, but these are minor omissions.
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?
Although the schema has 0% description coverage, the description includes a parameter section explaining x as horizontal pixel coordinate and y as vertical pixel coordinate. This adds meaningful semantics beyond the bare integer type in 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?
The description clearly states the tool's action: 'Move the mouse cursor to the given screen coordinates.' This is a specific verb and resource, and it distinguishes from siblings like mouse_click and get_cursor_position by focusing on movement only.
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 such as mouse_click or get_cursor_position. The description implies it is for positioning the cursor, but it does not state explicit conditions, exclusions, or mention other tools.
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 carries full responsibility for behavioral disclosure. It only states the core action and does not describe side effects, limitations, failure conditions, or what happens on success or failure, leaving significant behavioral information unaddressed.
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-purpose sentence followed by a short Parameters section, with no redundant filler. Everything included adds value and is front-loaded, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity—one parameter and an output schema exists—the description is largely complete. It tells the user exactly what the tool does and how to supply hwnd, though it lacks deeper behavioral caveats that might exist in more complex environments.
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?
The input schema only defines hwnd as an integer, but the description adds that it is 'The window handle (from list_windows)', providing essential provenance and integration context. With a single parameter and 0% schema coverage, this explanation effectively compensates for schema limitations.
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 uses a specific verb 'Bring' and resource 'window to the foreground and give it focus', clearly stating the tool's purpose. It distinguishes itself from sibling tools like move_window, resize_window, close_window, and get_foreground_window, which address different aspects of window management.
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 when a window needs to be brought to the foreground, and it notes that hwnd comes from list_windows, providing useful context. However, it does not explicitly state when not to use it or compare with alternatives like set_window_state, leaving room for ambiguity.
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 full burden of behavioral disclosure. It explicitly states the filter (visible windows) and the return fields (pid, process_name, title, responding, memory_mb), which adds useful context. However, it does not mention side effects (none obvious for a list operation), permission requirements, or whether it snapshots live data. This is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, both front-loaded and free of filler. The first sentence states the action and scope; the second lists the returned fields. Every word earns its place, and it is easily scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, no-argument tool, the description is nearly complete: it explains the filter and the output structure. However, it does not distinguish itself from the sibling 'list_windows', and there is no mention of platform or process scope (e.g., user vs system processes). Given the simplicity and the existence of an output schema, this is a minor gap.
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?
The tool has zero parameters, and the input schema is an empty object. Per the rubric, a 0-parameter tool gets a baseline score of 4 since no parameter documentation is needed. The description does not attempt to explain any parameters, which is appropriate.
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 uses a specific verb ('List') and clearly specifies the resource ('running processes') with a qualifier ('that have visible windows'). This distinguishes it from the sibling tool 'list_windows', which focuses on windows rather than process-level data. It also lists the returned fields, making the purpose unambiguous.
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?
There is no guidance on when to use this tool versus alternatives. The description does not mention list_windows or other sibling tools, nor does it provide context such as 'use this for process memory usage' or 'use list_windows for window titles'. The only implied usage is from the verb 'list'.
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?
No annotations are provided, so the description carries the behavioral disclosure burden. It explains accepted formats and gives examples, but does not mention whether the press targets the active window, whether it blocks, or what happens on invalid keys. This is adequate but not detailed.
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 front-loaded with the core action and immediately provides high-value examples. The 'Parameters' section is somewhat redundant with the schema, but it adds concrete format examples and does not include unnecessary prose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter keyboard tool with an output schema, the description provides enough to invoke correctly: what it does, valid input formats, and examples. It omits whether the target is the foreground window, but that is an implied prerequisite in the context of sibling focus_window and other desktop automation tools.
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?
The schema only defines keys as a string, but the description adds meaningful detail by showing accepted formats ('enter', 'ctrl+c', 'alt+tab') and labeling them 'human-friendly combos.' This compensates for the 0% schema description coverage.
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?
Opens with a specific verb and resource: 'Press a key or key combination.' The examples ('ctrl+c', 'alt+f4') clearly distinguish it from sibling keyboard_type, which would type strings rather than execute key combinations.
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 'Accepts human-friendly combos' and the examples imply usage for keyboard shortcuts, but there is no explicit guidance on when to prefer this over keyboard_type or whether a window must be focused first. No alternatives are named.
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 key behavior of passing -1 to keep a parameter's current value, which is helpful. However, no annotations exist, and the description doesn't mention potential limitations or side effects, such as whether the window is brought to foreground or if it works on minimized windows.
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 compact and well-structured, with a brief summary followed by a parameter list. No unnecessary wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a window manipulation tool, the description covers the essential parameters and the -1 behavior. It omits details like coordinate reference (screen vs client) and error behavior, but the output schema likely covers return values. The description is mostly complete for standard use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Every parameter in the schema is explained in the description with units and the -1 sentinel meaning. This fully compensates for the 0% schema description coverage.
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: 'Move and/or resize a window.' It uses a specific verb and resource, and distinguishes from sibling resize_window by covering both move and resize operations.
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 like resize_window or set_window_state. The description only explains what the tool does and its parameters, without mentioning exclusions or prerequisites.
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 and discloses key behavioral traits: it sends WM_CLOSE and may prompt the user to save. However, it does not specify whether the call blocks, what happens if the window handle is invalid, or whether it waits for the close to complete.
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 concise and well-structured: a one-line action summary, a brief behavioral note, and a parameter definition. Every sentence serves a purpose with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-param tool, the description covers the action and parameter adequately. Return behavior is absent but the output schema exists to fill that gap. Missing error-handling edge cases slightly reduce completeness, hence 4.
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?
The input schema has no descriptions (0% coverage), so the description compensates by explaining 'hwnd: The window handle.' This adds essential meaning beyond the bare schema, though the explanation is minimal and doesn't mention where to obtain the handle (e.g., list_windows).
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 'Gracefully close a window (sends WM_CLOSE)' with a specific verb and resource. It distinguishes from sibling tools by focusing solely on the close action, unlike focus_window or set_window_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 usage for closing windows but does not explicitly state when to use it versus alternatives (e.g., force-teminating a process). It mentions the application may prompt to save, giving some context, but lacks explicit guidance on exclusions or alternatives.
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 explains parameter behaviors (e.g., -1 for current position, button choices, click count) but does not disclose broader behavioral traits such as physical cursor movement, permission requirements, or side effects. Since no annotations are provided, the description carries the full burden, but it covers only the immediate mechanics without deeper context.
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 concise and well-structured. It opens with a clear one-sentence summary, then uses a bulleted list for parameters. Every line provides essential information without redundancy, making it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers all necessary aspects for operating the tool: coordinates, button, and click count. Since an output schema exists, return values need not be described. The tool is simple and the documentation is complete for its scope, though it lacks environmental or safety notes, which prevents a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides no parameter descriptions, but the tool description fully compensates by explaining each parameter in detail, including the special meaning of -1 for x and y, the valid button options, and the meaning of clicks. This adds significant value beyond the raw 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?
The description clearly states the tool's function: 'Click the mouse at the given coordinates.' It specifies the action (click) and the resource (mouse coordinates), effectively distinguishing it from siblings like mouse_move or keyboard_type. The purpose is explicit and unambiguous.
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 does not provide explicit guidance on when to use this tool versus alternatives. While the name and description make the primary use case obvious, there is no mention of exclusions or alternative tools for similar tasks. Usage context is implied but not stated.
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. It discloses the -1 keep-current behavior and the no-move guarantee. However, it omits potential side effects, error conditions, or permission requirements, leaving some behavioral transparency gaps.
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 succinct and well-structured, front-loading the purpose in the first sentence and then providing parameter details. There is no redundant or filler text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, and the description covers purpose, parameters, and key behavior. The -1 semantics are explained. It does not discuss return values, but an output schema exists. Minor gaps like error handling could be added, but overall it's quite complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has no descriptions, so the description provides the only semantics. It clearly explains hwnd as the window handle and width/height as pixel values with -1 meaning keep current, fully compensating for zero schema coverage.
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 action (resize), the resource (window), and a key constraint (without moving it), which distinguishes it from sibling tools like move_window and set_window_state. It is immediately clear 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for resizing windows but does not explicitly state when to prefer this over alternatives like move_window or set_window_state. There is no exclusion guidance, so it falls at the implied level.
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?
No annotations are present, so the description carries the burden. It implies a read-only operation via 'Get information' and enumerates return values, but does not disclose potential error conditions or permission requirements. This is a minor gap for such a simple 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 extremely concise—two sentences that immediately state the purpose and return values. No redundant or extraneous text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the zero-parameter signature and presence of an output schema, the description is reasonably complete. It covers the essential return fields and purpose, though it could add a note about when to use this tool over list_windows.
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?
The tool has zero parameters, so the baseline is 4. The description adds no conflicting information and correctly focuses on output rather than input.
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: 'Get information about the currently focused window' and lists the exact return fields. This distinguishes it from sibling tools like list_windows (which lists all windows) and focus_window (which changes focus).
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 provides clear context—use it to retrieve details about the active window. It does not explicitly name alternatives or exclusions, but for a simple zero-parameter getter, this is sufficient guidance.
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 full burden. It discloses that text is typed literally and special characters are escaped, which is a key behavioral nuance. However, it does not mention focus requirements or potential failure modes. For a simple typing tool, this is above-average disclosure.
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 extremely concise, with a single introductory sentence followed by a short parameter section. Every sentence adds value, and it is front-loaded with the core purpose. There is no fluff or repetition beyond the necessary parameter list.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one required parameter and an output schema present. The description explains the main behavior and the literal-escaping nuance. While it doesn't cover every edge case (e.g., whether focus is required), for a straightforward type-text tool it is sufficiently complete. The presence of an output schema means return values are not required in the description.
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 schema provides only a string type with no description. The description adds a parameter section stating 'text: The text to type,' which is minimal. However, the main body clarifies that the text is interpreted literally and special characters are escaped, which adds meaning beyond the schema. This compensates partially for the low schema coverage.
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 uses a specific verb+resource: 'Type a string of text as keyboard input.' It clearly distinguishes from sibling tools like keyboard_key by focusing on text strings, while also noting literal handling of special characters. This leaves 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.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context is clear: this tool is for typing arbitrary text as keyboard input. It implies use cases where literal text is needed, but it does not explicitly say 'use this instead of keyboard_key for shortcuts' or provide when-not-to-use guidance. No exclusions are stated, so it's a solid 4 but not a 5.
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 provided, the description carries the burden of behavioral disclosure. It clearly states the return format (a dict with x and y integers), which indicates a read-only operation. However, it does not mention potential edge cases (e.g., multi-monitor coordinates) or confirm the lack of side effects, though the 'get' verb implies no mutation.
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 extremely concise, with two short sentences that front-load the core purpose and immediately follow with the return type. Every word earns its place.
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?
The tool is simple: no parameters, no complex inputs. The output schema exists and the description explicitly states the return structure. Given the low complexity and available context, the description is fully adequate.
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?
There are no parameters, so the description does not need to explain parameter behavior. The input schema is empty, and the 100% schema coverage baseline for no parameters is satisfied.
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 gets the current mouse cursor position, using a specific verb and resource. It is distinct from sibling tools like mouse_move and mouse_click, which perform actions rather than retrieving 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 purpose implies this tool is used to retrieve the cursor position, but there is no explicit guidance on when to use it relative to alternatives. While it is obvious that a getter would be used for reading, the description does not state conditions or prerequisites.
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 explaining behavior. It does this well by stating that positive amount scrolls up, negative scrolls down, and that x/y can target specific coordinates or use current cursor position. However, it doesn't mention potential platform-specific behavior or absence of side effects, but the core behavior is transparent.
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 concise: one opening sentence followed by a well-structured parameter list. Every sentence adds value, and the formatting is easy to parse with clear labels and explanations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple scroll tool, the description covers the essential behavior and all parameters. The existence of an output schema means return values may not need to be explained. It lacks a bit of high-level context about when scrolling is applicable (e.g., scrolling a window or element), but overall it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description fully compensates by explaining each parameter: amount (number of clicks, direction), x and y (coordinates, with -1 meaning current position). This exceeds the minimum needed and makes the parameters clear.
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 action: 'Scroll the mouse wheel.' This is a specific verb+resource that distinguishes it from siblings like mouse_move and mouse_click. The parameter details further clarify that it controls scroll direction and position.
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?
Usage is implied by the name and description, but there is no explicit guidance on when to use this tool over alternatives like keyboard scrolling or mouse_move. The parameter documentation offers some context (e.g., x/y = -1 scrolls at current cursor position), but no exclusions or alternative tool references are provided.
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 full burden. It discloses that only visible windows are listed (not hidden ones), provides the output structure (hwnd, title, process_name, etc.), and implicitly indicates a read-only operation. It does not discuss edge cases or permission requirements, but for a simple list operation this is adequate.
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?
Two sentences, front-loaded with the core action. The first sentence states the action and scope; the second lists return fields and gives a usage hint. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter, read-only tool with an output schema, the description is complete: it states purpose, output fields, and a usage pointer. It doesn't cover error cases or limitations (e.g., what happens if no windows are visible), but those are minor for a simple enumeration tool.
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?
The tool takes zero parameters, so the schema already trivially covers 100%. The description enhances understanding by explaining what the returned fields mean and how to use the primary output (hwnd), which is effectively the tool's 'parameter' for downstream tools.
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 action ('List all visible windows') and scope ('on the desktop'). It distinguishes itself from siblings like list_monitors and list_processes by specifically enumerating windows and explicitly returning window handles (hwnd) for use by other window tools.
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 when to use it: 'Use hwnd to identify a window for other window tools.' This gives clear context but does not explicitly mention alternatives or when not to use it. Since sibling tools like focus_window or close_window are well-differentiated, the context is sufficient.
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 behavioral burden. It discloses return format (index, position, size) and the important nuance that index 0 is the virtual bounding box. This goes beyond a bare 'list' description and sets expectations about the special index.
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?
Only two sentences, front-loaded with the primary purpose, followed by return details. Every sentence adds value without waste.
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?
Given zero parameters, an output schema exists, and the description fully covers the key behavioral nuance (index 0 bounding box), the description is complete for the tool's complexity. Sibling tools about screen interaction benefit from this geometry info.
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?
The tool has zero parameters, so the baseline of 4 applies. The description contributes nothing about parameters, but none are needed, and the schema already confirms no parameters.
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 'List available monitors and their geometry' with a specific verb and resource. It distinguishes itself from sibling tools by being the only tool that deals with monitor enumeration.
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: when monitor geometry is needed, call this tool. It doesn't explicitly mention alternatives or exclusions, but the context is clear given the absence of other monitor-related tools.
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 and does disclose key behavior: it captures the screen, returns an image, and down-scales to max_width preserving aspect ratio. It also clarifies monitor numbering semantics (0=all, 1=primary, etc.). It doesn't cover permissions, errors, or image format, so it's not a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with the core action and return value, followed by a neatly formatted Parameters block. Every sentence contributes usage-relevant detail, with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter capture tool without an output schema, this description is nearly complete: it states purpose, return value, parameter semantics, and a helpful reference to list_monitors. The main gap is that it doesn't specify the image return format or error behavior, but that's a minor omission for a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions are empty (0% coverage), but the description fully documents both parameters: monitor numbering and max_width scaling, including the 0 case to disable. This exceeds the schema's bare type/default information and gives the agent all necessary usage detail.
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?
Description opens with 'Capture a screenshot of the user's screen,' which is a specific verb+resource statement that clearly differentiates it from sibling input/output tools. It also adds the return value purpose: 'so you can see what the user sees.'
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 phrase 'Returns the image so you can see what the user sees' provides a clear use context for visual awareness. It also advises 'Use list_monitors first if you're unsure' for the monitor parameter, giving a practical prerequisite. However, it doesn't mention when not to use or alternative tools.
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:

[![pov MCP server](https://glama.ai/mcp/servers/empezarcero/pov/badges/card.svg)](https://glama.ai/mcp/servers/empezarcero/pov)

Score Badge

Copy to your README.md:

[![pov MCP server](https://glama.ai/mcp/servers/empezarcero/pov/badges/score.svg)](https://glama.ai/mcp/servers/empezarcero/pov)

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/empezarcero/pov'

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