This server provides tools to investigate, analyze, and triage GitHub Actions CI failures:
List failed runs: Retrieve recent failed workflow runs for a repository, including run IDs, workflow names, branches, commits, and URLs.
Summarize a failure: Fetch and summarize logs from a specific failed run, identifying the failed job, step, and relevant log excerpts.
Compare with last success: Diff a failed run against the previous successful run on the same branch, highlighting changes in commit, author, event type, and intervening commits.
Detect flaky tests: Analyze run history on a branch to identify jobs that intermittently pass and fail, along with flakiness scores.
Explain root cause: Classify the likely cause into categories such as test_regression, infra_network, dependency, timeout, lint_or_type, auth_permissions, or unknown, with supporting evidence.
Suggest fixes: Get targeted remediation steps and a validation checklist based on the classified failure category.
List failure trends: Summarize recurring failed jobs over a configurable time window (up to 90 days), with occurrence counts and first/last seen timestamps.
Find regression PR or commit: Identify the suspect commit and linked pull request that likely introduced a regression.
CI health score: Compute an overall health score (0–100) for a branch based on pass/fail rates and flakiness signals.
Failure notifications digest: Generate a deduplicated digest of recent failures grouped by signature, suitable for alerting and triage workflows.
Provides tools to investigate GitHub Actions CI failures, including listing failed runs, summarizing failures, comparing with previous successes, detecting flaky tests, explaining root causes, suggesting fixes, listing trends, finding regression PRs/commits, computing CI health score, and generating failure digests.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@CI Investigator MCP explain the failure in run 12345 for myorg/myrepo"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Published MCP server for investigating GitHub Actions CI failures.
This package exposes tools to:
list recent failed workflow runs
summarize a failed run from logs
compare a failed run with the previous success
detect flaky jobs on a branch
explain likely root cause category
suggest remediation and validation steps
report failure trends and CI health
identify likely regression commit/PR
generate failure digest for notifications
List recent failed workflow runs for a repository.
Input:
owner (string, required): repo owner or org
repo (string, required): repo name
limit (number, optional, default: 10, min: 1, max: 100)
Returns:
array of failed runs with id, workflow name, branch, short commit, URL, and timestamps
Fetch and summarize a failed run.
Input:
owner (string, required)
repo (string, required)
run_id (number, required): failed workflow run id
Returns:
run id
failed job name
failed step name
log excerpt text
Notes:
attempts run log download first
falls back to failed job logs
falls back to check-run annotations when logs are unavailable
Compare a failed run with the previous successful run on the same branch.
Input:
owner (string, required)
repo (string, required)
run_id (number, required): failed workflow run id
Returns:
failed run snapshot
last successful run snapshot (or null)
diff fields:
commit_changed
author_changed
event_changed
commits_between (GitHub compare URL or fallback text)
Detect flaky jobs by analyzing recent completed runs on a branch.
Input:
owner (string, required)
repo (string, required)
branch (string, required)
limit (number, optional, default: 30, min: 1, max: 100)
Returns:
repository and branch metadata
number of analyzed runs
flaky jobs with pass/fail counts and flakiness score
Classify likely failure cause based on logs and fallback data.
Input:
owner (string, required)
repo (string, required)
run_id (number, required)
Returns:
cause category (test_regression, infra_network, dependency, timeout, lint_or_type, auth_permissions, unknown)
confidence and supporting evidence lines
failed job and failed step
Suggest practical remediation and validation steps for a failed run.
Input:
owner (string, required)
repo (string, required)
run_id (number, required)
Returns:
classified category
targeted suggestions
validation checklist
Summarize recurring failed jobs over a configurable time window.
Input:
owner (string, required)
repo (string, required)
days (number, optional, default: 14)
branch (string, optional)
limit (number, optional, default: 100)
Returns:
failure totals in the selected window
top failing jobs with occurrence counts and first/last seen timestamps
Find likely regression commit and linked PR for a failed run.
Input:
owner (string, required)
repo (string, required)
run_id (number, required)
Returns:
suspect commit SHA
compare URL from last success to failed commit
suspected PR metadata (if available)
Compute CI health score for a branch using pass/fail and flaky-job signals.
Input:
owner (string, required)
repo (string, required)
branch (string, required)
days (number, optional, default: 14)
limit (number, optional, default: 100)
Returns:
pass/failure rates
flaky jobs count
overall health score (0-100)
Build deduplicated digest of recent failures for alerting/triage workflows.
Input:
owner (string, required)
repo (string, required)
interval_hours (number, optional, default: 24)
branch (string, optional)
limit (number, optional, default: 20)
Returns:
grouped failure signatures
occurrence counts
latest run references and compact example summary
Related MCP server: Woodpecker CI Pipeline Analyzer
Node.js 20+
GitHub token in environment
Recommended token permissions:
actions:read
checks:read
contents:read
Running a server on its own is less useful than wiring it into an MCP client.
Set GITHUB_TOKEN in your client config:
{
"servers": {
"ci-investigator": {
"command": "npx",
"args": ["-y", "ci-investigator-mcp"],
"env": {
"GITHUB_TOKEN": "ghp_your_token"
}
}
}
}On Windows, wrap npx with cmd /c:
{
"servers": {
"ci-investigator": {
"command": "cmd",
"args": ["/c", "npx", "-y", "ci-investigator-mcp"],
"env": {
"GITHUB_TOKEN": "ghp_your_token"
}
}
}
}401 or 403 errors: verify GITHUB_TOKEN and permissions.
Empty or partial logs: some workflows/log artifacts can be unavailable; the server uses fallback strategies.
Run not found: confirm run_id, owner, and repo are correct.
node or npxSome IDEs (VS Code, Cursor) launch with a limited PATH and can't find Node.js installed via nvm or similar version managers.
Run the following to find the full paths:
which node && which npxThen use the full path in your MCP config:
{
"servers": {
"ci-investigator": {
"command": "/Users/your-user/.nvm/versions/node/v22.14.0/bin/npx",
"args": ["-y", "ci-investigator-mcp"],
"env": {
"GITHUB_TOKEN": "your_token",
"PATH": "/Users/your-user/.nvm/versions/node/v22.14.0/bin:/usr/local/bin:/usr/bin:/bin"
}
}
}
}ISC
Compute a CI health score for a branch based on pass/fail and flakiness
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Window in days | |
| repo | Yes | GitHub repo name | |
| limit | No | Max completed runs to inspect | |
| owner | Yes | GitHub repo owner or org | |
| branch | Yes | Branch to analyze |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description should disclose behavioral traits like read-only nature, side effects, or rate limits. It only states the operation without any such details, leaving the agent uninformed about behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words. It is front-loaded with the action and efficiently communicates the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema is provided, yet the description omits details about the return value (e.g., score range or format). For a score-computing tool, this is a notable gap, though the description still conveys the basic function.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are already documented. The tool description adds no extra meaning beyond what the schema provides. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Compute' and resource 'CI health score for a branch', with basis on 'pass/fail and flakiness'. It differentiates from sibling tools like 'detect_flaky_tests' and 'get_failed_runs' by focusing on an aggregate score, but does not explicitly contrast.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives. The description implies use for high-level health assessment, but does not mention when not to use it or suggest sibling tools for deeper analysis.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compare a failed run with the last successful run on the same branch
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| owner | Yes | GitHub repo owner or org | |
| run_id | Yes | The failed run ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It only states the comparison operation but omits behavioral traits such as whether it is read-only, what happens if no successful run exists, any required permissions, or the format of the comparison output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no extraneous words. It concisely conveys the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given low complexity (3 simple parameters, no output schema, no annotations), the description is adequate but incomplete. It does not describe the return value or behavior when there is no successful run, which are gaps for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The tool description adds context by clarifying that run_id is 'the failed run ID', which aligns with the schema. No additional 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('compare') and resources ('failed run' with 'last successful run') and context ('on the same branch'), clearly distinguishing from siblings like 'explain_failure_root_cause' or 'detect_flaky_tests'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used for comparing a failed run to a last successful run, but does not explicitly state when to use it over alternatives like 'find_regression_pr_or_commit' or 'suggest_fix_for_failure', nor provides any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyze run history to detect flaky jobs on a branch
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| limit | No | Number of runs to analyze | |
| owner | Yes | GitHub repo owner or org | |
| branch | Yes | Branch to analyze |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must fully disclose behavior. It only says 'analyze run history to detect flaky jobs', lacking details on what 'flaky' means, side effects, or output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence is concise and front-loaded with the action. Could be slightly more detailed but remains efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and complexity of flaky detection, the description lacks information about return type, error cases, or algorithm. More context is needed for full operational understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and description adds no further meaning to parameters. Baseline 3 is appropriate as the schema already documents all parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'detect' and the resource 'flaky jobs on a branch', which is specific and distinguishes it from siblings like get_failed_runs or explain_failure_root_cause.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives (e.g., get_failed_runs or list_failure_trends). The purpose is implicit but not contrasted with siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Classify the likely root cause category for a failed CI run
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| owner | Yes | GitHub repo owner or org | |
| run_id | Yes | The failed run ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It only states the high-level action without detailing whether it is read-only, what side effects exist, or what output format to expect. This leaves the agent uninformed about critical behavioral aspects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the verb 'Classify' and resource. Every word contributes meaning without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the simplicity, the description lacks information about return values (no output schema) and does not explain what root cause categories exist. Given the classification nature, this omission reduces the tool's usability for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All three parameters have detailed descriptions in the input schema (100% coverage). The tool description adds no extra 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Classify the likely root cause category for a failed CI run'. The verb 'Classify' and specific resource 'root cause category' make it distinct from siblings like 'detect_flaky_tests' or 'summarize_failure'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus the many siblings. It does not mention conditions, exclusions, or alternatives. The agent must infer usage from the name alone, which is insufficient given the diverse sibling set.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build a deduplicated digest of recent failures for alerting and triage
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| limit | No | Max failures to summarize | |
| owner | Yes | GitHub repo owner or org | |
| branch | No | Optional branch filter | |
| interval_hours | No | Digest interval in hours |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description bears full responsibility for behavioral disclosure. It implies a read-only operation ('build a digest') but does not confirm safety, mention side effects, authentication needs, or rate limits. The minimal description leaves the agent uncertain about underlying behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the core action, resource, and purpose with zero wasted words. It is optimally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description should explain what the digest includes (e.g., format, fields). It does not mention limitations (e.g., 50 max failures) or how results are returned. For a tool that aggregates data, this leaves a significant gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so each parameter is already documented. The description does not add new meaning beyond the schema (e.g., it does not explain how 'interval_hours' or 'limit' affect digest content). Baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'build', resource 'digest of recent failures', and purpose 'for alerting and triage'. It distinguishes from sibling tools like 'get_failed_runs' by emphasizing deduplication and summarization, though it does not explicitly differentiate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'get_failed_runs', 'summarize_failure', or 'detect_flaky_tests'. There is no mention of prerequisites (e.g., CI runs must exist) or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find likely regression commit and related pull request for a failed run
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| owner | Yes | GitHub repo owner or org | |
| run_id | Yes | The failed run ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It only states 'Find likely regression commit and related pull request' without disclosing side effects, permissions, or whether it modifies any state. The read-only nature is implied but not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the action and resource. Every word is meaningful, and there is no redundancy or unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description explains the tool's purpose but does not specify what the output looks like (e.g., commit SHA, PR number) or any constraints. For a tool with no output schema, additional context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for each parameter (owner, repo, run_id). The tool description adds no additional parameter-level information beyond what the schema already provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Find' and the specific resources 'regression commit and related pull request' for a 'failed run'. This distinguishes it from sibling tools like 'explain_failure_root_cause' which focus on explanation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by mentioning 'for a failed run', but it does not explicitly state when to use this tool versus alternatives like 'suggest_fix_for_failure' or 'explain_failure_root_cause'. No exclusions or when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List recent failed CI runs for a GitHub repo
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| limit | No | Max runs to return | |
| owner | Yes | GitHub repo owner or org |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must fully disclose behavior. It mentions 'recent' but does not define the time window, nor does it describe ordering, pagination, or authentication requirements. Minimal disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no superfluous words. Every element ('List', 'recent failed CI runs', 'for a GitHub repo') is essential and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with no output schema, the description is too brief. It lacks definition of 'recent' and does not indicate the output format, leaving ambiguity for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with clear descriptions for owner, repo, and limit. The description adds no additional parameter insights beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'recent failed CI runs for a GitHub repo'. It is distinct from sibling tools like 'ci_health_score' or 'detect_flaky_tests' which focus on analysis rather than listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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, nor prerequisites or exclusions. The description only states what the tool does without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Summarize recurring failed jobs over a time window
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Window in days | |
| repo | Yes | GitHub repo name | |
| limit | No | Max failed runs to inspect | |
| owner | Yes | GitHub repo owner or org | |
| branch | No | Optional branch filter |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It implies a read-only operation (summary), but fails to disclose authentication requirements, rate limits, how 'recurring' is determined, or output format. This is insufficient for safe and effective use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short (one sentence), which on the surface is concise, but it sacrifices completeness. It's not front-loaded with key information; it's just brief. A score of 3 balances conciseness with the need for more detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters with full schema coverage but no output schema and no annotations, the description is insufficient. It does not explain what the summary includes, how trends are computed, or what constraints apply. The tool is moderately complex and the description neglects important context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds 'over a time window' which maps to the 'days' parameter, but does not explain the 'branch' or 'limit' parameters. It adds minimal semantic value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Summarize recurring failed jobs over a time window' clearly states the core action (summarize), resource (failed jobs), and scope (time window). The word 'recurring' adds specificity, but it doesn't differentiate from siblings like 'summarize_failure' or 'get_failed_runs'. The purpose is clear but not uniquely distinguishing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With nine sibling tools, agents would benefit from explicit when-to-use or when-not-to-use instructions. The context is missing entirely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Suggest remediation steps and validation checks for a failed CI run
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| owner | Yes | GitHub repo owner or org | |
| run_id | Yes | The failed run ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Only states it 'suggests remediation steps and validation checks' without disclosing behaviors like authentication needs, side effects, or output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One concise sentence with no unnecessary words. Efficiently communicates core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description is adequate for a simple suggestion tool. However, with complex sibling tools and no usage guidance, it is minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter descriptions, so description does not need to add much. It provides no extra detail beyond the schema, earning baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb 'Suggest' and resource 'remediation steps and validation checks for a failed CI run', making purpose clear. However, it does not explicitly differentiate from sibling tools like 'explain_failure_root_cause' or 'detect_flaky_tests', which could cause confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With siblings covering related failure analysis, the lack of usage context is a significant gap for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch and summarize the logs of a failed CI run
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repo name | |
| owner | Yes | GitHub repo owner or org | |
| run_id | Yes | The failed run ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states that the tool fetches and summarizes logs, but does not mention whether it is read-only, API dependencies, potential latency, or what exactly the summary includes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. Every word contributes to conveying the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description should at least hint at the return format or expected content of the summary. It currently lacks this context, making the tool's full behavior unclear for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides comprehensive descriptions for all three parameters (owner, repo, run_id) with 100% coverage. The tool description adds no additional semantic meaning beyond the schema, 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (fetch and summarize) and the resource (logs of a failed CI run). It distinguishes the tool from siblings like get_failed_runs (which lists runs) and explain_failure_root_cause (which analyzes root cause).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 such as explain_failure_root_cause or detect_flaky_tests. No mention of prerequisites or scenarios where it is inappropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0ci_health_scorecompare_with_last_successdetect_flaky_testsexplain_failure_root_causefailure_notifications_digestfind_regression_pr_or_commitget_failed_runslist_failure_trendssuggest_fix_for_failuresummarize_failureEach tool has a clearly distinct purpose, covering different aspects of CI failure analysis without overlap. For example, ci_health_score computes a health metric, while detect_flaky_tests analyzes flakiness, and explain_failure_root_cause classifies root causes.
Tool names follow a consistent snake_case pattern and mostly use verb_noun or verb_phrase structure (e.g., detect_flaky_tests, list_failure_trends). One minor deviation is ci_health_score, which is a noun phrase, but it still fits the pattern.
With 10 tools, the server is well-scoped for its purpose of CI failure investigation. This count allows comprehensive coverage without being overwhelming.
The tool set covers the full lifecycle of CI failure analysis: identification (get_failed_runs), summarization (summarize_failure), root cause analysis (explain_failure_root_cause, find_regression_pr_or_commit), trend detection (list_failure_trends, detect_flaky_tests), and remediation (suggest_fix_for_failure, ci_health_score). No obvious gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Flaky test detection, root cause analysis, and fix suggestions for development teams.
Direct access to Cypress tests results and accessibility reports in your AI workflow.
BuildPulse CI test analytics for AI agents — flaky tests, coverage, and CI run history.
Agentic testing: HyperExecute jobs, test failure triage, SmartUI visual diffs, a11y audits
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/codeBKashif/ci-investigator-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
