Semaphore MCP for AI. Control every CI/CD step from chat.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
Semaphore connects your CI/CD platform directly to your AI agent. It lets you manage every part of your delivery lifecycle—from running workflows and viewing live job logs to triggering deployments and cleaning up artifacts—all through natural conversation.
What AI agents can do with Semaphore Automation
Activate deployment target
Marks a specific deployment target as active for immediate use.
Configure artifact retention
Sets the rules defining how long build artifacts are kept in storage.
Create agent type
Adds a new type of self-hosted agent to your system configuration.
Fetch specific job details using get_job and retrieve live logs for debugging failures via get_job_logs.
List pipelines (list_pipelines), check workflow statuses (get_workflow), and manually trigger or stop them using run_workflow, stop_pipeline, or stop_workflow.
Create, list, activate, deactivate, update, and delete deployment targets. You can also check the full history using get_deployment_history and trigger promotions with trigger_promotion.
List stored artifacts (list_artifacts) for a given scope and set how long they need to be kept via configure_artifact_retention.
View details about specific agents (get_agent), list all agent types (list_agent_types), or update/delete the underlying infrastructure with tools like update_agent_type.
Ask an AI about this
Waiting for input…
What AI agents can do with Semaphore: 36 Tools for CI/CD Management
These tools let you interact with every part of the Semaphore platform—from job logs to agent types—through simple, direct commands.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Semaphore on VinkiusActivate Deployment Target
Marks a specific deployment target as active for immediate use.
Configure Artifact Retention
Sets the rules defining how long build artifacts are kept in storage.
Create Agent Type
Adds a new type of self-hosted agent to your system configuration.
Create Deployment Target
Sets up a brand new destination for deploying code (a target).
Deactivate Deployment Target
Takes a deployment target offline, preventing accidental use.
Delete Agent Type
Removes an agent type definition from your organization's list.
Delete Deployment Target
Permanently removes a deployment target.
Disable All Agent Types
Turns off all agents belonging to a specific type at once.
Get Agent
Retrieves detailed information about one specific self-hosted agent instance.
Get Agent Type
Gets the full description and details for a defined agent type.
Get Artifact Retention
Shows current artifact retention policies for a project scope.
Get Deployment History
Retrieves a chronological list of all deployment events for a specific target.
Get Deployment Target By Name
Finds and describes a deployment target based on its human-readable name.
Get Deployment Target
Describes the details of a deployment target using its unique ID.
Get Job Logs
Fetches and displays all logged output for a specified job ID.
Get Job
Retrieves the summary details of one specific build job run.
Get Pipeline
Gets the current status and details of an entire pipeline run.
Get Workflow
Retrieves the specific status and context for a defined workflow execution.
List Agent Types
Lists every agent type currently configured in your organization.
List Agents
Displays all self-hosted agents, grouped by their agent type.
List Artifacts
Lists build artifacts available for a particular project scope.
List Deployment Targets
Shows all deployment targets associated with the current project.
List Pipelines
Retrieves a list of pipelines that have run for this project.
List Promotions
Displays a history list of all promotion events within a pipeline.
List Workflows
Lists all defined workflows for the project.
Rebuild Pipeline
Re-runs only the failed sections of an existing pipeline run.
Rerun Workflow
Resets and runs a previously defined workflow with its original settings.
Run Workflow
Initiates a new, fresh execution of a specific workflow.
Stop Job
Immediately halts a job that is currently running and consuming resources.
Stop Pipeline
Stops an entire pipeline run, preventing further steps from executing.
Stop Workflow
Halts a running workflow execution cleanly.
Trigger Promotion
Manually forces the deployment of code to a specified environment/target.
Trigger Task
Runs an isolated, single-purpose task right now without needing a full pipeline run.
Update Agent Type
Modifies the configuration or settings of an existing agent type.
Update Deployment Target
Changes details (like credentials or URL) for a deployment target.
Validate Yaml
Checks if your pipeline YAML definition is syntactically correct before committing it.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Semaphore, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Semaphore. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 36 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Debugging failures shouldn't mean switching between dashboards and terminals., Solved with Vinkius AI Gateway
Today, a build fails. You have to jump from your IDE to the CI/CD website. Then you find the job ID, click it, wait for the logs page to load, scroll through mountains of text, copy what you need, and paste it into Slack just so your teammate can see the error. It's tedious, slow, and requires five different clicks.
With this server, that whole process disappears. You tell your agent: 'What went wrong with job X?' The agent runs `get_job` and `get_job_logs`. It pulls the logs directly into the chat window, formatted cleanly. You get the error stack trace instantly—no clicks required.
The Semaphore MCP Server: Complete Deployment Control.
Before this server, deploying a fix was a multi-step dance: you'd finish testing in Staging, then manually go to the release section, find the Production target, and hit 'Promote.' If you forgot one step or used the wrong version, everything broke.
Now, it’s one chat command. You ask your agent to `trigger_promotion`. It handles the entire sequence—checking the prerequisites, updating the deployment state, and logging the final success (or failure) in real time. It's that simple.
What your AI can actually do with this
Semaphore MCP Server - CI/CD Automation via AI
This server hooks your Semaphore CI/CD account right up to your favorite agent. You ditch switching between web dashboards and terminals; you manage every single part of your delivery lifecycle using natural conversation with your AI client.
Monitoring Builds and Debugging Failures
You've got a broken build, right? No sweat. To check the status of everything, you can run list_pipelines to see all project runs, or use list_workflows for defined workflows. For deep dives, you get summary details on one specific job with get_job, and if that's not enough, you pull every log line using get_job_logs.
You can also check the overall status of a whole pipeline run via get_pipeline, or focus just on a workflow’s context using get_workflow.
If something fails, don't start over. You can use rebuild_pipeline to re-run only the broken sections of an existing job, and you can always stop a runaway process cleanly; that includes stopping a whole pipeline run with stop_pipeline, halting a specific workflow execution using stop_workflow, or just stopping a single running job instantly via stop_job.
Managing Deployments and Targets
You need to release code, period. This server gives you total control over deployment targets. You can list every target associated with the project using list_deployment_targets, and if you know its name, you find it with get_deployment_target_by_name; otherwise, you pull all the specs using get_deployment_target by ID. The lifecycle management is simple: use create_deployment_target to set up a new destination, then activate it immediately with activate_deployment_target, or take it offline entirely with deactivate_deployment_target.
If something changes—say, the URL or credentials—you modify it using update_deployment_target; if you're done with it, delete_deployment_target wipes it out permanently. You can check what happened before by pulling a full history of events with get_deployment_history, and to force an immediate release into a specific environment, you trigger a promotion using trigger_promotion.
If the target is bad news, you delete it; if you just need to know how it looks, you use get_deployment_target.
Artifacts and Code Integrity
Storage management is key. You can see all the built files available for a project scope by running list_artifacts. When you're done with storage, you set the rules defining artifact cleanup using configure_artifact_retention, and you check what those current policies are with get_artifact_retention.
Before committing anything, don't just trust it. You run validate_yaml to make sure your pipeline definition is syntactically correct, preventing messy commits down the line. For quick, isolated operations that don't require a full CI/CD cycle, you execute them right now using trigger_task.
Agent and System Management
The infrastructure runs on agents, so keeping track of 'em is critical. You can see every agent type configured across your organization by checking list_agent_types, or get the full details for one specific definition with get_agent_type. To spin up new resources, you use create_agent_type to define a new self-hosted agent type, and if you need to adjust its settings, you modify it using update_agent_type; if it's obsolete, delete_agent_type removes it.
You can list all active agents via list_agents, or pull detailed information on one specific instance with get_agent. If an agent type needs to be temporarily disabled for maintenance, you use disable_all_agent_types.
Other Tools At Your Fingertips
You also get tools for viewing promotion records with list_promotions, and if the whole project's YAML changes, you can run a general pipeline restart using rebuild_pipeline or trigger an entire fresh execution of a defined workflow with run_workflow; this is different from just running a single task. You'll find everything you need to manage your entire delivery process through one chat interface.
019ea605-b106-7234-8127-32d024123595 Here's how it actually works
The bottom line is you get full control over complex CI/CD tasks using simple natural language commands.
Subscribe to this server and provide your Semaphore API Token and Organization Slug.
Use a command like list_pipelines to see the current project status, or run get_job with an ID to check a specific build.
Your AI agent interprets your request, calls the necessary tool (e.g., run_workflow), and returns the real-time result directly in the chat window.
Who is this actually for?
This server is for Ops Engineers and Software Developers who are tired of context switching. If your day involves monitoring dashboards, copy-pasting logs from a terminal, or manually triggering a release to 'Staging' after a successful build, you need this. It keeps all that complexity inside your chat window.
Manages pipeline health by running list_pipelines and using rebuild_pipeline to fix failed blocks without touching the dashboard.
Checks build logs immediately after a commit by calling get_job_logs, diagnosing failures, and then triggering fixes or promotions via chat.
Orchestrates complex rollouts by using trigger_promotion to move code between environments and tracking the full history with list_promotions.
What Changes When You Connect
Debugging build failures used to mean jumping between the editor and a log dashboard. Now, calling get_job_logs lets you pull all the output directly into your agent's response, keeping your focus on the code. That saves massive context switching time.
You can stop runaway processes instantly. If a job is stuck or consuming excessive resources, running stop_job halts it immediately via chat—no need to find the kill button in three different tabs.
Deployment rollouts are now controlled commands. Instead of guessing which environment needs an update, use trigger_promotion to move code from 'Staging' to 'Pre-Prod', and check history with list_promotions for proof.
Managing infrastructure is simple. Need to clean up old build files? Use configure_artifact_retention to set clear rules, preventing your storage from getting choked by unnecessary artifacts.
You can test code definitions before committing. Run validate_yaml against a new pipeline structure; it catches syntax errors instantly, so you don't waste time running invalid configs.
See it in action
Debugging a failed build log.
A developer sees that their latest commit fails. Instead of clicking the job ID and scrolling through hundreds of lines, they ask their agent to run get_job for the last failure, then immediately follow up with get_job_logs. The agent returns the specific error stack trace in seconds, letting them fix it without leaving their code editor.
Moving code from Staging to Production.
The release manager confirms staging testing is complete. They tell their agent: 'Trigger promotion to production for project X.' The agent executes trigger_promotion, and the system updates the status, allowing the manager to track the change using get_deployment_history.
Rerunning a specific workflow.
A small bug is found right after deployment. Instead of restarting everything, the team member asks their agent to run rerun_workflow for the last successful build ID. The agent initiates the new run and keeps monitoring it until completion.
Cleaning up old resources.
The DevOps team realizes they're accumulating too many failed builds. They use list_artifacts to see what exists, then call configure_artifact_retention to set a 30-day policy, keeping the system clean and organized.
The honest tradeoffs
Assuming logs are visible in chat.
Just asking 'What happened with my build?' leads to vague status updates or just a link to an external dashboard, forcing you to click away and lose your train of thought.
Be specific. Tell the agent: 'Show me the logs for job ID [ID] using get_job_logs.' This forces the agent to execute the precise tool call needed to pull the raw data.
Forgetting to validate YAML.
Writing a new pipeline configuration and committing it, only for the CI/CD system to fail hours later because of a simple indentation error in the YAML file.
Always run validate_yaml on your local copy first. This checks the syntax before you even push the code, saving time and preventing failed commits.
Manually stopping processes.
Finding a runaway job via the web UI and clicking 'Stop'—a process that requires navigating deep into multiple menus and potentially losing your session data.
Use the stop_job tool. Tell the agent: 'Stop job ID [ID] immediately.' This action is instant, logged in chat, and doesn't require leaving your workspace.
When It Fits, When It Doesn't
You should use this server if your workflow requires orchestrating multiple distinct stages—like checking a build status AND triggering a deployment AND listing artifacts. It handles the entire sequence of calls (e.g., list_pipelines -> get_job_logs -> trigger_promotion). Don't use it if you just need to check one simple, isolated piece of information (e.g., 'What is my API key?'). For basic status checks that don't require action or deep history, a dedicated dashboard might be faster. Use this server when the answer requires doing something—running, stopping, creating, or moving code across environments.
Questions you might have
How do I check if my pipeline YAML is correct before committing it using `validate_yaml`? +
Run validate_yaml and pass your file content to the tool. It immediately returns a boolean success status or highlights specific syntax errors, ensuring your code compiles properly before you even push.
Can I stop a job that's running right now using `stop_job`? +
Yes, if you provide the correct Job ID to the agent, it executes the stop_job tool. This immediately halts resource consumption and prevents unexpected issues from continuing.
What is the difference between `run_workflow` and `trigger_task`? +
run_workflow starts an entire defined sequence of steps (a workflow). trigger_task runs a single, isolated operation without needing the full context or structure of a multi-step workflow.
How do I see which agents are available for my project using `list_agents`? +
Calling list_agents shows you all self-hosted agent instances. The output groups them by type, letting you verify if the required infrastructure is online and ready to run your build.
If a promotion fails, how do I use `get_deployment_history` to check the root cause? +
The tool pulls every record of deployments for that target. You see who ran it and when, allowing you to trace the failure. It's perfect for pinpointing exactly where the process broke down.
How do I use `configure_artifact_retention` to manage old build files? +
It lets you set rules defining how long artifacts stay stored. You define policies—like deleting anything older than 90 days. This keeps your storage clean and helps manage costs.
What if my production environment changes? How do I use `update_deployment_target`? +
You modify the target's connection details or credentials directly. Calling this tool with new parameters ensures your CI/CD tools still talk to the right place, even if the infrastructure shifts.
What does `list_pipelines` show me? Does it list everything in the project? +
It provides a summary of every pipeline defined for that specific project scope. You get the name, ID, and last run status immediately. This helps you quickly see what's available without opening individual workflow details.
Can I check the logs of a specific job to debug a failure? +
Yes! Use the get_job_logs tool with the Job ID. Your agent will retrieve the execution logs, allowing you to identify errors directly in the conversation.
How do I list all active pipelines for a specific project? +
Simply ask the agent to run the list_pipelines action providing the Project ID. You can also filter by branch name or workflow ID.
Is it possible to trigger a promotion to production via chat? +
Yes. If your pipeline has promotions configured, you can use the trigger_promotion tool by providing the Promotion ID to move your code to the next stage.
We've already built the connector for Semaphore. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 36 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.