Developers are no longer spending most of their time inside traditional IDEs.

Today, workflows increasingly happen inside AI-powered coding environments like Claude Code, Cursor, and Codex. Developers are collaborating with agents, asking questions in natural language, debugging through conversations, and automating repetitive work directly from their coding environment.

At Semaphore, we believe CI/CD needs to evolve alongside those workflows.

That’s why we’re introducing Semaphore for AI Agents: a new open-source CLI and agentic interface designed to make Semaphore fully accessible from AI coding agents.

This is the beginning of a broader initiative we call the AI-native Semaphore experience: a vision where developers can interact with Semaphore entirely through agents, natural language, and automation.

CI/CD Built for Agentic Workflows

Traditional CI/CD tools were designed around dashboards, manual configuration, and humans clicking through interfaces.

But modern development workflows are changing.

Developers want to stay focused inside their coding environment without constantly switching tabs, navigating dashboards, or manually gathering CI/CD context. Agents are becoming the new interface layer for software development.

Semaphore for AI Agents is designed specifically for that reality.

Instead of requiring developers to manually inspect pipelines, analyze failures, or collect build metrics, Semaphore for AI Agents gives AI coding assistants a structured way to understand and interact with Semaphore.

The result is a workflow where developers can simply ask:

• “Why is my CI failing?”
• “What tests are flaky?”
• “Show me the critical path in this pipeline.”
• “Summarize the health of this project over the last week.”

And their coding agent can retrieve, analyze, and act on that information directly.

What You Can Do With Semaphore for AI Agents

The first release already includes a growing set of commands focused on CI/CD visibility, debugging, and workflow automation.

Diagnose failing pipelines

Semaphore for AI Agents can analyze projects and identify failing workflows, blocks, and tests without requiring developers to manually navigate logs or dashboards.

Instead of piecing information together across multiple views, the CLI aggregates data into structured output designed specifically for agents.

Developers can retrieve:

• Failing tests
• Pipeline summaries
• Workflow diagnostics
• Commit metadata
• Flaky test information

All of it is available in machine-readable formats that coding agents can immediately process.

Critical path and blast radius analysis

Semaphore for AI Agents introduces commands specifically designed to help agents reason about CI/CD systems.

For example:

• Critical path analysis helps identify which jobs or blocks are having the largest impact on pipeline execution.
• Blast radius analysis helps evaluate how failures propagate through workflows.

These workflows are especially useful for AI agents trying to debug complex pipelines automatically.

Organization-level insights

Semaphore for AI Agents can also analyze entire organizations and summarize CI/CD health over time.

Developers and engineering leaders can retrieve insights such as:

• Pass rates
• Queue times
• Workflow durations
• Job execution trends
• Frequently failing tests
• Historical comparisons across weeks

Because the CLI outputs structured JSON, agents can summarize and contextualize large amounts of operational data automatically.

Instead of manually generating reports, developers can ask their coding assistant for an overview of the organization’s CI/CD health and immediately get actionable insights.

Designed for AI Coding Agents

Semaphore for AI Agents was built from the ground up for agentic workflows.

The CLI includes:

• Agent-oriented command structures
• Discoverable commands and examples
• Structured JSON outputs
• Schema-aware responses
• Built-in support for coding assistants

The project also ships with:

• Claude Code skills
• Generic agent skills
• A local MCP server

This allows coding assistants to directly interact with Semaphore using the Model Context Protocol (MCP).

In practice, this means developers can stay entirely inside their coding environment while their agent:

• Investigates CI failures
• Retrieves pipeline information
• Identifies flaky tests
• Summarizes project health
• Runs diagnostics
• Executes workflows

without requiring developers to leave their workflow.

CI Infrastructure for AI Agents

One of the most exciting capabilities demonstrated in the release is the ability to dynamically provision machines on Semaphore infrastructure for agent-driven workflows.

Using Semaphore for AI Agents, developers can:

• Spawn ephemeral machines
• Sync local files
• Run tests remotely
• Execute agent workflows at scale
• Keep environments warm for rapid iteration

Instead of waiting for commits to trigger CI, developers can use Semaphore infrastructure directly as an extension of their development environment.

This creates entirely new workflows where AI agents can:

• Continuously rerun tests
• Debug code remotely
• Scale workloads dynamically
• Execute large parallel workloads
• Operate safely in isolated environments

All powered by the same infrastructure Semaphore already uses to run CI/CD at scale.

A Foundation for the AI-Native Semaphore Experience

Semaphore for AI Agents is not a standalone experiment.

It is the first step toward a larger vision for how software delivery evolves in an AI-native world.

At Semaphore, we believe the future of CI/CD is not just about executing pipelines reliably.

It is about helping developers continuously improve software quality by automating the repetitive and operational work surrounding software delivery.

Our vision is simple:

• Developers define intent
• Agents handle repetitive execution
• Semaphore provides the infrastructure, orchestration, and control layer

Developers remain in control.

Agents become powerful collaborators.

And CI/CD evolves into a platform for developer automation.

Open Source, Built in Public, and Developer-Controlled

Semaphore for AI Agents is fully open source — and that is a core part of how we think about AI-powered developer tooling.

As an open-source company, we believe developers should be able to inspect, understand, and extend the tools they rely on every day. Especially when AI is involved.

Developers should be able to:

• Understand how tools work
• Inspect prompts and behavior
• Extend workflows
• Build custom automations
• Contribute new commands and integrations

There is no black-box automation here.

Semaphore for AI Agents is designed as infrastructure developers can trust, customize, and improve together with us.

And this is only the beginning.

The current release focuses on foundational capabilities for debugging, diagnostics, visibility, and agent interaction, but we’ll continue shipping new workflows and capabilities in the open.

Over the coming weeks, we’ll expand:

• MCP integrations
• CI analysis tooling
• Agent-driven workflows
• Automation primitives
• Testing workflows
• Scalable agent execution capabilities

We’ll also continue publishing demos, examples, and real-world workflows showing how developers can integrate Semaphore for AI Agents into their daily development process.

Because our goal is not to add AI for the sake of AI.

Our goal is to help developers spend less time on repetitive operational work and more time building great software.

Get Started

Semaphore for AI Agents is available today as an open-source project.

You can:

• Explore the repository: https://github.com/semaphoreio/sem-ai
• Compile it locally
• Connect it to your existing Semaphore CLI configuration
• Experiment with MCP integrations
• Build your own workflows and automations
• Contribute new commands and ideas

If you already use the Semaphore CLI, Semaphore for AI Agents reuses the same authentication and configuration setup, making onboarding straightforward.

We’re excited to see what developers build with it.

We also recorded a full demo showing Semaphore for AI Agents in action, including CI/CD debugging workflows, MCP integrations, organization-wide insights, and remote execution capabilities on Semaphore infrastructure.

👉 Watch the demo here.
👉 Explore the project on GitHub.
👉 Read the docs.

We’re excited to see what developers build with it.