wraith-mcp

Server Quality Checklist

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

Latest release: v0.2.2
Disambiguation4/5
Most tools have clearly distinct purposes: navigation, interaction, content reading, screenshots, PDFs, downloads, and session management are all separate. The only potential confusion is between browse, extract, and navigate, but their descriptions make the distinction clear.
Naming Consistency3/5
Naming is mixed: some tools use bare verbs (browse, scroll, navigate, click, extract), others use verb_noun (type_text, get_content, close_session), and a couple are nouns used as commands (tabs, screenshot). The style is readable but not uniform.
Tool Count4/5
With 17 tools, this is slightly above the ideal 3-15 range, but each tool covers a distinct browser or session operation, making the count justified. It feels a bit heavy but not excessive.
Completeness4/5
The server covers the core browser lifecycle well: navigation, interaction, content extraction, screenshots, PDFs, downloads, persistent sessions, and tabs. Minor gaps exist (e.g., no explicit history or wait commands), but workflows are largely complete.
Average 4/5 across 17 of 17 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 11 commits in the last 12 weeks
- Last stable release on May 15, 2026
- 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

Behavior1/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 disclosing behavioral traits. It only states the action itself, omitting critical details such as whether the close operation is irreversible, what happens to unsaved state, or whether it affects other sessions. This is a significant gap for a destructive-looking operation.
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 clear action statement followed by a structured Args section. Every sentence earns its place, and there is no redundant or filler content.
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's simplicity and the presence of an output schema, the description could suffice, but it lacks usage guidelines and behavioral disclosure. The existence of sibling tools like 'close_all_sessions' creates a need for differentiation that is not addressed, making the description incomplete for safe and correct use.
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 provides only 'session_id' as a string. The description adds meaningful context by explaining that the session ID is 'returned when the session was created', which helps agents source the correct value. This goes beyond the schema's minimal type information.
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 states a specific action ('Close a persistent browser session') with a clear resource (the session). It doesn't explicitly distinguish from the sibling 'close_all_sessions', but the name 'close_session' and the singular resource make the intent clear enough.
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 'list_sessions' or 'close_all_sessions'. There are no stated prerequisites, exclusions, or context for choosing this tool.
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 return format ('clean markdown') and exclusions ('no LLM, no screenshot'), but omits details like whether it waits for page load, whether it captures the full page or visible portion, or if it requires an active session. Some transparency is present but not fully disclosed.
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, front-loaded with the main action, and every word earns its place. No fluff or redundancy, making it an ideal concise tool 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 tool with one optional parameter and an output schema, the description is adequate. It clearly states what it returns and the parameter, which is enough for basic invocation. It could mention when to use it relative to siblings, but the low complexity keeps the requirement modest.
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 0%, so the description must compensate. It merely restates the schema's 'session_id' with a default, adding nothing beyond 'Session to read' which is nearly identical to the schema title. No additional meaning, constraints, or examples are provided.
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 uses a specific verb ('Return') and resource ('current page as clean markdown'), clearly distinguishing it from screenshot (not an image) and extract (no LLM processing). However, it does not explicitly differentiate from snapshot, which might also retrieve page content. Overall, purpose is 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 phrase 'no LLM, no screenshot' gives some context on what this tool is not for, but it does not explicitly state when to use it over siblings like browse, snapshot, or extract. Usage is implied rather than spelled out, with no exclusionary guidance.
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 provided, the description carries the full burden of disclosing behavioral traits. It only states what it does (closes all persistent sessions) but does not mention side effects, irreversibility, impact on current tab, or authentication requirements. This is a destructive operation with minimal behavioral 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 a single, concise sentence that is front-loaded with the verb and object. No unnecessary words or repetition.
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 (0 params, output schema exists), so the description is close to adequate. However, it lacks context about consequences (e.g., sessions are terminated and cannot be restored) and does not differentiate when to use this versus 'close_session'. Given the destructive nature, a bit more context would be appropriate.
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 fully covers everything. The description does not need to add parameter semantics, and the baseline for 0-parameter tools is 4.
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 (close) and the resource (all active persistent browser sessions). It distinguishes itself from the sibling tool 'close_session' by specifying 'all' rather than a single session.
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 the alternative 'close_session'. The description does not mention scenarios, prerequisites, or exclusions. While the name implies batch closing, there is no explicit 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?
No annotations are provided, so the description bears full responsibility. It discloses the output format (base64 PNG) and the keyless, direct capture behavior, but does not mention failure modes, page load handling, or limitations. This is minimal but not misleading.
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 three short sentences plus an Args list. Information is front-loaded, with the core purpose in the first sentence, and every phrase adds value. No filler 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 2-parameter screenshot tool with an output schema, the description covers core behavior, output format, and parameter semantics. It lacks some edge-case details (e.g., what happens on navigation failure), but is sufficient for the tool's simplicity.
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 0%, so the description must compensate. The Args section explains both 'url' and 'full_page', with full_page's default clarified as 'visible viewport only'. It adds meaning beyond the raw schema, though the url explanation is slightly tautological.
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 states 'Take a screenshot of a webpage and return it as base64-encoded PNG' – a specific verb and resource with output format. However, it does not explicitly distinguish from sibling tools like 'snapshot' or 'pdf', so it lacks explicit sibling 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 mentions it is 'Keyless' and navigates/captures directly, but it does not provide explicit when-to-use vs alternatives like 'snapshot' or 'get_content'. Usage is only implied by the purpose.
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 clearly states that this is a list operation, which implies non-mutating behavior, and adds contextual detail ('active persistent'). However, it does not explicitly state that no sessions are modified or whether any permissions are required.
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 words. Every word contributes to understanding the tool's purpose. It is appropriately concise for a zero-parameter list operation.
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 (0 params) and has an output schema, so the description need not explain return values. It provides enough context about what is listed ('active persistent browser session IDs'), though it could add a note about typical usage, e.g., retrieving IDs before closing sessions.
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 schema provides complete coverage. The description does not need to explain parameter semantics. A baseline of 4 is appropriate since there is nothing for the description to add.
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 a clear resource ('active persistent browser session IDs'). It clearly distinguishes itself from sibling tools like close_session and list_downloads by specifying exactly what is being listed.
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. There is no mention of exclusions, prerequisites, or relationships to sibling tools like close_session or list_downloads. The usage context is only implied by the tool's name.
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 full burden. It discloses a key behavioral trait: after pressing the key, it returns a new snapshot. However, it does not mention side effects, whether it waits for navigation/load, or how session state is affected, leaving gaps for a mutation-like 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 concise and well-structured: a one-sentence purpose statement followed by a clear Args list. No wasted words, and the key information is front-loaded.
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 its simplicity (2 params, output schema present), the description covers the essential aspects: what the tool does, its arguments, and the return behavior (new snapshot). It does not explain when to use vs. alternatives, but that is the usage dimension, and the output schema covers return value details.
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 description coverage is 0%, but the description compensates by explicitly explaining each parameter: 'keys' is a key or chord to send with a formatting example, and 'session_id' is the session to act on with a default value. This adds meaningful meaning 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 uses a specific verb ('Press') and resource ('a key or chord') with concrete examples ('Enter', 'Control+a'), and clearly distinguishes itself from siblings like type_text (typing strings) and click (mouse actions) by explaining it sends keyboard keys and then returns a new snapshot.
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 on when to use this tool versus alternatives. It does not mention using this for keyboard shortcuts/hotkeys vs. type_text for text entry, nor does it note any prerequisites like needing an active session or focus.
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 mentions stealth (Patchright), keyless operation, and URL protocol restriction, which is useful context. However, it does not disclose page load timing, error behavior, or session lifecycle details beyond 'persistent session'.
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: three sentences plus args. It front-loads the primary purpose, then adds key traits and follow-up guidance. Every sentence earns its place with no redundant info.
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 tool with an output schema, this is mostly complete: it covers purpose, key behavioral traits, session handling, and follow-up interaction tools. It lacks sibling differentiation and does not describe the output schema in prose, but the output schema itself is present, so this is acceptable.
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 both parameters: url is restricted to http/https, and session_id is a persistent session with a default value. This adds meaningful semantics beyond the bare 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 it opens a URL and returns a snapshot of interactive elements, which is a specific action and result. However, it does not differentiate from the sibling tool 'browse', so there is a slight gap in distinguishing between similar tools.
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 suggests follow-up tools and describes the keyless architecture, implying when to use it (direct AI-driven browsing) but does not explicitly state when NOT to use it or how it differs from 'browse'. There are no exclusions or named alternatives beyond the follow-up 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 exist, so the description must carry the transparency burden. It discloses the main behavior and the fact that a new snapshot is returned, but it does not mention potential side effects (e.g., navigation, waiting for load) or error behavior for stale indices.
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 a one-sentence purpose followed by a clear Args block. Every line provides relevant information without redundant 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 simple click action, the description covers the core workflow: get snapshot index, click, receive a new snapshot. It could mention prerequisites like session creation, but the schema and default values fill some gaps, and an output schema exists.
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 0%, so the parameter descriptions are essential. The description explains 'index' as an element index from a snapshot and 'session_id' as the session to act on with a default, adding meaningful context beyond the raw schema types.
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 states a specific verb ('Click'), a clear target ('the element with the given index (from snapshot)'), and the return value ('Returns a new snapshot'). This distinguishes it from sibling tools like type_text, scroll, and navigate.
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 'from snapshot' implies the prerequisite of obtaining a snapshot first, and returning a new snapshot suggests a refresh workflow. However, there is no explicit guidance on when to use this vs. alternatives or 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses autonomy, resilience to layout changes, a step cap, and session reuse, which are useful. However, it does not warn about potential destructive actions (e.g., form submissions, purchases) or describe error/return behavior, which is a notable gap for a tool that interacts with live pages.
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 summary sentence is front-loaded, and the Args section is clearly structured with no redundancy. Every sentence adds value, including the resilience note and the capped step limit. It is appropriately sized for the tool's complexity.
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 moderate complexity and the presence of an output schema (which handles return values), the description covers core purpose, behavior, and all parameters. It could add more about behavior when max_steps is exceeded or error handling, but it is largely complete for an agent to use the tool correctly.
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 documenting all four parameters: task with an example, url as optional starting point, max_steps with a cap, and session_id for reuse. This goes well beyond the bare schema and provides complete semantic meaning.
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 it executes natural-language browser tasks via an autonomous agent, which distinguishes it from sibling tools that handle specific low-level actions like click or type_text. The verb 'execute' and resource 'browser task' are specific, and the mention of 'no CSS selectors needed' further differentiates it from tools that require selectors.
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 for high-level, natural-language tasks with the example and the 'no CSS selectors needed' note, but it does not explicitly name alternatives or state when not to use this tool. It lacks clear exclusions or direct comparison with sibling tools like click or navigate.
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 explains each action and parameter, including URL validation, but does not disclose side effects, session requirements beyond 'existing', or error behavior. It adds useful context but lacks depth.
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 structured with an Args block, with no fluff. Every sentence earns its place, making it easy to parse.
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 required aspects for usage, and the output schema covers return values. It lacks some detail on error handling or session state, but is otherwise complete 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?
The schema has 0% description coverage, but the description compensates by explaining all parameters: session_id, action, url (with validation), and target_id (sourced from list). This fully maps 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 manages browser tabs within a persistent session and enumerates the supported actions (list, open, close). This is specific and distinguishes it from sibling tools like navigate or browse.
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 tab management within a session but does not explicitly state when to choose this over alternatives or provide exclusions. The context of a persistent session and action list gives some guidance, but no explicit comparisons are made.
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 a key behavior by stating 'Returns a new snapshot,' and the action of typing is clear. However, it does not mention whether text replaces existing content or appends, nor any prerequisite like focusing the element, which could be critical.
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 single purpose line followed by a clean Args list. Every sentence adds value and the front-loaded purpose immediately tells the agent what the tool does.
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 input, action, and return. It even references the snapshot tool by mentioning 'index from snapshot.' The presence of an output schema reduces the need to detail return values. Minor gaps like error behavior or text replacement semantics keep it from 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 description provides an Args section that explains all three parameters: index (element index from snapshot), text (text to type), and session_id (session to act on, default default). This fully compensates for the schema's 0% property descriptions, adding missing meaning.
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 and resource: 'Type text into the element with the given index.' This clearly differentiates the tool from siblings like 'click' or 'press_key' by indicating the action (typing) and the target (element index).
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 usage context is implied: the tool is for typing text into a specific element. However, there is no explicit guidance on when to prefer this over alternatives like 'press_key' or 'click', nor exclusions such as whether the element must be focused.
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?
No annotations exist, so the description carries the burden. It adds useful behavioral details not in the schema: max_steps is 'capped at 50', session_id allows reusing a browser session, and 'interaction steps' implies the tool may take actions on the page. However, it does not disclose whether these actions are read-only or can modify state, or any permission requirements.
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 purpose followed by a succinct Args list. Every element adds value, and the most important information (purpose) is front-loaded.
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 the tool's purpose, all parameters with examples, and key behavioral constraints. It lacks explicit usage guidance relative to siblings, but the presence of an output schema means return-value documentation is unnecessary. Overall, it is a solid, nearly complete description.
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%, but the description fully compensates with a clear Args list explaining each parameter. It provides an example for data_description ('all product names and prices in JSON'), specifies the max_steps cap, and clarifies session_id's purpose for reusing a session.
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 'Extract structured data from a webpage using natural language,' which combines a specific verb ('extract'), resource ('webpage'), and method ('natural language'). This distinguishes it from siblings like get_content or browse by emphasizing structured output and natural-language instructions.
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 (when you need structured data from a webpage) but does not explicitly compare to alternatives or state when not to use it. Mention of 'session_id' and 'interaction steps' provides some context, but there is no direct guidance on choosing this over sibling tools like get_content or snapshot.
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?
No annotations are present, so the description carries the burden. It discloses that it's keyless (no LLM), headless only, and returns base64-encoded PDF, which informs the agent about the output and execution mode. It doesn't cover error handling or timeouts, 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 and front-loaded, using three sentences plus an args line. It gets directly to the point with no extraneous information.
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 param) and presence of an output schema, the description covers the essential behavior: rendering URL to base64 PDF, headless mode, and keyless operation. It doesn't discuss failure modes, but the main usage scenario is well specified.
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?
With 0% schema description coverage, the description compensates by defining 'url: URL to render'. This adds meaning beyond the schema's just type and required flag. The single parameter is fully explained.
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 'Render a webpage to PDF and return it as a base64-encoded PDF' with a specific verb and resource. It distinguishes from siblings like screenshot by specifying PDF format and includes constraints (headless, keyless).
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 context on when to use: it mentions keyless, headless-only, and direct rendering, which implies it's for straightforward PDF capture without LLM processing. However, it doesn't explicitly name alternative tools or exclusion criteria, so 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, the description carries the full burden of behavioral disclosure. It explicitly says the tool scrolls and returns a new snapshot, covering the core action and output. It also documents defaults for direction and amount. It does not mention edge cases or side effects, but for a simple scrolling operation, this is sufficient.
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: one sentence for the action and output, followed by a compact list of parameter explanations. Every piece of information is necessary and directly relevant, and the structure is well-organized with the main purpose front-loaded.
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 the tool's low complexity (three optional parameters) and the presence of an output schema, the description is complete. It explains all parameters, states the output (snapshot), and does not need to elaborate on return structure. It is self-sufficient for an agent to invoke the tool correctly.
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 description provides plain-language explanations for all three parameters: direction (allowed values), amount (pixels), and session_id (session to act on). The schema only has titles and defaults, so the description adds essential meaning and 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 action ('Scroll the page') and its result ('return a new snapshot'), using a specific verb and resource. This distinguishes it from sibling tools like navigate (which changes the URL) and click (which interacts with elements).
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 that scroll is for moving the current page's viewport, but it does not explicitly state when to use it versus alternatives such as navigate or click, nor does it provide any exclusions or alternative recommendations. It is not misleading, but it lacks clear usage 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 provided, the description carries the burden of behavioral disclosure. It reveals the default save directory ('./downloads') and the BROWSER_DOWNLOADS_PATH override, which is useful operational context. It does not explicitly state that the operation is non-destructive, but the verb 'list' and inability to modify files make that apparent.
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: purpose sentence, path/override context, usage timing, and argument documentation. Every sentence adds value, with no redundancy or filler.
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 listing tool with an output schema, the description covers the core purpose, when to use it, the parameter semantics, and an important environment variable detail. No significant gaps remain for an agent to invoke it correctly.
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 provides only a default value for session_id with no description, and schema description coverage is 0%. The description compensates by including 'Args: session_id: Session to inspect', clarifying the parameter's meaning. Though minimal, this is necessary and sufficient for a single obvious 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 opens with 'List files downloaded in this session, with their paths', using a specific verb and resource. This clearly distinguishes the tool from sibling navigation and content tools, and immediately conveys its function.
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 explicitly says 'Call this after a click/navigate that triggers a download', providing clear timing guidance. It does not name alternatives or exclusions, but no sibling tool serves a similar download-listing purpose, so 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 full safety/disclosure burden. It adds useful behavioral context: the snapshot is an indexed list of interactive elements, indices are tied to the current page state, and stale results require a re-run. It doesn't explicitly state that this is a read-only operation, but the phrase 'Return' and the provided workflow imply no side effects.
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?
Three short segments with no filler: the main purpose, a usage tip, and a parameter note. The most important information appears first and the entire description is under 70 words.
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 single-parameter, read-only tool with an output schema, the description covers the core contract: what is returned, how to interpret it, when to refresh, and how to address a session. Nothing essential is missing.
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 `session_id` with a default and no descriptive help text (0% coverage). The description's Args section adds meaning by identifying it as 'Session to inspect', which clarifies the parameter's role beyond the schema's bare type and default.
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 opens with a specific verb+resource ('Return... interactive elements') and defines the output format `[index] <tag> text`, which distinguishes it from sibling read tools like get_content or screenshot.
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?
It explicitly instructs to pass an index to click/type_text and to re-run after the page changes, giving clear context for when to use it and how the result should be consumed. It doesn't name exclusions or alternative tools, but the usage note makes the intended scenario clear.
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 available, the description carries the full burden of behavioral disclosure. It warns that the file holds live authentication secrets and should be stored securely, which is a crucial behavioral trait. It also implies a write operation and gives restore instructions, though it does not mention overwriting behavior or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured. It opens with a one-sentence purpose, adds a security note, gives restore context, and then lists arguments with clear explanations. Every sentence earns its place with no redundancy.
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 tool with only two parameters and an output schema, the description covers all essential aspects: what is saved, the security implications, how to restore, and parameter details. It is complete enough for an agent to invoke correctly without further assumptions.
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 must compensate. It explains that session_id is an existing session ID and suggests creating one via browse/extract, and that path is the file to write to. These explanations add significant meaning beyond the bare schema property names.
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: 'Save a session's cookies + localStorage (auth state) to a JSON file.' This is a specific verb-plus-resource that distinguishes it from sibling tools like browse, extract, or close_session. The scope is well-defined: it saves session storage state, not just any data.
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: it explains that restoring is done via BROWSER_STORAGE_STATE and specifies that session_id must be an existing session (created via browse/extract). It does not explicitly name alternatives or when-not-to-use, but the context is sufficient for most agents.
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:

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

Score Badge

Copy to your README.md:

[![wraith-mcp MCP server](https://glama.ai/mcp/servers/Koreahwan/wraith-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Koreahwan/wraith-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/Koreahwan/wraith-mcp'

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