dos-mcp

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct operation: capabilities, file transfer, target discovery, status, screen capture (text vs graphics), and key injection. No overlapping purposes; the distinction between capture_screen and capture_graphics is clear.
Naming Consistency5/5
All tool names follow a consistent verb_noun snake_case pattern (get_capabilities, upload_file, list_targets, get_status, capture_screen, capture_graphics, send_keys, download_file). No mixed styles or irregular verbs.
Tool Count5/5
Eight tools is well-scoped for a DOS remote-control server, covering file transfer, input, output, discovery, and status without excess. Each tool earns its place in the set.
Completeness4/5
The tool surface covers core remote interaction: file up/download, screen capture, input, target discovery, and status. The only minor gap is a lack of explicit command execution beyond send_keys, but send_keys can handle that indirectly.
Average 3.7/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 12 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
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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?
The annotations already declare readOnlyHint=false, so the mutating nature is known, but the description adds minimal context beyond 'input queue.' It fails to disclose that the tool collects terminal output after injecting keys, which is implied by the settle_ms parameter in the schema but not mentioned in the description. This is a significant behavioral gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word is relevant.
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?
While the schema is fairly rich, the description is too terse to provide context such as when to use the tool, what happens after injection, or how to set up the target. The existence of an output schema covers return values, but the description itself leaves gaps in operational context for a tool with five optional parameters.
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 covers 80% of parameters with descriptions, so the baseline is 3. The description does not add any parameter-specific meaning; it only gestures at 'text and named keys,' which the schema already explains. It does not clarify the ambiguous 'target' parameter.
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 the specific verb 'inject' and identifies the resource as 'the target's input queue,' clearly distinguishing it from sibling tools like capture_screen, upload_file, and get_capabilities. It adds the detail of 'text and named keys' which maps to the parameters. This is a clear, non-tautological statement of function.
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 contains no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. It does not mention that the target must be active or how to choose among multiple targets, leaving the agent to infer usage from the name and schema alone.
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?
Annotations declare readOnlyHint=true, so the agent knows the operation is safe. The description adds scoping to standard graphics framebuffers, but it does not discuss failure modes or behavior for unsupported modes. No contradiction with annotations.
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, precise sentence that wastes no words and front-loads the action. It is appropriately concise and structured.
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 and the output schema covers return values, so that aspect is handled. However, the 'target' parameter is undocumented, and the description does not differentiate from the sibling capture_screen, creating ambiguity. Overall, the description is adequate but has notable gaps in parameter and usage context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has a single optional 'target' parameter with no description (0% schema coverage). The description does not mention this parameter or explain its meaning, leaving the agent without guidance on how to use it. The description fails to compensate 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 clearly states the tool's action: capturing a graphics framebuffer for specific video standards (CGA, Hercules, EGA, VGA). This distinguishes it from the sibling capture_screen by specifying 'graphics framebuffer' and the supported modes.
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 is for graphics modes but does not explicitly state when to use it over capture_screen or other alternatives. It also lacks any mention of prerequisites or context for the target parameter, offering only implicit usage 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?
Annotations include readOnlyHint: true, and the description uses 'report', so there is no contradiction. The description adds useful context by listing the specific aspects of the target that are reported, but it does not disclose behaviors like handling of a null target or error scenarios, which would add further 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?
A single, succinct sentence of 10 words that is front-loaded and contains no filler. Every word adds value, making it an ideal concise description.
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 read-only status tool with an output schema present, the description adequately covers what is reported. The optional target parameter and the output schema handle the remaining details, though it could briefly mention behavior when target is not provided.
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 schema has one optional 'target' parameter with 0% description coverage. The description does not explain what target accepts, what null means, or how it influences the report. It only uses the word 'target' generically, adding little beyond the parameter name.
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 reports target identity, connection state, and current operating phase, using a specific verb ('report') and a defined resource. This distinguishes it from sibling tools like get_capabilities and upload_file, which serve different purposes.
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 explicit guidance on when to use this tool versus alternatives. The description implies it is for checking status but does not provide context like pre/post command use, exclusions, or prerequisites. This leaves the agent without clear selection criteria.
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?
Annotations already declare readOnlyHint=true, so the description doesn't need to repeat safety. It adds specific behavioral context by listing what is reported (operations and screen formats) and emphasizes precision ('exactly'), which is valuable beyond the annotation. There is no mention of side effects, but readOnlyHint covers that aspect.
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, well-structured sentence with no filler words. It front-loads the action and resource. While it could include more detail about the target parameter, the concise phrasing is appropriate for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description does not need to explain return values. However, it lacks guidance on usage context and leaves the target parameter unexplained, which are gaps in the overall completeness. It is sufficient for a basic understanding but not fully self-contained for an 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?
The input schema has one parameter 'target' with 0% description coverage, and the tool description does not explain the parameter's role or behavior when null. The meaning of 'target' is left entirely to inference from the schema name, and no guidance is given on how it affects the capabilities report.
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 verb 'report' and the precise resource 'target operations and screen formats'. It is specific and easily distinguishes itself from sibling tools like get_status or list_targets, making the tool's purpose immediately 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 does not explicitly address when to use this tool versus alternatives, nor does it mention exclusions. However, the phrase 'exactly which target operations and screen formats are supported' implies it is used for discovering capabilities before calling other operations, so the usage is somewhat implied rather than stated.
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?
Beyond the readOnlyHint annotation, the description adds useful details about what is captured (cell attributes and cursor state), which is not evident from annotations alone. However, it does not disclose other behaviors like failure modes or return format details, but the output schema likely covers the latter.
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 immediately states the action and scope. It avoids unnecessary words and is easy to parse.
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?
Given the simple nature of the tool, the description covers the primary purpose and output components, aided by annotations and an output schema. However, it omits any explanation of the 'target' parameter, leaving a gap in completeness for a tool with at least one parameter.
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 includes one optional parameter 'target' with no description, and schema_description_coverage is 0%. The tool description does not mention or explain the parameter at all, failing to compensate for the missing parameter documentation. The name 'target' gives a vague hint but is insufficient.
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 captures the full fixed-width text screen, cell attributes, and cursor state, specifying a distinct resource and action. It differentiates from the sibling tool 'capture_graphics' by explicitly mentioning 'text screen' and the fixed-width nature.
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 when to use it (for capturing text screen state) through the wording 'text screen,' but it does not explicitly mention alternatives or exclusions. There is no direct comparison to capture_graphics or other siblings, so usage context is only implied.
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?
Annotations already declare readOnlyHint=true, so the read-safe nature is covered. The description adds valuable context: the 'bounded' constraint (likely a size limit) and the conditional 'when file reads are enabled', which indicates the tool may fail if that setting is off. This goes beyond the structured annotations, though it stops short of detailing failure modes or file-size boundaries.
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 clause, front-loaded with the verb 'Download' and contains all key information without redundancy. Every word earns its place; it is optimally concise.
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 presence of an output schema covers return values, but the description leaves ambiguity about the 'bounded' limit and the 'enabled' condition. The optional target parameter is unexplained, and there is no indication of how the tool behaves if file reads are disabled. For a tool with only two parameters, this is a moderate gap in contextual completeness.
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 50% (only path has a description), and the tool description does not mention parameters at all. The path is explained in the schema, but the optional 'target' parameter is left unexplained in both schema and description. The description says 'one bounded binary file' but does not clarify how path or target affect the download, 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.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Download' a 'bounded binary file as base64'. It specifies the resource type (binary file) and output format (base64), which distinguishes it from sibling tools like upload_file. The phrase 'when file reads are enabled' adds a scope condition, making the purpose precise.
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 use cases (downloading files) but does not explicitly state when to use this tool versus alternatives. It does not mention that upload_file would be used for the reverse operation, nor does it describe exclusions or prerequisites beyond the 'enabled' condition. Usage is implied rather than explicitly guided.
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?
Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is known. The description adds the prerequisite about peer write permissions and the bounded nature of the upload. It does not describe additional side effects (e.g., default no-overwrite behavior) but does not contradict annotations.
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 sentence of 11 words, front-loaded with the verb and object, and every word adds value. No redundancy or filler.
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?
Although annotations and an output schema exist, the description leaves ambiguities: the meaning of 'bounded' (not explicitly linked to the schema's maxLength), the reference to 'peers,' the role of the 'target' parameter, and the default overwrite behavior. These gaps make the description incomplete for fully autonomous use.
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 descriptions for 3 of 4 parameters (path, overwrite, content_base64), covering the required ones. The tool description adds no parameter-specific meaning, and the optional 'target' parameter has no schema description nor is clarified in the tool description. With 75% schema coverage, baseline 3 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 clearly states the action 'Upload one bounded binary file' with a specific resource and target (DOS), and adds scope constraints ('bounded', 'when writes are enabled at both peers'). It distinguishes from the sibling tool dos.download_file by the upload verb.
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 a clear usage condition: 'when writes are enabled at both peers.' This implies when to use the tool. However, it does not explicitly name alternatives or state when not to use it, but the context is clear and free of misleading directions.
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?
Annotations already provide readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds the nuance that the tool lists both configured and locally discovered systems, which is valuable contextual information beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the verb and resource. There is no redundant or extraneous information, and every word contributes to understanding the tool's function.
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, parameterless list operation with an output schema and read-only annotations, the description is fully adequate. It specifies what is listed and leaves return format details to the output schema, which is present.
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 does not need to explain parameter meanings, and the schema is empty, confirming no additional semantics are required.
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 ('List') and the resource ('configured and locally discovered DOS systems and selectors'). It is specific and distinguishes itself from sibling tools which perform actions like upload, download, or capture.
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 name and description make it evident this is the tool for listing DOS targets. There are no sibling tools that serve the same purpose, and while no explicit 'when to use' guidance is provided, the context is clear enough for an agent to select it for enumeration tasks.
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:

[![dos-mcp MCP server](https://glama.ai/mcp/servers/rvdbijl/dos-mcp/badges/card.svg)](https://glama.ai/mcp/servers/rvdbijl/dos-mcp)

Score Badge

Copy to your README.md:

[![dos-mcp MCP server](https://glama.ai/mcp/servers/rvdbijl/dos-mcp/badges/score.svg)](https://glama.ai/mcp/servers/rvdbijl/dos-mcp)

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/rvdbijl/dos-mcp'

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