Connect Buildkite to ChatGPT: Manage Pipelines, Builds, and Logs

If you need to connect Buildkite to ChatGPT to automate CI/CD workflows, inspect failed build logs, or trigger deployment pipelines natively from a chat interface, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Buildkite's API surface. You can either spend weeks building, hosting, and maintaining a custom MCP server, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL in seconds.

If your team uses Claude, check out our guide on connecting Buildkite to Claude or explore our broader architectural overview on connecting Buildkite to AI Agents.

Giving a Large Language Model (LLM) read and write access to your CI/CD infrastructure is a massive engineering challenge. You have to handle complex nested routing architectures, parse deeply nested artifact payloads, and deal with strict security boundaries. Every time you need a new tool, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Buildkite, connect it natively to ChatGPT, and execute complex DevOps workflows using natural language.

The Engineering Reality of the Buildkite API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Buildkite's API is painful. If you decide to build a custom MCP server for Buildkite, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Buildkite:

The Tripartite Routing Hierarchy

Buildkite does not rely on global UUIDs for most operational endpoints. Instead, the API relies heavily on a strict routing hierarchy: org_slug > pipeline_slug > build_number. For example, to get the logs for a specific job, you cannot just pass a job_id. You must construct a request containing the organization slug, the pipeline slug, the numeric build number (not the build UUID), and the job ID.

If you hand-code an MCP server, you must write custom schema validation to ensure the LLM extracts and provides all four of these routing parameters correctly for every log request. Truto automatically maps these path parameters directly from the Buildkite API specification into the MCP tool schema, forcing the LLM to supply the exact routing path.

REST vs. GraphQL Feature Gaps

Buildkite maintains both a REST API and a GraphQL API. While the industry is pushing toward GraphQL, many critical CI/CD operations - such as downloading artifacts, managing test engine runs, and manipulating annotations - are significantly easier or exclusively available via the REST API. A custom MCP server must often maintain two separate client implementations to provide full coverage. Truto normalizes Buildkite's endpoints into a unified REST-based Proxy API format before exposing them as MCP tools, abstracting away the protocol fragmentation.

Factual Note on Rate Limits and Backoff

Buildkite enforces strict rate limits across its API infrastructure. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When Buildkite returns an HTTP 429 Too Many Requests error, Truto passes that error directly through to the caller (ChatGPT). Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (the LLM client or orchestrator) is entirely responsible for evaluating these headers and executing retry/backoff logic. Truto will not absorb rate limit errors on your behalf.

Buildkite to ChatGPT Quickstart Guide

If you want the fastest path from a fresh Truto account to ChatGPT calling the Buildkite API, follow these steps.

What you need:

• A Truto account with API access.
• A Buildkite account with permissions to generate API access tokens or complete OAuth.
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available (or access to a local config file for desktop clients).

Step 1: Connect Buildkite as an Integrated Account

First, you need to establish the connection between Truto and Buildkite. In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account, select Buildkite, and complete the authentication flow. Truto securely stores the credentials and handles token refreshes automatically.

Grab your integrated_account_id. You can copy it from the account detail page in the UI or list it via the API:

curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"

Step 2: Generate a Buildkite MCP Server

You can generate an MCP server URL scoped exclusively to this Buildkite account. This URL is highly sensitive - it carries routing and authentication in a single string.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your Buildkite connection in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allowed methods, tags, expiration time).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>).

Method B: Via the API You can programmatically generate the server URL via a single POST request. Filter by methods and tags to constrain exactly what ChatGPT can do.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Buildkite for ChatGPT DevOps Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["builds", "pipelines", "jobs", "artifacts"]
    }
  }'

Step 3: Connect the MCP Server to ChatGPT

Now you must register this server with ChatGPT so it can discover and call your Buildkite tools.

Method A: Via the ChatGPT UI

1. Open ChatGPT.
2. Navigate to Settings -> Apps -> Advanced settings.
3. Enable Developer mode (MCP support requires this flag).
4. Under MCP servers / Custom connectors, click add a new server.
5. Enter a Name (e.g., "Buildkite Prod").
6. Paste the Truto MCP URL into the Server URL field and click Save. ChatGPT will immediately connect, perform an initialization handshake, and list the available Buildkite tools.

Method B: Via Manual Config File If you are using an MCP client that requires manual JSON configuration (or testing locally before deploying to ChatGPT), you can use the @modelcontextprotocol/server-sse package to proxy the connection. Add this to your configuration file:

{
  "mcpServers": {
    "buildkite": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_TRUTO_TOKEN>"
      ]
    }
  }
}

Hero Tools for Buildkite

Truto automatically generates tools from the Buildkite API documentation. Here are the highest-leverage tools available for your ChatGPT DevOps agent.

list_all_buildkite_builds

Fetches a paginated list of all builds across your authorized organizations and pipelines. This is the primary discovery tool for finding recent failures or checking pipeline health. It supports filtering by branch, commit, creator, date ranges, and build state.

"Check my Buildkite account for any builds on the 'main' branch that have failed in the last 24 hours."

get_single_buildkite_build_by_id

Retrieves the complete, nested details for a specific build. This returns the pipeline state, commit message, creator, and crucially, the array of jobs associated with the build. You must provide the org_slug, pipeline_slug, and numeric build id.

"Get the detailed status of build number 4592 on the 'payment-service' pipeline in the 'acme-corp' organization."

create_a_buildkite_build

Triggers a new build for a specific pipeline. This tool requires the org_slug, pipeline_slug, commit, and branch. It allows ChatGPT to act as a deployment orchestrator, kicking off rollbacks or hotfixes directly from your conversation.

"Trigger a new build on the 'frontend-web' pipeline in 'acme-corp'. Use the 'hotfix-auth-bug' branch and target the HEAD commit."

buildkite_jobs_get_log

Fetches the raw log output for a specific job within a build. This is the most critical tool for AI-driven incident response, allowing ChatGPT to read the actual stack trace or compiler error that caused a pipeline to fail.

"Fetch the logs for job ID 'jb-123456789' in build 4592 of the 'payment-service' pipeline. Summarize the exact error message causing the failure."

buildkite_builds_retry_failed_jobs

Retries all failed jobs in a specific Buildkite build. Once ChatGPT has investigated a log, identified it as a flaky test or transient network error, it can use this tool to restart the failed steps without kicking off the entire pipeline from scratch.

"The logs indicate a transient database connection timeout. Go ahead and retry the failed jobs for build 4592 on the 'payment-service' pipeline."

buildkite_artifacts_download

Generates a presigned download URL for a specific Buildkite artifact. This allows the AI agent to fetch compiled binaries, test coverage reports, or integration test screenshots stored by the CI environment.

"Get the download URL for the artifact named 'coverage-report.json' from job 'jb-987654321' in build 4592."

To view the complete inventory of available Buildkite endpoints, schemas, and required parameters, visit the Buildkite integration page.

Workflows in Action

Once connected, ChatGPT stops being a simple chatbot and becomes a fully capable DevOps orchestrator. Here are two real-world sequences showing how the LLM routes requests through the Truto MCP server to automate Buildkite operations.

Scenario 1: The Incident Response Triager

An engineer notices a deployment failed in Slack and asks ChatGPT to investigate the root cause and attempt a fix.

"Build 890 on the 'api-gateway' pipeline just failed. Find out which job failed, fetch its logs, tell me the root cause, and if it looks like a transient network error, retry the failed jobs."

Execution Steps:

1. ChatGPT calls get_single_buildkite_build_by_id with pipeline_slug: "api-gateway" and id: "890".
2. The LLM parses the response, identifies the job in the jobs array with state: "failed", and extracts its job_id.
3. ChatGPT calls buildkite_jobs_get_log using that job_id to download the raw terminal output.
4. The LLM reads the log content, identifies a 502 Bad Gateway from an external package registry, and determines it is a transient error.
5. ChatGPT calls buildkite_builds_retry_failed_jobs to restart the job.
6. The LLM replies to the user: "Job 'npm-install' failed due to a 502 error from the npm registry. I have triggered a retry for the failed jobs. The new build state is 'scheduled'."

sequenceDiagram
    participant User as Developer
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP Server
    participant Buildkite as Buildkite API

    User->>ChatGPT: "Build 890 failed. Find the error and retry if transient."
    ChatGPT->>TrutoMCP: tools/call (get_single_buildkite_build_by_id)
    TrutoMCP->>Buildkite: GET /organizations/{org}/pipelines/{pipeline}/builds/890
    Buildkite-->>TrutoMCP: Build data (includes failed job_id)
    TrutoMCP-->>ChatGPT: MCP Result (JSON)
    
    ChatGPT->>TrutoMCP: tools/call (buildkite_jobs_get_log)
    TrutoMCP->>Buildkite: GET /organizations/{org}/pipelines/{pipeline}/builds/890/jobs/{job_id}/log
    Buildkite-->>TrutoMCP: Raw log text
    TrutoMCP-->>ChatGPT: MCP Result (Log output)
    
    ChatGPT->>TrutoMCP: tools/call (buildkite_builds_retry_failed_jobs)
    TrutoMCP->>Buildkite: PUT /organizations/{org}/pipelines/{pipeline}/builds/890/rebuild
    Buildkite-->>TrutoMCP: 200 OK (New build state)
    TrutoMCP-->>ChatGPT: MCP Result (Success)
    
    ChatGPT-->>User: "npm registry returned 502. Retry triggered successfully."

Scenario 2: The Release Engineer

A QA engineer wants to trigger a specific integration testing suite and grab the resulting artifact for a compliance audit.

"Trigger a build on the 'e2e-tests' pipeline for the 'release-v2' branch. Check the status, and once it finishes, get the download link for the 'audit-report.pdf' artifact."

Execution Steps:

1. ChatGPT calls create_a_buildkite_build passing pipeline_slug: "e2e-tests" and branch: "release-v2".
2. The LLM extracts the new build number from the response.
3. ChatGPT calls get_single_buildkite_build_by_id to check the status. (If it is still running, the LLM will wait or inform the user it will take a moment).
4. Once finished, ChatGPT calls list_all_buildkite_artifacts for that build to find the ID of audit-report.pdf.
5. ChatGPT calls buildkite_artifacts_download using the discovered artifact ID.
6. The LLM replies to the user with the pre-signed S3 download URL for the compliance report.

Security and Access Control

Connecting an LLM to your CI/CD infrastructure requires strict governance. Truto provides several mechanisms to lock down your Buildkite MCP server:

• Method Filtering: Configure the server with "methods": ["read"] to allow ChatGPT to read logs and list builds, while strictly blocking create, update, or delete operations. This ensures the agent cannot trigger unauthorized deployments.
• Tag Filtering: Limit the server to specific tool tags like "tags": ["builds", "jobs"]. This prevents the LLM from accidentally modifying organization users, teams, or billing settings.
• API Token Authentication: Enable require_api_token_auth to enforce a second layer of security. The client must supply a valid Truto API token in the Authorization header, ensuring that even if the MCP URL leaks, the server remains secure.
• Expiration Constraints: Use the expires_at field to create temporary, short-lived MCP servers. This is ideal for giving a contractor or temporary AI agent access to Buildkite logs for exactly 24 hours, after which the server is automatically destroyed.

Moving Fast with Managed MCP

Building a custom integration layer for Buildkite requires writing complex pagination handlers, normalizing GraphQL and REST anomalies, and maintaining deployment infrastructure just to get a working tool schema into ChatGPT.

Truto eliminates this technical debt. By dynamically generating documentation-driven MCP tools, handling the OAuth lifecycle, and normalizing upstream rate limits into standard headers, Truto allows your engineering team to focus on building agentic workflows rather than maintaining API boilerplate. You get a production-ready, highly secure connection between ChatGPT and Buildkite in minutes, complete with granular access controls and zero data retention.

Stop managing integration infrastructure. Generate your Buildkite MCP server today.