Enables interaction with GitHub repositories to access and manage workflow files, including listing repositories, creating and updating workflow files, and managing repository contents through GitHub's API.
Provides comprehensive GitHub Actions management capabilities, including creating workflows, listing and retrieving workflow details, monitoring workflow runs, triggering workflows manually, canceling running workflows, and re-executing failed or completed workflows.
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., "@GitHub Actions MCP Server create a CI workflow for my react app that runs tests on pull requests"
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.
A Model Context Protocol (MCP) server that provides comprehensive GitHub Actions management capabilities. This server allows you to create, manage, monitor, and interact with GitHub Actions workflows through a standardized interface.
Related MCP server: github-repo-mcp
Create Workflow: Create new GitHub Actions workflow files
List Workflows: Get all workflows in a repository
Get Workflow: Retrieve detailed information about a specific workflow
Get Workflow Usage: View usage statistics and billing information
List Workflow Runs: List all workflow runs with filtering options
Get Workflow Run: Get detailed information about a specific run
Get Workflow Run Jobs: View jobs and steps for a workflow run
Trigger Workflow: Manually trigger a workflow dispatch event
Cancel Workflow Run: Cancel a running workflow
Rerun Workflow: Re-execute a failed or completed workflow
Clone or download the server files
Install dependencies:
npm installBuild the TypeScript code:
npm run buildNode.js 18+
GitHub Personal Access Token with appropriate permissions
Generate a GitHub Personal Access Token:
Go to GitHub Settings → Developer settings → Personal access tokens → Fine-grained tokens
https://github.com/settings/personal-access-tokensCreate a token with these scopes:
repo (full repository access)
workflow (update GitHub Action workflows)
contents:read (read access to see GitHub Action workflows)
contents:write (write access GitHub Action workflows)
actions:read (read access to GitHub Actions)
actions:write (write access to GitHub Actions)
Set the environment variable:
export GITHUB_TOKEN=your_token_hereNavigate to your project directory and run the setup script:
cd github-actions-mcp
chmod +x setup.sh
./setup.shYour GitHub token needs the following permissions for the target repositories:
Read: List workflows, get workflow details, view runs and jobs
Write: Create/update workflow files, trigger workflows
Actions: Cancel and rerun workflows
npm startnpm run devCreate a new GitHub Actions workflow file in a repository.
Required inputs:
owner: Repository owner (username/organization)
repo: Repository name
path: Workflow file path (e.g., '.github/workflows/ci.yml')
name: Workflow name - should be descriptive and related to the workflow's purpose
on: Trigger events configuration
jobs: Jobs configuration
Optional inputs:
branch: Target branch (default: 'main')
commitMessage: Commit message (default: 'Add GitHub Actions workflow')
Example:
{
"owner": "myorg",
"repo": "myrepo",
"path": ".github/workflows/ci.yml",
"name": "CI Pipeline",
"on": {
"push": {
"branches": ["main"]
},
"pull_request": {}
},
"jobs": {
"test": {
"runs-on": "ubuntu-latest",
"steps": [
{
"name": "Checkout code",
"uses": "actions/checkout@v4"
},
{
"name": "Setup Node.js",
"uses": "actions/setup-node@v4",
"with": {
"node-version": "18"
}
},
{
"name": "Install dependencies",
"run": "npm install"
},
{
"name": "Run tests",
"run": "npm test"
}
]
}
}
}List all workflows in a repository.
Required inputs:
owner: Repository owner
repo: Repository name
Optional inputs:
page: Page number for pagination
perPage: Results per page (max 100)
Get detailed information about a specific workflow.
Required inputs:
owner: Repository owner
repo: Repository name
workflowId: Workflow ID or filename
Get usage statistics for a workflow (billing information).
Required inputs:
owner: Repository owner
repo: Repository name
workflowId: Workflow ID or filename
List workflow runs with extensive filtering options.
Required inputs:
owner: Repository owner
repo: Repository name
Optional inputs:
workflowId: Filter by specific workflow
actor: Filter by user who triggered the run
branch: Filter by branch
event: Filter by trigger event
status: Filter by run status
created: Filter by creation date (YYYY-MM-DD)
excludePullRequests: Exclude PR-triggered runs
checkSuiteId: Filter by check suite ID
page: Page number
perPage: Results per page
Get detailed information about a specific workflow run.
Required inputs:
owner: Repository owner
repo: Repository name
runId: Workflow run ID
Get jobs and steps for a specific workflow run.
Required inputs:
owner: Repository owner
repo: Repository name
runId: Workflow run ID
Optional inputs:
filter: Filter jobs ('latest' or 'all')
page: Page number
perPage: Results per page
Manually trigger a workflow using workflow_dispatch.
Required inputs:
owner: Repository owner
repo: Repository name
workflowId: Workflow ID or filename
ref: Branch, tag, or commit SHA to run on
Optional inputs:
inputs: Input parameters for the workflow
Cancel a running workflow.
Required inputs:
owner: Repository owner
repo: Repository name
runId: Workflow run ID
Re-run a completed workflow.
Required inputs:
owner: Repository owner
repo: Repository name
runId: Workflow run ID
You can also use this server with MCP configuration files. Add to your MCP settings:
{
"mcp": {
"inputs": [
{
"type": "promptString",
"id": "github-token",
"description": "GitHub personal access token",
"password": true
}
],
"servers": {
"GitHub Actions": {
"command": "node",
"args": ["/path/to/github-actions-mcp-server/dist/index.js"],
"env": {
"GITHUB_TOKEN": "${input:github-token}"
}
}
}
}
}The server provides comprehensive error handling:
Authentication errors: Invalid or expired GitHub tokens
Permission errors: Insufficient repository access
Rate limiting: GitHub API rate limit exceeded
Validation errors: Invalid input parameters
Network errors: Connection issues with GitHub API
Token Authentication Fails
Verify your GitHub token is valid and not expired
Check that the token has the required scopes
Ensure the GITHUB_TOKEN environment variable is set
Permission Denied
Verify your token has access to the target repository
For organization repositories, check if additional permissions are needed
Ensure your token has the workflow scope for creating/modifying workflows
Rate Limiting
GitHub API has rate limits (5000 requests/hour for authenticated requests)
Implement retry logic with exponential backoff if needed
Consider using multiple tokens for high-volume operations
Workflow Creation Fails
Check that the workflow path starts with .github/workflows/
Ensure the YAML syntax is valid
Verify the target branch exists
For debugging, you can run the server with additional logging:
DEBUG=* npm start# List recent workflow runs to check status
list_workflow_runs --owner myorg --repo myapp --status completed --per_page 10
# Get details of a failed run
get_workflow_run --owner myorg --repo myapp --run_id 12345
# View job details to identify failure points
get_workflow_run_jobs --owner myorg --repo myapp --run_id 12345# Trigger a deployment workflow
trigger_workflow --owner myorg --repo myapp --workflow_id deploy.yml --ref main --inputs '{"environment": "production"}'
# Monitor the deployment
list_workflow_runs --owner myorg --repo myapp --workflow_id deploy.yml --status in_progress
# Cancel if needed
cancel_workflow_run --owner myorg --repo myapp --run_id 67890# List all workflows to review
list_workflows --owner myorg --repo myapp
# Check workflow usage for billing
get_workflow_usage --owner myorg --repo myapp --workflow_id ci.yml
# Get workflow details for optimization
get_workflow --owner myorg --repo myapp --workflow_id ci.ymlWe welcome contributions to the GitHub Actions MCP Server! Whether you're fixing bugs, improving documentation, adding new features, or providing feedback, your help is appreciated.
MIT License
Cancel a workflow run
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner | |
| repo | Yes | Repository name | |
| runId | Yes | The ID of the workflow run |
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 states the action ('Cancel') but doesn't explain what cancellation entails (e.g., immediate termination, partial rollback, status changes), required permissions, side effects, or error conditions. This is inadequate for a mutation tool with zero annotation coverage.
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, efficient sentence with zero wasted words. It's appropriately sized for a simple action and front-loads the core purpose immediately.
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 this is a mutation tool (canceling a workflow run) with no annotations and no output schema, the description is incomplete. It doesn't address behavioral aspects like what happens post-cancellation, error handling, or return values, leaving significant gaps for the agent to operate effectively.
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 schema description coverage is 100%, with all three parameters clearly documented in the schema. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage without compensating value.
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 ('Cancel') and target resource ('a workflow run'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from its siblings like 'rerun_workflow' or 'get_workflow_run', which would require explicit comparison to achieve a score of 5.
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. It doesn't mention prerequisites (e.g., needing an active run), exclusions (e.g., cannot cancel completed runs), or comparisons to siblings like 'rerun_workflow' or 'get_workflow_run'. This leaves the agent without contextual usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new GitHub Actions workflow file
| Name | Required | Description | Default |
|---|---|---|---|
| branch | No | Branch to create the workflow on | main |
| commitMessage | No | Commit message | Add GitHub Actions workflow |
| jobs | Yes | Jobs configuration | |
| name | Yes | Workflow name - should be descriptive and related to the workflow's purpose | |
| on | Yes | Trigger events (e.g., {push: {branches: ['main']}, pull_request: {}}) | |
| owner | Yes | Repository owner | |
| path | Yes | Path for the workflow file (e.g., '.github/workflows/ci.yml') | |
| repo | Yes | Repository name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Create' which implies a write operation, but doesn't mention authentication requirements, potential side effects (e.g., committing to a branch), error conditions, or what happens on success (e.g., file creation confirmation). For a mutation tool with zero annotation coverage, this leaves critical behavioral aspects unclear.
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, efficient sentence that front-loads the core purpose without unnecessary words. It earns its place by clearly stating what the tool does, though it could be more informative. There's zero waste or 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?
Given the complexity (8 parameters, nested objects, no output schema, and no annotations), the description is incomplete. It doesn't address behavioral aspects like authentication, side effects, or error handling, nor does it provide usage context. For a creation tool with multiple required parameters and no structured safety hints, more descriptive guidance is needed.
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 schema already documents all 8 parameters thoroughly. The description adds no parameter-specific information beyond what's in the schema (e.g., it doesn't explain how 'jobs' or 'on' should be structured). Baseline 3 is appropriate when the schema does the heavy lifting, though the description could have provided high-level context about parameter relationships.
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 ('Create') and resource ('new GitHub Actions workflow file'), making the purpose immediately understandable. It distinguishes from siblings like 'get_workflow' or 'cancel_workflow_run' by focusing on creation rather than retrieval or management. However, it doesn't specify that this creates a file in a repository, which could be inferred but isn't explicit.
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. It doesn't mention prerequisites (e.g., needing repository access), compare to sibling tools (e.g., 'trigger_workflow' for execution), or specify use cases (e.g., setting up CI/CD). Without annotations or context, users must infer usage from the name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get details of a specific workflow
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner | |
| repo | Yes | Repository name | |
| workflowId | Yes | The ID of the workflow or filename |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get details'), implying it's non-destructive, but doesn't mention authentication requirements, rate limits, error conditions, or what 'details' include (e.g., YAML content, status, timestamps). This leaves significant gaps 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 a single, direct sentence that efficiently conveys the core purpose without unnecessary words. It's front-loaded with the key action and resource, making it easy to parse quickly, which is ideal for tool selection.
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 complexity of workflows in GitHub (with siblings for runs, lists, etc.), no annotations, and no output schema, the description is insufficient. It doesn't clarify what 'details' are returned (e.g., YAML, status), how this differs from run-related tools, or prerequisites like authentication, leaving the agent under-informed for reliable use.
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%, with clear parameter descriptions in the schema (e.g., 'Repository owner', 'Repository name', 'The ID of the workflow or filename'). The description adds no additional meaning beyond the schema, such as explaining how 'workflowId' relates to filenames or providing examples. This meets the baseline for high schema coverage.
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 ('Get details') and resource ('a specific workflow'), making the purpose immediately understandable. However, it doesn't differentiate this tool from similar siblings like 'get_workflow_run' or 'list_workflows', which would require specifying that this retrieves metadata about the workflow definition itself rather than runs or a list.
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 siblings like 'get_workflow_run' (for run details) and 'list_workflows' (for multiple workflows), the agent must infer usage from the name alone, which could lead to incorrect tool selection in complex scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get details of a specific workflow run
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner | |
| repo | Yes | Repository name | |
| runId | Yes | The ID of the workflow run |
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 states it 'gets details' but doesn't specify what details are returned (e.g., status, logs, duration), whether it's a read-only operation, or any error conditions. This leaves significant gaps in understanding the tool's behavior beyond basic retrieval.
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, efficient sentence that directly states the tool's purpose without any unnecessary words. It is appropriately sized and front-loaded, making it easy to parse quickly, which is ideal for clarity in tool selection.
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 complexity of workflow runs (which can involve statuses, logs, artifacts, etc.), no annotations, and no output schema, the description is insufficient. It doesn't explain what details are returned, potential errors, or how it differs from sibling tools, leaving the agent with incomplete context for effective use.
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 has 100% description coverage, clearly documenting all three required parameters (owner, repo, runId). The description adds no additional meaning beyond what the schema provides, such as explaining relationships between parameters or usage examples, so it meets the baseline for high schema coverage.
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 ('Get details') and resource ('specific workflow run'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_workflow' or 'list_workflow_runs', which would require more specificity about what details are retrieved versus those other tools.
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 like 'get_workflow' (for workflow metadata) or 'list_workflow_runs' (for multiple runs). It lacks context about prerequisites, such as needing a specific run ID, or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get jobs for a specific workflow run
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Filter jobs by completion status | |
| owner | Yes | Repository owner | |
| page | No | Page number for pagination | |
| perPage | No | Results per page (max 100) | |
| repo | Yes | Repository name | |
| runId | Yes | The ID of the workflow run |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Get') but doesn't describe whether this is a read-only operation, if it requires authentication, how pagination works (beyond what's in the schema), or what the output format looks like. For a tool with 6 parameters and no annotations, this is a significant gap in transparency.
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, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple tool, though it could be more front-loaded with key details if it were longer. There's no waste, but it's borderline under-specified rather than 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?
Given the complexity (6 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the return values, error conditions, or how this tool fits into the broader workflow system. For a tool that likely returns job data, more context is needed to guide effective use by an AI 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 schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds no additional meaning beyond what the schema provides, such as explaining the relationship between parameters or usage examples. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
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 'Get jobs for a specific workflow run' clearly states the verb ('Get') and resource ('jobs for a specific workflow run'), but it's somewhat vague about what 'jobs' entails and doesn't distinguish this tool from potential sibling tools like 'get_workflow_run' or 'list_workflow_runs'. It's adequate but lacks specificity about the scope of 'jobs'.
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 like 'get_workflow_run' or 'list_workflow_runs'. It doesn't mention prerequisites, such as needing a specific workflow run ID, or clarify its role in the workflow management context. Usage is implied by the name but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get usage statistics of a workflow
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner | |
| repo | Yes | Repository name | |
| workflowId | Yes | The ID of the workflow or filename |
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 states 'Get usage statistics' which implies a read-only operation, but does not specify aspects like authentication needs, rate limits, data format, or any side effects. This leaves significant gaps in understanding how the tool behaves beyond its basic purpose.
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, efficient sentence with no wasted words, making it easy to parse and front-loaded with the core purpose. It is appropriately sized for the tool's complexity, earning full marks for conciseness.
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's moderate complexity (3 parameters, no output schema, and no annotations), the description is incomplete. It lacks details on what 'usage statistics' entail, how results are returned, or any behavioral traits, making it insufficient for an agent to fully understand the tool's context and usage.
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 has 100% description coverage, detailing all three parameters (owner, repo, workflowId) with clear types and requirements. The description adds no additional meaning beyond what the schema provides, such as explaining parameter interactions or usage examples, so it meets the baseline for high schema coverage.
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 'Get usage statistics of a workflow' clearly states the action (Get) and resource (usage statistics of a workflow), making the purpose understandable. However, it does not differentiate from siblings like 'get_workflow' or 'get_workflow_run', which might retrieve different types of workflow data, so it lacks specificity in comparison.
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 such as 'get_workflow' or 'list_workflow_runs'. There is no mention of context, prerequisites, or exclusions, leaving the agent without direction on tool selection among similar siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all workflow runs for a repository or specific workflow
| Name | Required | Description | Default |
|---|---|---|---|
| actor | No | Filter by user who triggered the workflow | |
| branch | No | Filter by branch | |
| checkSuiteId | No | Filter by check suite ID | |
| created | No | Filter by creation date (YYYY-MM-DD) | |
| event | No | Filter by event type | |
| excludePullRequests | No | Exclude PR-triggered runs | |
| owner | Yes | Repository owner | |
| page | No | Page number for pagination | |
| perPage | No | Results per page (max 100) | |
| repo | Yes | Repository name | |
| status | No | Filter by status | |
| workflowId | No | The ID of the workflow or filename |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions listing but doesn't disclose behavioral traits like pagination behavior (implied by 'page' and 'perPage' params), rate limits, authentication requirements, or response format. For a read operation with many parameters, this lacks critical context beyond the basic action.
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, efficient sentence that front-loads the core action and scope. It wastes no words and is appropriately sized for a list operation, making it easy for an AI agent to parse quickly.
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 high complexity (12 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain return values, pagination, error handling, or authentication needs. For a tool with extensive filtering options and sibling tools, more context is needed to guide effective use.
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 well-documented in the schema. The description adds no specific parameter semantics beyond implying filtering capabilities ('for a repository or specific workflow'), which the schema already covers in detail. Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't compensate with additional insights.
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 resource ('workflow runs'), specifying scope ('for a repository or specific workflow'). It distinguishes from siblings like 'get_workflow_run' (singular) and 'list_workflows' (workflows, not runs), but doesn't explicitly differentiate from 'get_workflow_run_jobs' which focuses on jobs within runs. The purpose is specific but could be more precise about sibling distinctions.
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. It doesn't mention prerequisites like authentication, compare to 'list_workflows' for listing workflow definitions, or specify scenarios like filtering needs. With 12 parameters for filtering, usage context is implied but not stated, leaving gaps 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.
List workflows in a GitHub repository
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner | |
| page | No | Page number for pagination | |
| perPage | No | Results per page (max 100) | |
| repo | Yes | Repository name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure but only states the basic action. It doesn't mention that this is a read-only operation (implied by 'list'), doesn't describe pagination behavior beyond what's in the schema, and doesn't explain what 'workflows' means in GitHub context (e.g., workflow files vs. workflow runs).
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, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a straightforward list operation and front-loads the essential information.
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 list operation with good schema coverage but no annotations or output schema, the description is minimally adequate. It identifies the resource and action but lacks important context about what 'workflows' includes, how results are structured, or how this differs from sibling tools, leaving gaps for an agent to understand the full scope.
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 schema already documents all 4 parameters thoroughly. The description adds no additional parameter information beyond what's in the schema, maintaining the baseline score of 3 for adequate but not enhanced parameter documentation.
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 resource ('workflows in a GitHub repository'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_workflow_runs' or 'get_workflow', which could cause confusion about what specific workflows are being listed.
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 like 'list_workflow_runs' or 'get_workflow'. There's no mention of prerequisites, context, or exclusions that would help an agent choose between these similar-sounding workflow-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Re-run a workflow run
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner | |
| repo | Yes | Repository name | |
| runId | Yes | The ID of the workflow run |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Re-run' implies a mutation operation, but the description doesn't specify permissions required, side effects (e.g., if it cancels the current run), rate limits, or what happens on success/failure. This leaves significant gaps for a tool that modifies workflow state.
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, efficient sentence with zero wasted words. It's appropriately sized for a simple tool and front-loaded with the core action. Every word earns its place, making it easy to parse quickly.
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 complexity of a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 're-run' entails behaviorally, what the expected outcome is, or how it differs from similar operations. For a tool that likely has significant side effects, more context is needed to guide proper usage.
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%, with clear documentation for 'owner', 'repo', and 'runId' parameters. The description adds no additional parameter semantics beyond what's in the schema. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even without param info in the description.
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 'Re-run a workflow run' clearly states the action (re-run) and resource (workflow run) with a specific verb. However, it doesn't distinguish this from sibling tools like 'trigger_workflow' or 'create_workflow', which might have overlapping functionality. The purpose is clear but lacks sibling differentiation.
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. It doesn't mention prerequisites (e.g., needing an existing workflow run), exclusions, or comparisons to siblings like 'trigger_workflow' or 'cancel_workflow_run'. Without any usage context, the agent must infer when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Trigger a workflow run
| Name | Required | Description | Default |
|---|---|---|---|
| inputs | No | Input parameters for the workflow | |
| owner | Yes | Repository owner | |
| ref | Yes | The reference to run the workflow on (branch, tag, or SHA) | |
| repo | Yes | Repository name | |
| workflowId | Yes | The ID of the workflow, filename, or display name as defined in the workflow file's 'name:' field |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states the action without disclosing behavioral traits such as whether this is a mutation, requires specific permissions, has side effects (e.g., starting a run), rate limits, or expected outcomes. It's minimal and lacks critical context for safe invocation.
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, efficient sentence with zero waste, front-loaded and appropriately sized for the tool's purpose. Every word earns its place, making it highly 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?
Given no annotations, no output schema, and a mutation-like tool (triggering implies execution), the description is incomplete. It doesn't cover behavioral aspects, return values, or error handling, leaving significant gaps for an agent to understand the tool's full 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 the schema fully documents all 5 parameters. The description adds no additional meaning beyond what's in the schema (e.g., no extra context on parameter usage or relationships), meeting the baseline for high coverage without compensation.
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 'Trigger a workflow run' clearly states the action (trigger) and resource (workflow run), but it's vague about what 'trigger' entails (e.g., starting execution) and doesn't differentiate from siblings like 'rerun_workflow' or 'create_workflow', which involve similar concepts. It avoids tautology but lacks specificity.
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 like 'rerun_workflow' or 'create_workflow', nor does it mention prerequisites or context. Usage is implied by the name alone, with no explicit when/when-not statements.
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.0cancel_workflow_runcreate_workflowget_workflowget_workflow_runget_workflow_run_jobsget_workflow_usagelist_workflow_runslist_workflowsrerun_workflowtrigger_workflowEach tool has a clearly distinct purpose targeting specific GitHub Actions resources and actions, with no overlap. For example, list_workflows enumerates workflows, get_workflow retrieves details, create_workflow adds new ones, and trigger_workflow initiates runs, making misselection unlikely.
All tools follow a consistent verb_noun pattern with snake_case, such as list_workflows, get_workflow_run, and cancel_workflow_run. This predictability aids agents in understanding and using the toolset effectively without confusion from mixed conventions.
With 10 tools, the server is well-scoped for managing GitHub Actions workflows, covering essential operations like listing, creating, triggering, and monitoring runs. Each tool earns its place without feeling excessive or insufficient for the domain.
The toolset provides complete CRUD and lifecycle coverage for GitHub Actions, including create_workflow, list_workflows, get_workflow, trigger_workflow, rerun_workflow, cancel_workflow_run, and monitoring via get_workflow_run and get_workflow_usage, with no obvious gaps or dead ends.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Model Context Protocol server for Studex tools, notifications, and profile integrations
A Model Context Protocol server for Wix AI tools
A Model Context Protocol (MCP) application for automated GitHub PR analysis and issue management.…
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/onemarc/github-actions-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server