cypress-mcp

by jams4code

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v0.1.1
Disambiguation4/5
Most tools have clearly distinct purposes, but cypress_discover and cypress_list_specs both list specs, with discover providing more detailed information. Descriptions make the difference clear, so confusion is unlikely, though there is slight overlap.
Naming Consistency4/5
All tools share the cypress_ prefix and use snake_case, with most following a verb_noun pattern (e.g., analyze_spec, run_spec, get_last_run). A few like 'discover' and 'doctor' are single words, deviating slightly from the pattern, but the overall style is predictable and consistent.
Tool Count5/5
With 11 tools, the set is well-scoped for a Cypress testing server. It covers discovery, execution, analysis, debugging, environment inspection, and health checks without unnecessary bloat.
Completeness5/5
The tools provide comprehensive coverage of the Cypress testing lifecycle: discover specs, analyze them, run tests, retrieve results, debug failures with screenshots and context, and run environment checks. The only minor gap is a lack of a bulk run-all tool, but that can be worked around by running specs individually.
Average 4/5 across 11 of 11 tools scored. Lowest: 3.4/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 is passing
This repository is licensed under Business Source License 1.1.
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full responsibility. It discloses the return information (file paths and test counts) but does not detail side effects, permissions, or behavior with the filter parameter. The read-only nature is implied but not explicitly stated.
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 concise sentences with no filler. It is front-loaded and every word earns its place.
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 listing tool with one optional parameter, the description adequately covers the purpose and return value. The schema handles the parameter details, making the description sufficiently complete for its simplicity, though it lacks context on default behavior or how it relates to sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the 'pattern' parameter fully described in the schema. The description does not add any further meaning beyond what the schema already provides.
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 the specific verb 'List' with the resource 'Cypress spec files' and scope 'project', clearly stating the tool's purpose. However, it does not differentiate from the sibling tool 'cypress_discover'.
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 cypress_discover. There is no mention of exclusions or alternative use cases.
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 the full burden of disclosing side effects and safety. The description does not explicitly state whether the tool is read-only, whether it executes the spec, or any other behavioral constraints. It only lists output items, leaving safety and side effects implicit.
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 and front-loaded with the core purpose. The second sentence efficiently lists the extracted artifacts without fluff. Every word contributes, and the structure is 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?
For a tool with one parameter and no output schema, the description effectively communicates what is returned by listing the extracted items. However, it omits whether the analysis is static or involves executing the spec, which could be relevant given sibling tools that run tests. Overall, it's fairly complete for its simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides a clear description of the 'spec' parameter, so schema coverage is 100%. The tool description does not add additional meaning beyond restating the scope as 'single spec file'. Given high schema coverage, a baseline score of 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?
Description clearly defines the tool's function: deep analysis of a single spec file, and enumerates specific extraction targets. This distinguishes it from sibling tools like cypress_list_specs (which lists specs) and cypress_run_spec (which executes tests). The resource and scope are 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 implies usage when an agent needs to understand the structure of a spec file (describe/it blocks, URLs, routes, etc.) but does not explicitly state when to use it versus alternatives. No exclusions or alternative tool references are provided. This is acceptable but not 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?
With no annotations, the description carries the full transparency burden. It discloses that it runs headless and returns structured results, screenshots, and next actions, but does not mention side effects of running tests, project setup requirements, or potential long execution time. The mention of 'screenshot paths' provides some context but is incomplete.
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 that front-loads the core action and return value. It is concise and every part contributes meaningful information.
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 description covers the main function and return type, but fails to mention prerequisites like a valid Cypress project, how this differs from running a single test, or error handling. Given the tool's complexity (5 params, no output schema), the description is adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters with descriptions for each. The tool description does not add additional meaning beyond what the schema already provides, so a baseline score of 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 verb 'run', the resource 'single Cypress spec file', and the mode 'headless', which distinguishes it from sibling tools like cypress_run_test (likely runs a single test) and cypress_list_specs (lists specs). It also specifies the return value.
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 running a spec file headless, but does not explicitly state when to use this tool versus alternatives such as cypress_run_test. There is no mention of when not to use it or context about 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?
No annotations are provided, so the description must carry the transparency burden. It does disclose that it returns 'structured results with recommended next actions' and uses 'grep' for matching, which is useful. However, it does not mention potential side effects (test execution might have side effects), failure modes, or prerequisites. It provides some behavioral context but not a full picture.
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 but packs in the core action, scope, method, and return value. Every word earns its place, and it is front-loaded with the purpose. There is no redundancy or filler, making it highly concise and well-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 description covers the purpose and mentions the return type ('structured results with recommended next actions'), but without an output schema, this is vague. It does not specify the structure of the results or how the 'recommended next actions' are formatted. For a tool that likely returns complex data, this is a gap. Additionally, it doesn't mention error handling or timeout behavior, but the parameter schema covers some of that. Overall, it's adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for all 4 parameters, so the schema already documents each parameter. The description adds only a little extra meaning: 'by name' maps to testName, 'within a spec file' maps to spec, and 'using grep' suggests the matching behavior. This is slightly beyond the schema, but the schema's own descriptions already carry the load, so the baseline of 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 tool's function: 'Run a specific test by name within a spec file using grep.' It uses a specific verb ('run'), defines the resource ('specific test by name within a spec file'), and the grep detail distinguishes it from sibling tools like cypress_run_spec (which likely runs the whole spec). This is specific 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 implies usage: when you need to run a single test by name in a spec file, rather than an entire spec. It does not explicitly mention alternatives like cypress_run_spec or cypress_rerun_last, nor does it give exclusions. The 'within a spec file' phrase gives context, but explicit when/when-not guidance is missing.
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 burden. It discloses the output content (full structured results, runId, args, test details) and the verb 'Return' suggests a read-only operation. However, it does not specify behavior when no previous run exists, potential errors, or any side effects, leaving some ambiguity.
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, efficient sentence that front-loads the main action ('Return') and packs in key details (full structured results, most recent run, runId, args, test details). No wasted words.
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 0-parameter getter with no output schema, the description covers the essential return value details. It lacks explicit error/empty-run behavior, but the overall context is clear enough for an agent to invoke the tool confidently.
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 empty. The description does not need to explain parameters, and it does not add parameter-specific meaning. Baseline for 0 params is 4, and the description correctly indicates the tool takes no input while describing the output.
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 returns 'the full structured results of the most recent Cypress test run' with specific contents (runId, args, all test details). This is a specific verb + resource, and it distinguishes from siblings like cypress_rerun_last (which reruns) and cypress_get_failure_context (which gets failure context only).
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: fetch results of the most recent run. However, it does not explicitly mention when to use this tool over alternatives, nor any scope limitations or exclusions. The agent can infer when to use it from the purpose, but there is no direct 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?
No annotations are present, so the description carries the full burden. It only says the tool 'replays' the last invocation but does not disclose side effects, environment requirements, or behavior when no prior run exists. This is a significant gap for a tool that executes Cypress tests.
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 action, and every word contributes. It is concise without sacrificing the core message.
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-input tool, the description adequately covers the main purpose and use case. It lacks edge-case behavior (e.g., what happens if there is no last run), but given the tool's simplicity and absent output schema, the description is reasonably complete.
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 zero parameters, the schema is trivially fully covered. The description adds meaning by explaining that no arguments need reconstruction ('no need to reconstruct arguments'), which justifies the empty schema. This is helpful and matches the baseline for zero-parameter 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 'replays the exact last run_spec or run_test invocation,' using a specific verb and resource. This distinguishes it from siblings that start new runs or retrieve information.
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 provides clear usage context ('when iterating on the same failure') but does not explicitly mention alternatives or when not to use it. The intent is clear, but it lacks explicit exclusions.
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 provided, so the description carries the behavioral disclosure burden. It reveals that the output is absolute file paths and that multimodal AI agents can read them directly, which is beyond what the input schema states. However, it does not mention whether this is a read-only operation or what happens if no screenshots are found, but the overall behavior is reasonably transparent for a simple lookup 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, consisting of two short sentences. The first sentence is front-loaded with the main action, and the second adds a valuable detail about the return type. Every word earns its place with no filler or redundant information.
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 description covers the return value and the general source (Cypress test failures), but it leaves ambiguity about which test run it refers to (e.g., the last run vs. all historical failures). The filters are described in the schema, but the description doesn't explain how they interact or whether they are optional. For a simple tool, this is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides complete descriptions for both parameters ('Filter by spec file name' and 'Filter by test name'), covering 100% of the schema. The description adds no additional meaning or context about these filters beyond what the schema already documents, so the baseline score of 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 tool's purpose: finding screenshot files from Cypress test failures. It uses a specific verb ('find'), specifies the resource ('screenshot files'), and provides a scoping detail ('from Cypress test failures'). This distinguishes it from sibling tools that deal with running tests, analyzing specs, or retrieving contexts.
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 implicitly conveys when to use this tool: when you need screenshot files from failed Cypress tests. It does not explicitly mention alternatives or exclusion cases, but the context is clear enough for an agent to select it over sibling tools like cypress_get_failure_context or cypress_get_last_run.
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 full burden of behavioral disclosure. It explicitly mentions that sensitive values are masked and that the output is safe to display, providing valuable context. However, it does not specify masking details, error behavior, or output format, leaving some 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 exceptionally concise, with two short sentences that convey the core functionality and safety property. There is no redundant or filler content, and the key information is immediately presented.
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 zero-parameter tool with no output schema, the description adequately covers the tool's purpose and key behavioral trait (masking). It does not describe the output format or potential issues like a missing file, but given the simplicity, the information is reasonably complete.
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 schema is empty, so there is nothing for the description to clarify. The baseline for 0 params is 4, and the description appropriately does not overcompensate for nonexistent 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 the tool returns the contents of cypress.env.json with sensitive values masked, using a specific verb and resource. This distinguishes it from sibling tools focused on running, analyzing, or inspecting specs and test results.
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 viewing environment configuration by noting it is 'Safe to display' and returns the contents. However, it does not explicitly state when to use this tool over alternatives or provide any exclusions or prerequisites, so guidance is only implied.
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 full burden. It implies a read-only discovery operation but does not explicitly state that it does not modify anything or execute tests. The output details are helpful, but safety or side-effect information is missing.
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 with no redundancy. It front-loads the main purpose, provides concrete output details, and ends with a clear usage directive. Every word adds value.
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 description fully covers what the tool does, what it returns, and when to use it. Since there is no output schema, it adequately explains the return values. For a zero-parameter tool, this is complete and self-sufficient.
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 empty. The description does not need to explain parameters, and the baseline for 0 parameters is 4. No additional parameter information is needed.
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 purpose: to discover and map the entire Cypress test suite, returning specific details like specs, test counts, describe blocks, and test names. This goes beyond a simple list and distinguishes it from siblings such as cypress_list_specs.
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 'Use this first to understand what tests exist before writing or running anything,' providing clear guidance on when to use the tool. However, it does not mention alternatives or when not to use it, so it falls short of 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. It transparently discloses the tool's scope—validating config file, binary, spec files, support file, and directories. 'Health check' and 'validates' strongly imply a non-mutating diagnostic, though it does not explicitly state that no files are modified or describe failure behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short, purposeful sentences: purpose, scope, and usage. Every sentence adds value, with the main function front-loaded and no filler words.
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 zero-input diagnostic tool, the description provides the role, exact validation targets, and a usage directive. It omits return-value details, but given the simple invocation and highly descriptive tool name, 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, so the baseline is 4. The description appropriately focuses on the tool's scope and purpose rather than parameter details, which are nonexistent.
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 'health check' and enumerates exactly what is validated (config file, binary, spec files, support file, directories), making the tool's purpose clear. This distinguishes it from sibling tools like run_spec or get_screenshot, which focus on execution or retrieving artifacts.
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 'Use this to diagnose setup issues,' providing clear guidance on when to invoke the tool. It does not name alternative tools or explicitly state when not to use it, but the intended context is unambiguous and distinct from sibling 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 full transparency burden. It explicitly lists what the tool returns in detail, giving a strong sense of behavior and output. It does not explicitly state that the tool is read-only or what happens if no failure exists, but the 'Get' phrasing and debugging bundle framing make the read-only nature implicit.
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 action and return items. Every clause contributes meaning: the first sentence defines the output, the second positions the tool in the workflow. 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?
Given the tool has no parameters and no output schema, the description is largely complete: it explains the purpose, the return contents, and the intended workflow role. It omits edge-case behavior like a missing prior failure, but for a simple getter with no params, this description provides sufficient context for an agent to select and invoke it.
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 zero parameters, so the baseline is 4. The description adds semantic value by specifying the tool targets 'the most recent failure', which gives the agent context about what the tool operates on despite having no formal 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?
Description clearly states 'Get a compact debugging bundle for the most recent failure' with a specific verb and resource, and enumerates the exact contents (failing test, error, stack hint, screenshot paths, spec excerpt, recommended next actions). This distinguishes it from siblings like cypress_get_last_run, which likely returns full run details rather than failure-focused debugging context.
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 'This is the key tool for the fix-and-rerun loop' provides a clear, explicit use case, telling the agent when to reach for this tool. However, it does not explicitly mention alternatives or exclusion criteria (e.g., when cypress_get_last_run would be more appropriate), so it lacks full contrast.
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:

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

Score Badge

Copy to your README.md:

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

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