Buildkite MCP Server

Official MCP server from Buildkite. Exposes pipelines, builds, jobs, logs, artifacts, annotations, and Test Engine data to AI tools and editors.

Developer Tools by Buildkite OAuth2 (remote server) or API Key (local server, BUILDKITE_API_TOKEN) active

Connect (Remote Server) GitHub Docs

Overview

The Buildkite MCP server is the official Model Context Protocol implementation maintained by Buildkite. It exposes Buildkite CI/CD product data, including pipelines, builds, jobs, job logs, artifacts, annotations, clusters, and Test Engine runs, to AI tools and editors so agents can read CI state and act on it.

The server is offered in three deployment modes. A hosted remote server is available at https://mcp.buildkite.com/mcp with read/write OAuth scopes (and a read-only variant at /mcp/readonly), using short-lived OAuth tokens (12 hour access, 7 day refresh). A local server can be run via Docker (buildkite/mcp-server), a prebuilt binary from GitHub Releases, Homebrew, or go install. The local server authenticates with a Buildkite API access token (typically prefixed bkua_).

Notable capabilities include creating and updating pipelines, triggering builds, unblocking blocked jobs, searching and tailing job logs (including dedicated tools for working with Parquet log files), listing build artifacts, reading annotations, and querying failed test executions from Buildkite Test Engine. Each tool maps to a specific Buildkite API scope (e.g. read_pipelines, write_builds, read_build_logs, read_suites), so tokens can be scoped tightly per use case.

Tools

Tool	Description
`access_token`	Retrieve information about the current API access token, including its scopes and UUID.
`current_user`	Retrieve details about the user account that owns the API token.
`user_token_organization`	Retrieve details about the Buildkite organization associated with the user token.
`list_clusters`	List all clusters in an organization with their names, descriptions, and default queues.
`get_cluster`	Obtain detailed information about a specific cluster configuration.
`list_cluster_queues`	List all queues in a cluster with their keys, descriptions, and dispatch status.
`get_cluster_queue`	Retrieve specific queue details including dispatch and agent configuration.
`list_pipelines`	List all pipelines in an organization with their basic details and build counts.
`get_pipeline`	Retrieve detailed information about a specific pipeline including its configuration.
`create_pipeline`	Set up a new CI/CD pipeline in Buildkite with YAML configuration.
`update_pipeline`	Modify an existing Buildkite pipeline's configuration, repository, or settings.
`list_builds`	List all builds for a pipeline with their status and commit information.
`get_build`	Retrieve detailed information about a specific build including its jobs and timing.
`create_build`	Trigger a new build on a Buildkite pipeline for a specific commit and branch.
`get_job_logs`	Get the log output and metadata for a specific job.
`unblock_job`	Unblock a blocked job in a Buildkite build to allow it to continue execution.
`search_logs`	Search log entries using regex patterns with optional context lines.
`tail_logs`	Show the last N entries from the log file for recent errors and status checks.
`get_logs_info`	Get metadata and statistics about the Parquet log file.
`read_logs`	Read log entries from the file, optionally starting from a specific row.
`list_artifacts`	List a build's artifacts across all of its jobs, including file details, paths, and sizes.
`get_artifact`	Get detailed information about a specific artifact including its metadata and file size.
`list_annotations`	List all annotations for a build, including their context, style, and rendered HTML content.
`get_test`	Retrieve a specific test in Buildkite Test Engine with failure metadata.
`list_test_runs`	List all test runs for a test suite in Buildkite Test Engine.
`get_test_run`	Retrieve a specific test run in Buildkite Test Engine.
`get_failed_executions`	Retrieve failed test executions for a specific test run, with optional expanded details.
`get_build_test_engine_runs`	Fetch Test Engine runs data for a specific build in Buildkite Pipelines.

Setup Guide

Prerequisites

A Buildkite account
A Buildkite API access token (prefixed bkua_) with the scopes you need (e.g. read_pipelines, read_builds, read_build_logs, write_builds, read_suites)
For local Docker mode: Docker 20.x or later

Option 1: Remote hosted server (recommended)

Point your MCP client at the official hosted server. It uses OAuth (12 hour access tokens, 7 day refresh tokens), so no API token management is needed.

Read/write URL: https://mcp.buildkite.com/mcp
Read-only URL: https://mcp.buildkite.com/mcp/readonly

Option 2: Local server via Docker

docker run --pull=always -q -it --rm -e BUILDKITE_API_TOKEN=<bkua_xxxxx> buildkite/mcp-server stdio

Claude Desktop / Cursor config

{
  "mcpServers": {
    "buildkite": {
      "command": "docker",
      "args": [
        "run", "--pull=always", "-q", "-i", "--rm",
        "-e", "BUILDKITE_API_TOKEN",
        "buildkite/mcp-server",
        "stdio"
      ],
      "env": { "BUILDKITE_API_TOKEN": "bkua_xxxxx" }
    }
  }
}

VS Code config

{
  "inputs": [
    {
      "id": "BUILDKITE_API_TOKEN",
      "type": "promptString",
      "description": "Enter your Buildkite API access token",
      "password": true
    }
  ],
  "servers": {
    "buildkite": {
      "command": "docker",
      "args": [
        "run", "--pull=always", "-q", "-i", "--rm",
        "-e", "BUILDKITE_API_TOKEN",
        "buildkite/mcp-server",
        "stdio"
      ],
      "env": { "BUILDKITE_API_TOKEN": "${input:BUILDKITE_API_TOKEN}" }
    }
  }
}

Option 3: Binary or Go install

# Homebrew
brew install buildkite/buildkite/buildkite-mcp-server

# Go (requires Go 1.24+)
go install github.com/buildkite/buildkite-mcp-server/cmd/buildkite-mcp-server@latest

Or download prebuilt binaries from the GitHub Releases page.

To run as a self-hosted HTTP MCP server on http://localhost:3000/mcp:

buildkite-mcp-server http --api-token=${BUILDKITE_API_TOKEN}

Use Cases

Triage failing CI by asking an agent to fetch the latest build, locate failing jobs, pull their logs, and summarize the root cause.
Trigger or rerun builds from inside an editor: create_build against a specific commit and branch without leaving the chat.
Audit pipeline configuration drift across an organization by listing pipelines and diffing their YAML against expectations.
Investigate flaky tests using list_test_runs, get_test_run, and get_failed_executions from Buildkite Test Engine.
Unblock manual approval steps in a build via unblock_job from a chat-driven release workflow.

Example Prompts

"Show me the last 5 builds on the main branch for the api-server pipeline and flag any failures."
"Pull the job logs for the failed job in build #4821 and summarize what broke."
"Trigger a new build on the web-app pipeline for commit abc123 on branch release/v2."
"List all Test Engine runs for the backend-tests suite this week and show me the most common failed tests."
"Unblock the deploy-production job in build #1042 of the web-app pipeline."

Pros

Officially maintained by Buildkite with active releases and a published Docker image.
Broad coverage of the Buildkite API: pipelines, builds, jobs, logs, artifacts, annotations, clusters, queues, and Test Engine.
Multiple deployment options: hosted OAuth remote server, local Docker, prebuilt binaries, Homebrew, and go install.
Fine-grained scope mapping per tool, so API tokens can be locked down to read-only or specific resources.

Limitations

Local mode counts against your organization's REST API rate limits, while the hosted remote server has separate limits.
The exported Go API is explicitly marked unstable and subject to breaking changes.
Some advanced areas of Buildkite (e.g. agent management, billing) are not exposed; tool coverage is centered on pipelines, builds, and tests.

Alternatives

GitHub MCP Server for GitHub Actions based CI workflows.
CircleCI MCP Server for CircleCI pipelines and insights.
Self-built MCP wrappers around the Buildkite REST or GraphQL APIs if you need capabilities outside what the official server exposes.